@grupodiariodaregiao/bunstone 0.2.7 → 0.2.9

package/dist/index.js

@@ -67726,6 +67726,85 @@ var ZodRealError = $constructor("ZodError", initializer2, {
   Parent: Error
 });
 
+// lib/http-exceptions.ts
+class HttpException extends Error {
+  status;
+  response;
+  constructor(response, status) {
+    const responseObj = typeof response === "string" ? { message: response } : response;
+    super(JSON.stringify(responseObj));
+    this.status = status;
+    this.response = responseObj;
+    Object.setPrototypeOf(this, HttpException.prototype);
+  }
+  getResponse() {
+    return this.response;
+  }
+  getStatus() {
+    return this.status;
+  }
+}
+
+class BadRequestException extends HttpException {
+  constructor(response = "Bad Request") {
+    super(response, 400);
+  }
+}
+
+class UnauthorizedException extends HttpException {
+  constructor(response = "Unauthorized") {
+    super(response, 401);
+  }
+}
+
+class ForbiddenException extends HttpException {
+  constructor(response = "Forbidden") {
+    super(response, 403);
+  }
+}
+
+class NotFoundException extends HttpException {
+  constructor(response = "Not Found") {
+    super(response, 404);
+  }
+}
+
+class ConflictException extends HttpException {
+  constructor(response = "Conflict") {
+    super(response, 409);
+  }
+}
+
+class UnprocessableEntityException extends HttpException {
+  constructor(response = "Unprocessable Entity") {
+    super(response, 422);
+  }
+}
+
+class InternalServerErrorException extends HttpException {
+  constructor(response = "Internal Server Error") {
+    super(response, 500);
+  }
+}
+
+class OkResponse extends HttpException {
+  constructor(response = "OK") {
+    super(response, 200);
+  }
+}
+
+class CreatedResponse extends HttpException {
+  constructor(response = "Created") {
+    super(response, 201);
+  }
+}
+
+class NoContentResponse extends HttpException {
+  constructor() {
+    super("", 204);
+  }
+}
+
 // lib/utils/is-zod-schema.ts
 var isZodSchema = (obj) => {
   return obj && typeof obj === "object" && typeof obj.parse === "function";
@@ -67852,8 +67931,15 @@ async function processParameters(request, target, propertyKey) {
       }
     } catch (e2) {
       if (e2 instanceof ZodError) {
-        badRequest(e2.issues.map((issue) => issue.message).join(", "));
+        throw new BadRequestException({
+          status: 400,
+          errors: e2.issues.map((issue) => ({
+            field: issue.path.join("."),
+            message: issue.message
+          }))
+        });
       }
+      throw e2;
     }
   }
   return args;
@@ -67965,10 +68051,7 @@ function appendValue(formData, key, value) {
   }
 }
 function badRequest(message) {
-  throw new Response(JSON.stringify({ error: message }), {
-    status: 400,
-    headers: { "content-type": "application/json" }
-  });
+  throw new BadRequestException(message);
 }
 
 // lib/adapters/form-data.ts
@@ -68283,84 +68366,6 @@ QueryBus = __legacyDecorateClassTS([
   Injectable()
 ], QueryBus);
 
-// lib/http-exceptions.ts
-class HttpException extends Error {
-  response;
-  status;
-  constructor(response, status) {
-    super(typeof response === "string" ? response : JSON.stringify(response));
-    this.response = response;
-    this.status = status;
-    Object.setPrototypeOf(this, HttpException.prototype);
-  }
-  getResponse() {
-    return this.response;
-  }
-  getStatus() {
-    return this.status;
-  }
-}
-
-class BadRequestException extends HttpException {
-  constructor(response = "Bad Request") {
-    super(response, 400);
-  }
-}
-
-class UnauthorizedException extends HttpException {
-  constructor(response = "Unauthorized") {
-    super(response, 401);
-  }
-}
-
-class ForbiddenException extends HttpException {
-  constructor(response = "Forbidden") {
-    super(response, 403);
-  }
-}
-
-class NotFoundException extends HttpException {
-  constructor(response = "Not Found") {
-    super(response, 404);
-  }
-}
-
-class ConflictException extends HttpException {
-  constructor(response = "Conflict") {
-    super(response, 409);
-  }
-}
-
-class UnprocessableEntityException extends HttpException {
-  constructor(response = "Unprocessable Entity") {
-    super(response, 422);
-  }
-}
-
-class InternalServerErrorException extends HttpException {
-  constructor(response = "Internal Server Error") {
-    super(response, 500);
-  }
-}
-
-class OkResponse extends HttpException {
-  constructor(response = "OK") {
-    super(response, 200);
-  }
-}
-
-class CreatedResponse extends HttpException {
-  constructor(response = "Created") {
-    super(response, 201);
-  }
-}
-
-class NoContentResponse extends HttpException {
-  constructor() {
-    super("", 204);
-  }
-}
-
 // lib/openapi.ts
 var import_reflect_metadata12 = __toESM(require_Reflect(), 1);
 var API_TAGS_METADATA = "dip:openapi:tags";
@@ -68612,11 +68617,37 @@ class AppStartup {
     AppStartup.elysia.error({
       HttpException
     });
-    AppStartup.elysia.onError(({ error, set }) => {
+    AppStartup.elysia.onError(({ code: code2, error, set }) => {
       if (error instanceof HttpException) {
         set.status = error.getStatus();
         return error.getResponse();
       }
+      if (code2 === "VALIDATION") {
+        set.status = 400;
+        const extractField = (path) => {
+          if (Array.isArray(path)) {
+            return path.join(".").replace(/^body\./, "").replace(/^query\./, "").replace(/^params\./, "");
+          }
+          if (typeof path === "string") {
+            return path.replace(/^body\./, "").replace(/^query\./, "").replace(/^params\./, "");
+          }
+          return "";
+        };
+        const allErrors = error.all;
+        const errors = Array.isArray(allErrors) && allErrors.length > 0 ? allErrors.map((err) => ({
+          field: extractField(err.path),
+          message: err.message
+        })) : [
+          {
+            field: extractField(error.path),
+            message: error.message
+          }
+        ];
+        return {
+          status: 400,
+          errors
+        };
+      }
       return error;
     });
     if (options?.cors) {

package/dist/lib/http-exceptions.d.ts

@@ -2,10 +2,10 @@
  * Base class for all HTTP exceptions.
  */
 export declare class HttpException extends Error {
-    readonly response: string | object;
     readonly status: number;
+    readonly response: object;
     constructor(response: string | object, status: number);
-    getResponse(): string | object;
+    getResponse(): object;
     getStatus(): number;
 }
 /**

package/lib/app-startup.ts

@@ -79,11 +79,52 @@ export class AppStartup {
 			HttpException,
 		});
 
-		AppStartup.elysia.onError(({ error, set }) => {
+		AppStartup.elysia.onError(({ code, error, set }) => {
 			if (error instanceof HttpException) {
 				set.status = error.getStatus();
 				return error.getResponse();
 			}
+
+			if (code === "VALIDATION") {
+				set.status = 400;
+
+				const extractField = (path: any): string => {
+					if (Array.isArray(path)) {
+						return path
+							.join(".")
+							.replace(/^body\./, "")
+							.replace(/^query\./, "")
+							.replace(/^params\./, "");
+					}
+					if (typeof path === "string") {
+						return path
+							.replace(/^body\./, "")
+							.replace(/^query\./, "")
+							.replace(/^params\./, "");
+					}
+					return "";
+				};
+
+				const allErrors = (error as any).all;
+				const errors =
+					Array.isArray(allErrors) && allErrors.length > 0
+						? allErrors.map((err: any) => ({
+								field: extractField(err.path),
+								message: err.message,
+							}))
+						: [
+								{
+									field: extractField((error as any).path),
+									message: error.message,
+								},
+							];
+
+				return {
+					status: 400,
+					errors,
+				};
+			}
+
 			return error;
 		});
 

package/lib/http-exceptions.ts

@@ -2,11 +2,16 @@
  * Base class for all HTTP exceptions.
  */
 export class HttpException extends Error {
+	public readonly response: object;
+
 	constructor(
-		public readonly response: string | object,
+		response: string | object,
 		public readonly status: number,
 	) {
-		super(typeof response === "string" ? response : JSON.stringify(response));
+		const responseObj =
+			typeof response === "string" ? { message: response } : response;
+		super(JSON.stringify(responseObj));
+		this.response = responseObj;
 		Object.setPrototypeOf(this, HttpException.prototype);
 	}
 

package/lib/http-params.ts

@@ -1,395 +1,400 @@
 import "reflect-metadata";
 import { ZodError, type ZodType } from "zod/v4";
 import { PARAM_METADATA_KEY } from "./constants";
+import { BadRequestException } from "./http-exceptions";
 import { isZodSchema } from "./utils/is-zod-schema";
 
 export enum ParamType {
-  BODY = "body",
-  QUERY = "query",
-  PARAM = "param",
-  HEADER = "header",
-  REQUEST = "request",
-  FORM_DATA = "form-data",
+	BODY = "body",
+	QUERY = "query",
+	PARAM = "param",
+	HEADER = "header",
+	REQUEST = "request",
+	FORM_DATA = "form-data",
 }
 
 function setParamMetadata(
-  target: any,
-  propertyKey: string | symbol,
-  parameterIndex: number,
-  type: ParamType,
-  key?: string,
-  options?: unknown
+	target: any,
+	propertyKey: string | symbol,
+	parameterIndex: number,
+	type: ParamType,
+	key?: string,
+	options?: unknown,
 ) {
-  const existingParams =
-    Reflect.getOwnMetadata(PARAM_METADATA_KEY, target, propertyKey) || [];
+	const existingParams =
+		Reflect.getOwnMetadata(PARAM_METADATA_KEY, target, propertyKey) || [];
 
-  existingParams.push({ index: parameterIndex, type, key, options });
+	existingParams.push({ index: parameterIndex, type, key, options });
 
-  Reflect.defineMetadata(
-    PARAM_METADATA_KEY,
-    existingParams,
-    target,
-    propertyKey
-  );
+	Reflect.defineMetadata(
+		PARAM_METADATA_KEY,
+		existingParams,
+		target,
+		propertyKey,
+	);
 }
 
 export function Body(schema?: ZodType): any;
 export function Body(): any {
-  if (arguments.length === 1) {
-    const arg = arguments[0] as ZodType;
-    if (isZodSchema(arg)) {
-      return (target: any, propertyKey: any, parameterIndex: any) => {
-        setParamMetadata(
-          target,
-          propertyKey as string,
-          parameterIndex,
-          ParamType.BODY,
-          undefined,
-          { zodSchema: arg }
-        );
-      };
-    }
-  }
-
-  return (target: any, propertyKey: any, parameterIndex: any) => {
-    setParamMetadata(
-      target,
-      propertyKey as string,
-      parameterIndex,
-      ParamType.BODY
-    );
-  };
+	if (arguments.length === 1) {
+		const arg = arguments[0] as ZodType;
+		if (isZodSchema(arg)) {
+			return (target: any, propertyKey: any, parameterIndex: any) => {
+				setParamMetadata(
+					target,
+					propertyKey as string,
+					parameterIndex,
+					ParamType.BODY,
+					undefined,
+					{ zodSchema: arg },
+				);
+			};
+		}
+	}
+
+	return (target: any, propertyKey: any, parameterIndex: any) => {
+		setParamMetadata(
+			target,
+			propertyKey as string,
+			parameterIndex,
+			ParamType.BODY,
+		);
+	};
 }
 
 export function Param(schema?: ZodType): any;
 export function Param(key?: string): any;
 export function Param(): any {
-  let key: string | undefined;
-  if (arguments.length === 1) {
-    if (isZodSchema(arguments[0])) {
-      return function (target: any, propertyKey: any, parameterIndex: any) {
-        setParamMetadata(
-          target,
-          propertyKey as string,
-          parameterIndex,
-          ParamType.PARAM,
-          undefined,
-          {
-            zodSchema: arguments[0] as ZodType,
-          }
-        );
-      };
-    }
-    key = arguments[0] as string;
-  }
-
-  return (target: any, propertyKey: any, parameterIndex: any) => {
-    setParamMetadata(
-      target,
-      propertyKey as string,
-      parameterIndex,
-      ParamType.PARAM,
-      key
-    );
-  };
+	let key: string | undefined;
+	if (arguments.length === 1) {
+		if (isZodSchema(arguments[0])) {
+			return function (target: any, propertyKey: any, parameterIndex: any) {
+				setParamMetadata(
+					target,
+					propertyKey as string,
+					parameterIndex,
+					ParamType.PARAM,
+					undefined,
+					{
+						zodSchema: arguments[0] as ZodType,
+					},
+				);
+			};
+		}
+		key = arguments[0] as string;
+	}
+
+	return (target: any, propertyKey: any, parameterIndex: any) => {
+		setParamMetadata(
+			target,
+			propertyKey as string,
+			parameterIndex,
+			ParamType.PARAM,
+			key,
+		);
+	};
 }
 
 export function Query(schema?: ZodType): any;
 export function Query(key?: string): any;
 export function Query(): any {
-  let key: string | undefined;
-  if (arguments.length === 1) {
-    if (isZodSchema(arguments[0])) {
-      return function (target: any, propertyKey: any, parameterIndex: any) {
-        setParamMetadata(
-          target,
-          propertyKey as string,
-          parameterIndex,
-          ParamType.QUERY,
-          undefined,
-          {
-            zodSchema: arguments[0] as ZodType,
-          }
-        );
-      };
-    }
-    key = arguments[0] as string;
-  }
-
-  return (target: any, propertyKey: any, parameterIndex: any) => {
-    setParamMetadata(
-      target,
-      propertyKey as string,
-      parameterIndex,
-      ParamType.QUERY,
-      key
-    );
-  };
+	let key: string | undefined;
+	if (arguments.length === 1) {
+		if (isZodSchema(arguments[0])) {
+			return function (target: any, propertyKey: any, parameterIndex: any) {
+				setParamMetadata(
+					target,
+					propertyKey as string,
+					parameterIndex,
+					ParamType.QUERY,
+					undefined,
+					{
+						zodSchema: arguments[0] as ZodType,
+					},
+				);
+			};
+		}
+		key = arguments[0] as string;
+	}
+
+	return (target: any, propertyKey: any, parameterIndex: any) => {
+		setParamMetadata(
+			target,
+			propertyKey as string,
+			parameterIndex,
+			ParamType.QUERY,
+			key,
+		);
+	};
 }
 
 export function Header(key: string): any {
-  return (target: any, propertyKey: any, parameterIndex: any) => {
-    setParamMetadata(
-      target,
-      propertyKey,
-      parameterIndex,
-      ParamType.HEADER,
-      key
-    );
-  };
+	return (target: any, propertyKey: any, parameterIndex: any) => {
+		setParamMetadata(
+			target,
+			propertyKey,
+			parameterIndex,
+			ParamType.HEADER,
+			key,
+		);
+	};
 }
 
 export function Request(): any {
-  return (target: any, propertyKey: any, parameterIndex: any) => {
-    setParamMetadata(target, propertyKey, parameterIndex, ParamType.REQUEST);
-  };
+	return (target: any, propertyKey: any, parameterIndex: any) => {
+		setParamMetadata(target, propertyKey, parameterIndex, ParamType.REQUEST);
+	};
 }
 
 export async function processParameters(
-  request: any,
-  target: any,
-  propertyKey: string
+	request: any,
+	target: any,
+	propertyKey: string,
 ): Promise<any[]> {
-  const paramMetadata =
-    Reflect.getOwnMetadata(
-      PARAM_METADATA_KEY,
-      Object.getPrototypeOf(target),
-      propertyKey
-    ) || [];
-
-  const paramTypes =
-    Reflect.getMetadata("design:paramtypes", target, propertyKey) || [];
-
-  const args: any[] = new Array(paramTypes.length);
-  let cachedFormData: FormData | null = null;
-
-  for (const metadata of paramMetadata) {
-    const { index, type, key } = metadata;
-
-    switch (type) {
-      case ParamType.BODY:
-        try {
-          args[index] = request.body;
-        } catch (_e) {
-          args[index] = null;
-        }
-        break;
-
-      case ParamType.QUERY:
-        if (key) {
-          args[index] = request.query?.[key];
-        } else {
-          args[index] = request.query;
-        }
-        break;
-
-      case ParamType.PARAM:
-        if (key === undefined) {
-          args[index] = request.params;
-        } else {
-          args[index] = request.params?.[key];
-        }
-        break;
-
-      case ParamType.HEADER:
-        if (key) {
-          args[index] = request.headers?.[key];
-        }
-        break;
-
-      case ParamType.REQUEST:
-        args[index] = request;
-        break;
-
-      case ParamType.FORM_DATA:
-        cachedFormData = cachedFormData || (await readFormData(request));
-        args[index] = extractFormDataPayload(
-          cachedFormData,
-          metadata.options as FormDataOptions | undefined
-        );
-        break;
-    }
-
-    try {
-      if (metadata.options?.zodSchema) {
-        const zodSchema = metadata.options.zodSchema as ZodType;
-        if (isZodSchema(zodSchema)) {
-          args[index] = zodSchema.parse(args[index]);
-        }
-      }
-    } catch (e) {
-      if (e instanceof ZodError) {
-        badRequest(e.issues.map((issue) => issue.message).join(", "));
-      }
-    }
-  }
-
-  return args;
+	const paramMetadata =
+		Reflect.getOwnMetadata(
+			PARAM_METADATA_KEY,
+			Object.getPrototypeOf(target),
+			propertyKey,
+		) || [];
+
+	const paramTypes =
+		Reflect.getMetadata("design:paramtypes", target, propertyKey) || [];
+
+	const args: any[] = new Array(paramTypes.length);
+	let cachedFormData: FormData | null = null;
+
+	for (const metadata of paramMetadata) {
+		const { index, type, key } = metadata;
+
+		switch (type) {
+			case ParamType.BODY:
+				try {
+					args[index] = request.body;
+				} catch (_e) {
+					args[index] = null;
+				}
+				break;
+
+			case ParamType.QUERY:
+				if (key) {
+					args[index] = request.query?.[key];
+				} else {
+					args[index] = request.query;
+				}
+				break;
+
+			case ParamType.PARAM:
+				if (key === undefined) {
+					args[index] = request.params;
+				} else {
+					args[index] = request.params?.[key];
+				}
+				break;
+
+			case ParamType.HEADER:
+				if (key) {
+					args[index] = request.headers?.[key];
+				}
+				break;
+
+			case ParamType.REQUEST:
+				args[index] = request;
+				break;
+
+			case ParamType.FORM_DATA:
+				cachedFormData = cachedFormData || (await readFormData(request));
+				args[index] = extractFormDataPayload(
+					cachedFormData,
+					metadata.options as FormDataOptions | undefined,
+				);
+				break;
+		}
+
+		try {
+			if (metadata.options?.zodSchema) {
+				const zodSchema = metadata.options.zodSchema as ZodType;
+				if (isZodSchema(zodSchema)) {
+					args[index] = zodSchema.parse(args[index]);
+				}
+			}
+		} catch (e) {
+			if (e instanceof ZodError) {
+				throw new BadRequestException({
+					status: 400,
+					errors: e.issues.map((issue) => ({
+						field: issue.path.join("."),
+						message: issue.message,
+					})),
+				});
+			}
+			throw e;
+		}
+	}
+
+	return args;
 }
 
 export type FormDataOptions = {
-  fileField?: string;
-  allowedTypes?: string[];
-  jsonField?: string;
+	fileField?: string;
+	allowedTypes?: string[];
+	jsonField?: string;
 };
 
 export type FormDataFields = Record<string, string | string[]>;
 
 export type FormDataPayload = {
-  files: File[];
-  json?: unknown;
+	files: File[];
+	json?: unknown;
 };
 
 const FORM_DATA_CACHE = Symbol.for("dip:form-data-cache");
 
 async function readFormData(request: any): Promise<FormData> {
-  if (request?.[FORM_DATA_CACHE]) {
-    return request[FORM_DATA_CACHE];
-  }
-
-  const existingBody = request?.body;
-  const bodyAsFormData = tryResolveFromBody(existingBody);
-  if (bodyAsFormData) {
-    request[FORM_DATA_CACHE] = bodyAsFormData;
-    return bodyAsFormData;
-  }
-
-  const requestLike = request?.request || request?.raw || request;
-
-  if (!requestLike || typeof requestLike.formData !== "function") {
-    throw new Error("FormData is not available on this request.");
-  }
-
-  let formData: FormData;
-  try {
-    formData =
-      typeof requestLike.clone === "function"
-        ? await requestLike.clone().formData()
-        : await requestLike.formData();
-  } catch (err: any) {
-    const fallback = tryResolveFromBody(existingBody);
-    if (fallback) {
-      request[FORM_DATA_CACHE] = fallback;
-      return fallback;
-    }
-
-    const reason =
-      err instanceof Error
-        ? err.message
-        : "Body already consumed or unreadable";
-    throw new Error(
-      `Could not read multipart form data from the request. ${reason}`
-    );
-  }
-
-  if (!(formData instanceof FormData)) {
-    throw new Error("Could not read multipart form data from the request.");
-  }
-
-  request[FORM_DATA_CACHE] = formData;
-  return formData;
+	if (request?.[FORM_DATA_CACHE]) {
+		return request[FORM_DATA_CACHE];
+	}
+
+	const existingBody = request?.body;
+	const bodyAsFormData = tryResolveFromBody(existingBody);
+	if (bodyAsFormData) {
+		request[FORM_DATA_CACHE] = bodyAsFormData;
+		return bodyAsFormData;
+	}
+
+	const requestLike = request?.request || request?.raw || request;
+
+	if (!requestLike || typeof requestLike.formData !== "function") {
+		throw new Error("FormData is not available on this request.");
+	}
+
+	let formData: FormData;
+	try {
+		formData =
+			typeof requestLike.clone === "function"
+				? await requestLike.clone().formData()
+				: await requestLike.formData();
+	} catch (err: any) {
+		const fallback = tryResolveFromBody(existingBody);
+		if (fallback) {
+			request[FORM_DATA_CACHE] = fallback;
+			return fallback;
+		}
+
+		const reason =
+			err instanceof Error
+				? err.message
+				: "Body already consumed or unreadable";
+		throw new Error(
+			`Could not read multipart form data from the request. ${reason}`,
+		);
+	}
+
+	if (!(formData instanceof FormData)) {
+		throw new Error("Could not read multipart form data from the request.");
+	}
+
+	request[FORM_DATA_CACHE] = formData;
+	return formData;
 }
 
 function extractFormDataPayload(
-  formData: FormData,
-  options: FormDataOptions = {}
+	formData: FormData,
+	options: FormDataOptions = {},
 ): FormDataPayload {
-  const { fileField, allowedTypes, jsonField } = options;
-  const files: File[] = [];
-
-  const allowed = (allowedTypes || []).map((item) => item.toLowerCase());
-  const getFiles = fileField
-    ? formData.getAll(fileField)
-    : Array.from(formData.values());
-
-  for (const value of getFiles) {
-    if (value instanceof File) {
-      if (allowed.length > 0 && !isAllowedFileType(value, allowed)) {
-        badRequest(
-          `File type for "${
-            value.name
-          }" is not allowed. Allowed: ${allowed.join(", ")}`
-        );
-      }
-
-      files.push(value);
-    }
-  }
-
-  let parsedJson: unknown;
-
-  if (jsonField) {
-    const rawJson = formData.get(jsonField);
-
-    if (typeof rawJson === "string") {
-      try {
-        parsedJson = JSON.parse(rawJson);
-      } catch {
-        badRequest(`Failed to parse JSON field "${jsonField}".`);
-      }
-    } else if (rawJson !== null) {
-      badRequest(`JSON field "${jsonField}" must be a string value.`);
-    }
-  }
-
-  return {
-    files,
-    json: parsedJson,
-  };
+	const { fileField, allowedTypes, jsonField } = options;
+	const files: File[] = [];
+
+	const allowed = (allowedTypes || []).map((item) => item.toLowerCase());
+	const getFiles = fileField
+		? formData.getAll(fileField)
+		: Array.from(formData.values());
+
+	for (const value of getFiles) {
+		if (value instanceof File) {
+			if (allowed.length > 0 && !isAllowedFileType(value, allowed)) {
+				badRequest(
+					`File type for "${
+						value.name
+					}" is not allowed. Allowed: ${allowed.join(", ")}`,
+				);
+			}
+
+			files.push(value);
+		}
+	}
+
+	let parsedJson: unknown;
+
+	if (jsonField) {
+		const rawJson = formData.get(jsonField);
+
+		if (typeof rawJson === "string") {
+			try {
+				parsedJson = JSON.parse(rawJson);
+			} catch {
+				badRequest(`Failed to parse JSON field "${jsonField}".`);
+			}
+		} else if (rawJson !== null) {
+			badRequest(`JSON field "${jsonField}" must be a string value.`);
+		}
+	}
+
+	return {
+		files,
+		json: parsedJson,
+	};
 }
 
 function isAllowedFileType(file: File, allowedTypes: string[]): boolean {
-  const mime = file.type?.toLowerCase?.() || "";
-  const extension = file.name.split(".").pop()?.toLowerCase();
+	const mime = file.type?.toLowerCase?.() || "";
+	const extension = file.name.split(".").pop()?.toLowerCase();
 
-  if (mime && allowedTypes.includes(mime)) return true;
-  if (extension && allowedTypes.includes(extension)) return true;
+	if (mime && allowedTypes.includes(mime)) return true;
+	if (extension && allowedTypes.includes(extension)) return true;
 
-  return allowedTypes.length === 0;
+	return allowedTypes.length === 0;
 }
 
 function isFormDataLike(value: unknown): value is FormData {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    typeof (value as FormData).get === "function" &&
-    typeof (value as FormData).entries === "function"
-  );
+	return (
+		typeof value === "object" &&
+		value !== null &&
+		typeof (value as FormData).get === "function" &&
+		typeof (value as FormData).entries === "function"
+	);
 }
 
 function tryResolveFromBody(body: unknown): FormData | null {
-  if (!body) return null;
-  if (isFormDataLike(body)) return body;
-  if (typeof body !== "object") return null;
-
-  const formData = new (globalThis as any).FormData();
-  for (const [key, value] of Object.entries(body)) {
-    if (value === undefined || value === null) continue;
-    if (Array.isArray(value)) {
-      value.forEach((item) => {
-        appendValue(formData, key, item);
-      });
-      continue;
-    }
-    appendValue(formData, key, value);
-  }
-
-  return formData;
+	if (!body) return null;
+	if (isFormDataLike(body)) return body;
+	if (typeof body !== "object") return null;
+
+	const formData = new (globalThis as any).FormData();
+	for (const [key, value] of Object.entries(body)) {
+		if (value === undefined || value === null) continue;
+		if (Array.isArray(value)) {
+			value.forEach((item) => {
+				appendValue(formData, key, item);
+			});
+			continue;
+		}
+		appendValue(formData, key, value);
+	}
+
+	return formData;
 }
 
 function appendValue(formData: FormData, key: string, value: unknown) {
-  if (value instanceof File || value instanceof Blob) {
-    formData.append(key, value);
-  } else if (typeof value === "object") {
-    formData.append(key, JSON.stringify(value));
-  } else {
-    formData.append(key, String(value));
-  }
+	if (value instanceof File || value instanceof Blob) {
+		formData.append(key, value);
+	} else if (typeof value === "object") {
+		formData.append(key, JSON.stringify(value));
+	} else {
+		formData.append(key, String(value));
+	}
 }
 
 function badRequest(message: string): never {
-  throw new Response(JSON.stringify({ error: message }), {
-    status: 400,
-    headers: { "content-type": "application/json" },
-  });
+	throw new BadRequestException(message);
 }

package/package.json

@@ -13,7 +13,7 @@
       "types": "./dist/*.d.ts"
     }
   },
-  "version": "0.2.7",
+  "version": "0.2.9",
   "homepage": "https://bunstone.diario.one/",
   "repository": {
     "url": "https://github.com/diariodaregiao/bunstone.git",