Faire une vérification

Vous pouvez normaliser vos vérifications au sein d'une route, très simplement avec un checker.

import { useCheckerBuilder } from "@duplojs/http";
import { findOneUser } from "./findOneUser";

export const userExist = useCheckerBuilder({ options: { someOption: "" } })
	.handler(
		async(input: number, { output, options: { someOption } }) => {
			const user = await findOneUser(input);

			if (user) {
				return output("user.find", user);
			} else {
				return output("user.notfound", null);
			}
		},
	);

Pour créer un checker, il vous suffit d'importer la fonction useCheckerBuilder de @duplojs/http et d'appeler la méthode handler du builder. Ce qui est important, c'est de définir l'input de votre checker, mais également de correctement définir vos sorties.

INFO

Les sorties sont accompagnées d'une information, ce qui permet de pouvoir discriminer la sortie facilement.

Implémentation d'un checker dans une route

import { ResponseContract, useRouteBuilder } from "@duplojs/http";
import { DPE } from "@duplojs/utils";
import { userExist } from "./checker";
import { userSchema } from "./schema";

useRouteBuilder("GET", "/users/{userId}")
	.extract({
		params: {
			userId: DPE.coerce.number(),
		},
	})
	.check(
		userExist,
		{
			input: ({ userId }) => userId,
			result: "user.find",
			otherwise: ResponseContract.notFound("user.notfound"),
			indexing: "user",
		},
	)
	.handler(
		ResponseContract.ok("user.find", userSchema),
		({ user }, { response }) => response("user.find", user),
	);

Pour utiliser un checker, il suffit d'utiliser la méthode check du builder de route. Passez le checker en premier argument et configurez son implémentation :

• input : permet de passer la valeur d'entrée au checker depuis le Floor.
• result : définit l'information attendue pour passer à l'étape suivante.
• otherwise : définit la réponse renvoyée si l'information reçue du checker ne correspond pas au result attendu.
• indexing: définit la clé où va être indexée la donnée associée au result défini.

Aller plus vite

Vous pouvez aller beaucoup plus vite en créant un presetChecker.

import { createPresetChecker, ResponseContract } from "@duplojs/http";
import { userExist } from "./checker";

export const iWantUserExist = createPresetChecker(
	userExist,
	{
		result: "user.find",
		otherwise: ResponseContract.notFound("user.notfound"),
	},
);

Il vous suffit d'importer la fonction createPresetChecker de @duplojs/http et de définir ses options d'implémentation par défaut.

import { ResponseContract, useRouteBuilder } from "@duplojs/http";
import { DPE } from "@duplojs/utils";
import { userSchema } from "./schema";
import { iWantUserExist } from "./presetChecker";

useRouteBuilder("GET", "/users/{userId}")
	.extract({
		params: {
			userId: DPE.coerce.number(),
		},
	})
	.presetCheck(
		iWantUserExist.indexing("user"),
		({ userId }) => userId,
	)
	.handler(
		ResponseContract.ok("user.find", userSchema),
		({ user }, { response }) => response("user.find", user),
	);

Utilisez la méthode presetCheck du builder de route et implémentez facilement votre checker, sans oublier une fonction d'input pour lui envoyer la donnée que vous voulez.

Cas particulier

Parfois, il arrive d'être dans un cas particulier où la création d'un checker pour factoriser du code n'est pas utile. Vous souhaitez juste appeler une fonction et continuer ou stopper l'exécution de la route. Il existe pour cela les étapes cut.

import { ResponseContract, useRouteBuilder } from "@duplojs/http";
import { DPE } from "@duplojs/utils";
import { userSchema } from "./schema";
import { findOneUser } from "./findOneUser";

useRouteBuilder("GET", "/users/{userId}")
	.extract({
		params: {
			userId: DPE.coerce.number(),
		},
	})
	.cut(
		[
			ResponseContract.notFound("user.notfound"),
			ResponseContract.forbidden("user.inaccessible"),
		],
		async({ userId }, { response, output }) => {
			if (userId === 0) {
				return response("user.inaccessible");
			}

			const user = await findOneUser(userId);

			if (!user) {
				return response("user.notfound");
			}

			return output({ user });
		},
	)
	.handler(
		ResponseContract.ok("user.find", userSchema),
		({ user }, { response }) => response("user.find", user),
	);

Utilisez la méthode cut du builder de route pour créer votre étape sur mesure. Celle-ci est semblable à la méthode handler, sauf qu'elle n'est pas la dernière étape de votre route. Vous avez la possibilité, dans une étape cut, de répondre ou de passer à l'étape suivante avec la possibilité d'ajouter une donnée à la route.

WARNING

Les exemples ci-dessus n’encouragent en aucun cas à faire du code métier dans un checker ou un cut. Ils sont juste là pour illustrer les différentes fonctions et moyens que vous avez à votre disposition pour que vous puissiez évaluer le potentiel et être autonome le plus rapidement possible.