Récupérer des données

import { ResponseContract, useRouteBuilder } from "@duplojs/http";
import { DPE } from "@duplojs/utils";

useRouteBuilder("POST", "/users/{userId}")
	.extract({
		params: {
			userId: DPE.coerce.number(),
		},
		query: {
			someValue: DPE.string().optional(),
			superQuery: DPE.coerce.number(),
		},
	})
	.extract({
		headers: {
			token: DPE.string(),
		},
		body: DPE.object({
			username: DPE.string(),
			age: DPE.string(),
		}),
	})
	.handler(
		ResponseContract.noContent("someInformation"),
		(floor, { response }) => {
			const {
				someValue,
				superQuery,
				token,
				userId,
				body: {
					username,
					age,
				},
			} = floor;

			return response("someInformation");
		},
	);

Pour récupérer des données sur une requête, il suffit d'appeler la méthode extract du route builder, ce qui ajoutera une étape d'extraction de données à votre route. Cette étape d'extraction utilise forcément un dataParser de la lib @duplojs/utils. Cela permet de valider les données avant de les utiliser.

Les données sont ensuite disponibles dans le Floor, qui est un objet qui contient l'accumulation de données de la route. Les données peuvent provenir d'étapes d'extraction ou d'autres étapes comme les checkeurs, les processus, les cuts, etc.

Profondeur d'extraction

import { useRouteBuilder } from "@duplojs/http";
import { DPE } from "@duplojs/utils";

useRouteBuilder("POST", "/users/{userId}")
	.extract({
		headers: {
			token: DPE.string(),
		},
		body: DPE.object({
			username: DPE.string(),
			age: DPE.string(),
		}),
	});

L'extraction de données peut se faire sur deux niveaux. La clé de stockage sera la clé du dataParser.

Recevoir du FormData

import { controlBodyAsFormData, ResponseContract, useRouteBuilder } from "@duplojs/http";
import { SDPE } from "@duplojs/server-utils";
import { asserts, DPE, E, O, Path } from "@duplojs/utils";

useRouteBuilder("POST", "/documents", {
	bodyController: controlBodyAsFormData({ maxFileQuantity: 5 }),
})
	.extract({
		body: {
			userId: DPE.coerce.number(),
			files: SDPE.file().array().max(3),
		},
	})
	.handler(
		ResponseContract.noContent("files.receive"),
		async({ files, userId }, { response }) => {
			for (const [index, file] of O.entries(files)) {
				asserts(
					await file.move(
						Path.resolveRelative([
							"new/path/of/file",
							`${userId}-${index}${file.getExtension() ?? ""}`,
						]),
					),
					E.isRight,
				);
			}

			return response("files.receive");
		},
	);

Pour recevoir du FormData, il vous suffit de configurer un bodyController sur votre route. Cela permet d'indiquer à la route qu'elle doit se préparer à recevoir un flux de FormData lors d'une requête. Les paramètres définis pour ce bodyController s'appliquent pendant le flux du body, contrairement au dataParser qui s'applique après la réception du body.

INFO

Les schémas d'extraction peuvent avoir la même complexité que ceux d'un JSON, car le serializer de FormData utilisé permet des niveaux de profondeur supérieurs au FormData de base.

L'extraction de fichiers se fait via le dataParser file (SDPE.file()) provenant de la librairie @duplojs/server-utils.