framework-do-dede 4.0.0 → 4.0.2

package/dist/application/controller.d.ts

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import type { ValidatorLike } from "../interface/validation/validator";
+import type { ValidatorDefinition } from "../interface/validation/validator";
 export interface Middleware {
     execute(input: Input<any>): Promise<any>;
 }
@@ -40,7 +40,7 @@ export declare function Post(config?: {
     body?: string[];
     bodyFilter?: BodyFilter;
     responseType?: 'json' | 'text' | 'html';
-    validator?: ValidatorLike;
+    validator?: ValidatorDefinition;
 }): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
 export declare function Get(config?: {
     path?: string;
@@ -49,7 +49,7 @@ export declare function Get(config?: {
     query?: string[];
     headers?: string[];
     responseType?: 'json' | 'text' | 'html';
-    validator?: ValidatorLike;
+    validator?: ValidatorDefinition;
 }): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
 export declare function Put(config?: {
     path?: string;
@@ -60,7 +60,7 @@ export declare function Put(config?: {
     body?: string[];
     bodyFilter?: BodyFilter;
     responseType?: 'json' | 'text' | 'html';
-    validator?: ValidatorLike;
+    validator?: ValidatorDefinition;
 }): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
 export declare function Patch(config?: {
     path?: string;
@@ -71,7 +71,7 @@ export declare function Patch(config?: {
     body?: string[];
     bodyFilter?: BodyFilter;
     responseType?: 'json' | 'text' | 'html';
-    validator?: ValidatorLike;
+    validator?: ValidatorDefinition;
 }): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
 export declare function Delete(config?: {
     path?: string;
@@ -82,6 +82,6 @@ export declare function Delete(config?: {
     body?: string[];
     bodyFilter?: BodyFilter;
     responseType?: 'json' | 'text' | 'html';
-    validator?: ValidatorLike;
+    validator?: ValidatorDefinition;
 }): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
 export {};

package/dist/http/controller.handler.js

@@ -32,11 +32,20 @@ export default class ControllerHandler {
                     startTime = performance.now();
                     request = this.requestMapper.map(input, { params, query, headers, body, bodyFilter });
                     if (validator) {
-                        if (typeof validator === 'function') {
-                            await validateWithClassValidator(validator, request.data);
+                        let validatorLike;
+                        let options;
+                        if (isValidatorDefinition(validator)) {
+                            validatorLike = validator.validator;
+                            options = validator.error;
                         }
-                        else if (typeof validator.validate === 'function') {
-                            await validator.validate(request.data);
+                        else {
+                            validatorLike = validator;
+                        }
+                        if (typeof validatorLike === 'function') {
+                            await validateWithClassValidator(validatorLike, request.data, options);
+                        }
+                        else if (typeof validatorLike.validate === 'function') {
+                            await validatorLike.validate(request.data);
                         }
                         else {
                             throw new FrameworkError('Validator must be a class or implement validate()');
@@ -135,3 +144,6 @@ export default class ControllerHandler {
         return middleware;
     }
 }
+function isValidatorDefinition(value) {
+    return !!value && typeof value === 'object' && 'validator' in value;
+}

package/dist/http/http-server.d.ts

@@ -1,5 +1,5 @@
 import { Middleware, Tracer } from "../application/controller";
-import type { ValidatorLike } from "../interface/validation/validator";
+import type { ValidatorDefinition } from "../interface/validation/validator";
 export type Request = {
     data: any;
     context: any;
@@ -16,7 +16,7 @@ export type HttpServerParams = {
     };
     responseType: 'json' | 'text' | 'html';
     middlewares?: Middleware[];
-    validator?: ValidatorLike;
+    validator?: ValidatorDefinition;
     statusCode?: number;
     params?: string[];
     query?: string[];

package/dist/index.d.ts

@@ -3,5 +3,7 @@ import { Container, DefaultContainer, Inject, setDefaultContainer } from './infr
 import { Dede, type Options, Register } from './dede';
 import { ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError, CustomServerError } from './http/errors/server';
 import { AppError } from './domain/errors/app-error';
+import type { ValidatorDefinition } from './interface/validation/validator';
 import type { RepositoryCreate, RepositoryUpdate, RepositoryRemove, RepositoryRemoveBy, RepositoryExistsBy, RepositoryRestore, RepositoryRestoreBy, RepositoryNotExistsBy, RepositoryPagination } from './protocols/repository';
 export { Controller, Post, Get, Put, Delete, Patch, Input, Middleware, UseMiddleware, UseMiddlewares, Tracer, Tracing, TracerData, Entity, Restrict, VirtualProperty, GetterPrefix, Serialize, UseCase, DecorateUseCase, Storage, StorageGateway, Inject, Container, DefaultContainer, setDefaultContainer, Dede, Options, Register, ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError, CustomServerError, AppError, RepositoryCreate, RepositoryUpdate, RepositoryRemove, RepositoryRemoveBy, RepositoryRestore, RepositoryExistsBy, RepositoryRestoreBy, RepositoryNotExistsBy, RepositoryPagination };
+export type { ValidatorDefinition };

package/dist/infra/di/registry.js

@@ -18,11 +18,12 @@ export let DefaultContainer = new Container();
 export function setDefaultContainer(container) {
     DefaultContainer = container;
 }
-export function Inject(name, container = DefaultContainer) {
+export function Inject(name, container) {
     return function (target, propertyKey) {
         target[propertyKey] = new Proxy({}, {
             get(_, propertyKey) {
-                const dependency = container.inject(name);
+                const resolvedContainer = container ?? DefaultContainer;
+                const dependency = resolvedContainer.inject(name);
                 return dependency[propertyKey];
             }
         });

package/dist/interface/validation/class-validator.d.ts

@@ -1,6 +1,6 @@
-export type ValidationErrorDetail = {
-    path: string;
-    message: string;
-    rule: string;
+export type ValidationErrorMap = Record<string, string[]>;
+export type ValidationErrorOptions = {
+    statusCode?: number;
+    errorName?: string;
 };
-export declare function validateWithClassValidator<T extends object>(dtoClass: new () => T, input: T): Promise<void>;
+export declare function validateWithClassValidator<T extends object>(dtoClass: new () => T, input: T, options?: ValidationErrorOptions): Promise<void>;

package/dist/interface/validation/class-validator.js

@@ -1,27 +1,24 @@
-import { UnprocessableEntity } from '../../domain/errors/http-errors';
+import { CustomServerError } from '../../http/errors/server';
 import { validate } from 'class-validator';
-export async function validateWithClassValidator(dtoClass, input) {
+export async function validateWithClassValidator(dtoClass, input, options = {}) {
     const instance = Object.assign(new dtoClass(), input);
     const errors = await validate(instance);
     if (errors.length === 0)
         return;
     const details = flattenErrors(errors);
-    throw new UnprocessableEntity('Validation error', {
-        code: 'validation_error',
-        details
-    });
+    const statusCode = options.statusCode ?? 400;
+    const errorName = options.errorName ?? 'BadRequest';
+    throw new CustomServerError({ errors: details }, statusCode, errorName);
 }
 function flattenErrors(errors, parentPath = '') {
-    const output = [];
+    const output = {};
     for (const error of errors) {
         const path = parentPath ? `${parentPath}.${error.property}` : error.property;
         if (error.constraints) {
-            for (const [rule, message] of Object.entries(error.constraints)) {
-                output.push({ path, rule, message });
-            }
+            output[path] = Object.values(error.constraints);
         }
         if (error.children && error.children.length > 0) {
-            output.push(...flattenErrors(error.children, path));
+            Object.assign(output, flattenErrors(error.children, path));
         }
     }
     return output;

package/dist/interface/validation/validator.d.ts

@@ -1,5 +1,10 @@
+import type { ValidationErrorOptions } from '../../interface/validation/class-validator';
 export interface Validator<T = any> {
     validate(input: T): void | Promise<void>;
 }
 export type ValidatorClass<T = any> = new () => T;
 export type ValidatorLike<T = any> = Validator<T> | ValidatorClass<T>;
+export type ValidatorDefinition<T = any> = ValidatorLike<T> | {
+    validator: ValidatorLike<T>;
+    error?: ValidationErrorOptions;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "framework-do-dede",
-  "version": "4.0.0",
+  "version": "4.0.2",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",