file

Construit un parser pour les fichiers. DServerDataParser.file() garantit que l'entrée est un FileInterface (avec support optionnel de la coercition) et retourne un Either typé contenant soit la valeur validée, soit un DataParserError détaillé.

Exemple

import { SDP, type SF } from "@duplojs/server-utils";
import { E, type ExpectType, type DP } from "@duplojs/utils";

const schema = SDP.coerce.file({
	checkers: [SDP.checkerFileMimeType(/^application\/json$/)],
});

const result = schema.parse("/path/file.json");

if (E.isRight(result)) {
	type check = ExpectType<
		typeof result,
		E.Success<SF.FileInterface>,
		"strict"
	>;
} else {
	type check = ExpectType<
		typeof result,
		E.Error<DP.DataParserError>,
		"strict"
	>;
}

Paramètres

• errorMessage : message personnalisé utilisé lorsque l'entrée n'est pas un fichier et par défaut par les checkers qui ne définissent pas leur propre message.
• checkers : tableau de checkers (checkerFileSize, checkerFileExist, checkerFileMimeType, checkerRefine, etc.) exécutés après la validation de base.
• coerce : true pour transformer un chemin en FileInterface. Par défaut false.

Valeur de retour

Un DataParserFile disposant de parse, asyncParse, exec, asyncExec, addChecker et clone.

Le parser File est synchrone par défaut. checkerFileMimeType est également synchrone, tandis que checkerFileExist et checkerFileSize sont asynchrones, car ils lisent les informations du fichier.

• schema.parse(data) exécute les validations synchrones et renvoie un DEither.Success<FileInterface> ou un DEither.Error<DataParserError>. Il renvoie une erreur lorsque le parser contient un checker asynchrone.
• schema.asyncParse(data) attend les checkers asynchrones et renvoie une Promise<DEither.Success<FileInterface>> ou une Promise<DEither.Error<DataParserError>>.

Autres exemples

Checkers personnalisés

import { SDP, type SF } from "@duplojs/server-utils";
import { E, type ExpectType, type DP } from "@duplojs/utils";

const schema = SDP
	.coerce
	.file()
	.addChecker(
		SDP.checkerFileExist(),
		SDP.checkerFileSize(
			{
				min: 1,
				max: 5_000_000,
			},
			{ errorMessage: "file.invalid-size" },
		),
		SDP.checkerFileMimeType(/^image\/(?:png|jpeg)$/),
	);

const result = await schema.asyncParse("/path/image.png");

if (E.isRight(result)) {
	type check = ExpectType<
		typeof result,
		E.Success<SF.FileInterface>,
		"strict"
	>;
} else {
	type check = ExpectType<
		typeof result,
		E.Error<DP.DataParserError>,
		"strict"
	>;
}

Mode étendu

import { SDPE, type SF } from "@duplojs/server-utils";
import { E, type ExpectType, type DP } from "@duplojs/utils";

const schema = SDPE
	.coerce
	.file()
	.exist()
	.mimeType(/^image\/(?:png|jpeg)$/)
	.size({ max: 5_000_000 });

const result = await schema.asyncParse("/path/image.png");

if (E.isRight(result)) {
	type check = ExpectType<
		typeof result,
		E.Success<SF.FileInterface>,
		"strict"
	>;
} else {
	type check = ExpectType<
		typeof result,
		E.Error<DP.DataParserError>,
		"strict"
	>;
}

Différence entre parse et asyncParse

import { SDP, type SF } from "@duplojs/server-utils";
import { E, type DP, type ExpectType } from "@duplojs/utils";

const schema = SDP.coerce.file({
	checkers: [
		SDP.checkerFileExist(),
		SDP.checkerFileSize({ max: 2_000_000 }),
	],
});

const syncResult = schema.parse("/path/file.json");
Incorrect: parse cannot execute asynchronous checkers.

const asyncResult = await schema.asyncParse("/path/file.json");
Correct: asyncParse awaits asynchronous checkers.

if (E.isRight(asyncResult)) {
	type check = ExpectType<
		typeof asyncResult,
		E.Success<SF.FileInterface>,
		"strict"
	>;
} else {
	type check = ExpectType<
		typeof asyncResult,
		E.Error<DP.DataParserError>,
		"strict"
	>;
}

INFO

Cet exemple utilise checkerFileExist et checkerFileSize, deux checkers asynchrones qui lisent les informations du fichier. Il faut donc utiliser asyncParse pour attendre leur résultat. L'utilisation de parse sur ce parser retourne un DataParserError, car il ne peut pas exécuter ces checkers asynchrones.

Voir aussi

• fileInterface - Crée une interface fichier.