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({
	mimeType: "application/json",
});

const result = await schema.asyncParse("/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é injecté dans chaque issue lorsque l'entrée n'est pas un fichier ou ne respecte pas les contraintes.
• coerce : true pour transformer un chemin en FileInterface. Par défaut false.
• mimeType?: string, [string, ...string[]] ou RegExp appliqué au mime type du fichier.
• minSize?: number ou BytesInString (${number}${"b" | "kb" | "mb"...}) pour contraindre une taille minimale au fichier. Cette vérification est effectuée uniquement via asyncParse.
• maxSize?: number ou BytesInString (${number}${"b" | "kb" | "mb"...}) pour contraindre une taille maximale au fichier. Cette vérification est effectuée uniquement via asyncParse.
• checkExist?: true pour vérifier que le fichier existe réellement. Cette vérification est effectuée uniquement via asyncParse.

Valeur de retour

Un DataParserFile disposant de parse, asyncParse, isAsynchronous et clone.

• schema.parse(data) renvoie un DEither.Success<FileInterface> lorsque les validations synchrones passent, ou un DEither.Error<DataParserError>. Si checkExist, minSize ou maxSize sont activés, ce mode synchrone renvoie directement une erreur car ces contrôles nécessitent l'async.
• schema.asyncParse(data) exécute les validations complètes (dont existence réelle et contraintes de taille) et renvoie une Promise<DEither.Success<FileInterface>> lorsque toutes les validations passent, ou une Promise<DEither.Error<DataParserError>> avec les chemins (path), les messages et les valeurs rejetées.

Autres exemples

Mode étendu

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

const schema = SDPE
	.coerce
	.file()
	.mustExist()
	.mimeType(["image/png", "image/jpeg"])
	.maxSize("5mb");

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({
	checkExist: true,
	maxSize: "2mb",
});

// parse returns an Either immediately and cannot execute async I/O checks.
const syncResult = schema.parse("/path/file.json");

if (E.isLeft(syncResult)) {
	type check = ExpectType<
		typeof syncResult,
		E.Error<DP.DataParserError>,
		"strict"
	>;
}

// asyncParse runs full checks (existence and size) and returns Promise<Either>.
const asyncResult = await schema.asyncParse("/path/file.json");

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"
	>;
}

Voir aussi

• fileInterface - Crée une interface fichier.