framework-do-dede 5.4.11 → 5.5.1

package/README.md

@@ -100,6 +100,7 @@ Decorators disponíveis:
 
 - `@Controller(basePath?: string)`
 - `@Get`, `@Post`, `@Put`, `@Patch`, `@Delete`
+- `@Version(version: number)`
 
 Opções de rota (comuns):
 
@@ -110,6 +111,38 @@ Opções de rota (comuns):
 - `responseType`: `"json" | "text" | "html"`
 - `validator`: pode ser uma classe com decorators do `class-validator` **ou** um objeto com `validate(data)` (sync/async)
 
+### Versionamento e Prefixo
+
+Você pode definir um prefixo e uma versão global ao criar a aplicação. A versão vira `v{numero}` logo após o prefixo (se existir):
+
+```ts
+const app = await Dede.create({
+  framework: { use: 'express', port: 3000 },
+  registries: [],
+  prefix: '/api',
+  version: 1
+});
+
+// rota final: /api/v1/users/list
+```
+
+Para sobrescrever a versão global em um controller ou método, use `@Version`:
+
+```ts
+import { Controller, Get, Version } from './src';
+
+@Version(2)
+@Controller('/users')
+class UsersController {
+  @Get({ path: '/list' })
+  async list() {}
+
+  @Version(3)
+  @Get({ path: '/featured' })
+  async featured() {}
+}
+```
+
 ### Input, params e filtros
 
 O framework compõe um objeto `request.data` a partir de:

package/dist/application/controller.d.ts

@@ -29,6 +29,7 @@ export interface Input<T, K = any> {
 type BodyFilter = "restrict" | "none";
 export declare function Controller(basePath?: string): (target: any) => void;
 export declare function Tracing<R>(tracer: Tracer<R>): (target: any, propertyKey?: string) => void;
+export declare function Version(version: number): (target: any, propertyKey?: string) => void;
 export declare function UseMiddleware(middlewareClass: MiddlewareDefinition): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
 export declare function UseMiddlewares(middlewareClasses: MiddlewareDefinition[]): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
 export declare function Post(config?: {

package/dist/application/controller.js

@@ -17,6 +17,19 @@ export function Tracing(tracer) {
         }
     };
 }
+export function Version(version) {
+    return function (target, propertyKey) {
+        if (!Number.isInteger(version) || version <= 0) {
+            throw new FrameworkError('Version must be a positive integer');
+        }
+        if (!propertyKey) {
+            Reflect.defineMetadata('version', version, target);
+        }
+        else {
+            Reflect.defineMetadata('version', version, target, propertyKey);
+        }
+    };
+}
 function isClass(fn) {
     return /^\s*class\s/.test(Function.prototype.toString.call(fn));
 }

package/dist/application/index.d.ts

@@ -1,8 +1,8 @@
-import { Controller, Post, Get, Put, Delete, Patch, UseMiddleware, UseMiddlewares, Tracing, type Middleware, type Input, type Tracer, type TracerData } from './controller';
+import { Controller, Post, Get, Put, Delete, Patch, UseMiddleware, UseMiddlewares, Tracing, Version, type Middleware, type Input, type Tracer, type TracerData } from './controller';
 import { Entity, Restrict, VirtualProperty, GetterPrefix, Transform } from '../infra/serialization/entity';
 import { Model, model, column } from '../infra/model/model';
 import { DecorateUseCase, UseCase, Hook, BeforeHook, AfterHook, HookBefore, HookAfter } from './usecase';
-export { Controller, UseMiddleware, UseMiddlewares, Post, Get, Put, Delete, Patch, Tracing, DecorateUseCase, UseCase, Hook, BeforeHook, AfterHook, HookBefore, HookAfter, Entity, Restrict, VirtualProperty, GetterPrefix, Transform, Model, model, column, };
+export { Controller, UseMiddleware, UseMiddlewares, Post, Get, Put, Delete, Patch, Tracing, Version, DecorateUseCase, UseCase, Hook, BeforeHook, AfterHook, HookBefore, HookAfter, Entity, Restrict, VirtualProperty, GetterPrefix, Transform, Model, model, column, };
 export { Storage, CacheGateway, EventDispatcher } from './services';
 export type { Middleware, Input, Tracer, TracerData };
 export type { StorageGateway } from './services';

package/dist/application/index.js

@@ -1,6 +1,6 @@
-import { Controller, Post, Get, Put, Delete, Patch, UseMiddleware, UseMiddlewares, Tracing } from './controller';
+import { Controller, Post, Get, Put, Delete, Patch, UseMiddleware, UseMiddlewares, Tracing, Version } from './controller';
 import { Entity, Restrict, VirtualProperty, GetterPrefix, Transform } from '../infra/serialization/entity';
 import { Model, model, column } from '../infra/model/model';
 import { DecorateUseCase, UseCase, Hook, BeforeHook, AfterHook, HookBefore, HookAfter, } from './usecase';
-export { Controller, UseMiddleware, UseMiddlewares, Post, Get, Put, Delete, Patch, Tracing, DecorateUseCase, UseCase, Hook, BeforeHook, AfterHook, HookBefore, HookAfter, Entity, Restrict, VirtualProperty, GetterPrefix, Transform, Model, model, column, };
+export { Controller, UseMiddleware, UseMiddlewares, Post, Get, Put, Delete, Patch, Tracing, Version, DecorateUseCase, UseCase, Hook, BeforeHook, AfterHook, HookBefore, HookAfter, Entity, Restrict, VirtualProperty, GetterPrefix, Transform, Model, model, column, };
 export { Storage, CacheGateway, EventDispatcher } from './services';

package/dist/dede.d.ts

@@ -13,6 +13,8 @@ export type Options = {
     registries: Register[];
     defaultServerError?: string;
     container?: Container;
+    prefix?: string;
+    version?: number;
 };
 export declare class Dede {
     private readonly framework;
@@ -21,9 +23,11 @@ export declare class Dede {
     private readonly httpServer;
     private readonly port?;
     private controllersRegistered;
+    private readonly prefix?;
+    private readonly version?;
     private constructor();
-    static create({ framework, registries, defaultServerError, container }: Options): Promise<Dede>;
-    static start({ framework, registries, defaultServerError, container, controllers }: Options): Promise<Dede>;
+    static create({ framework, registries, defaultServerError, container, prefix, version }: Options): Promise<Dede>;
+    static start({ framework, registries, defaultServerError, container, controllers, prefix, version }: Options): Promise<Dede>;
     stop(): Promise<void>;
     registerControllers(controllers: any[]): void;
     listen(port?: number): void;

package/dist/dede.js

@@ -2,13 +2,16 @@ import ControllerHandler from "./http/controller.handler";
 import { ElysiaServerAdapter } from "./http/elysia-server.adapter";
 import { ExpressServerAdapter } from "./http/express-server.adapter";
 import { Container, DefaultContainer, setDefaultContainer } from "./infra/di/registry";
+import { FrameworkError } from "./http/errors/framework";
 export class Dede {
-    constructor(framework, defaultServerError, container = DefaultContainer) {
+    constructor(framework, defaultServerError, container = DefaultContainer, prefix, version) {
         this.framework = framework;
         this.defaultServerError = defaultServerError;
         this.container = container;
         this.controllersRegistered = false;
         this.port = framework.port;
+        this.prefix = normalizePrefix(prefix);
+        this.version = version;
         if (framework.use === 'elysia') {
             this.httpServer = new ElysiaServerAdapter(framework.middlewares || []);
         }
@@ -18,14 +21,15 @@ export class Dede {
         if (defaultServerError)
             this.httpServer.setDefaultMessageError(defaultServerError);
     }
-    static async create({ framework, registries, defaultServerError, container }) {
+    static async create({ framework, registries, defaultServerError, container, prefix, version }) {
+        assertValidVersion(version);
         const appContainer = container ?? new Container();
         setDefaultContainer(appContainer);
         await this.loadRegistries(appContainer, registries);
-        return new Dede(framework, defaultServerError, appContainer);
+        return new Dede(framework, defaultServerError, appContainer, prefix, version);
     }
-    static async start({ framework, registries, defaultServerError, container, controllers }) {
-        const app = await Dede.create({ framework, registries, defaultServerError, container, controllers });
+    static async start({ framework, registries, defaultServerError, container, controllers, prefix, version }) {
+        const app = await Dede.create({ framework, registries, defaultServerError, container, controllers, prefix, version });
         if (controllers && controllers.length > 0) {
             app.registerControllers(controllers);
         }
@@ -38,7 +42,7 @@ export class Dede {
     registerControllers(controllers) {
         if (this.controllersRegistered)
             return;
-        new ControllerHandler(this.httpServer, controllers);
+        new ControllerHandler(this.httpServer, controllers, { prefix: this.prefix, version: this.version });
         this.controllersRegistered = true;
     }
     listen(port) {
@@ -51,3 +55,20 @@ export class Dede {
         });
     }
 }
+function assertValidVersion(version) {
+    if (version === undefined)
+        return;
+    if (!Number.isInteger(version) || version <= 0) {
+        throw new FrameworkError('Version must be a positive integer');
+    }
+}
+function normalizePrefix(prefix) {
+    if (!prefix)
+        return undefined;
+    const trimmed = prefix.trim();
+    if (!trimmed)
+        return undefined;
+    if (trimmed === '/')
+        return '/';
+    return trimmed.endsWith('/') ? trimmed.slice(0, -1) : trimmed;
+}

package/dist/http/controller.handler.d.ts

@@ -3,7 +3,17 @@ export default class ControllerHandler {
     private readonly requestMapper;
     private readonly middlewareExecutor;
     private readonly errorMapper;
-    constructor(httpServer: HttpServer, controllers?: any[]);
+    private readonly prefix?;
+    private readonly version?;
+    constructor(httpServer: HttpServer, controllers?: any[], options?: {
+        prefix?: string;
+        version?: number;
+    });
     private registryControllers;
     private resolveMiddleware;
+    private buildRoute;
+    private joinSegments;
+    private trimLeadingSlash;
+    private trimTrailingSlash;
+    private trimSlashes;
 }

package/dist/http/controller.handler.js

@@ -4,10 +4,12 @@ import { MiddlewareExecutor } from "../interface/http/middleware-executor";
 import { HttpErrorMapper } from "../interface/errors/http-error-mapper";
 import { validateWithClassValidator } from "../interface/validation/class-validator";
 export default class ControllerHandler {
-    constructor(httpServer, controllers = []) {
+    constructor(httpServer, controllers = [], options = {}) {
         this.requestMapper = new HttpRequestMapper();
         this.middlewareExecutor = new MiddlewareExecutor();
         this.errorMapper = new HttpErrorMapper();
+        this.prefix = options.prefix;
+        this.version = options.version;
         for (const { handler, middlewares, validator, method, route, statusCode, params, query, headers, body, bodyFilter, responseType } of this.registryControllers(controllers)) {
             httpServer.register({
                 method,
@@ -42,7 +44,7 @@ export default class ControllerHandler {
                             validatorLike = validator;
                         }
                         if (typeof validatorLike === 'function') {
-                            await validateWithClassValidator(validatorLike, request.data, options);
+                            request.data = await validateWithClassValidator(validatorLike, request.data, options);
                         }
                         else if (typeof validatorLike.validate === 'function') {
                             await validatorLike.validate(request.data);
@@ -94,15 +96,19 @@ export default class ControllerHandler {
             const basePath = Reflect.getMetadata('basePath', controller);
             const methodNames = Object.getOwnPropertyNames(controller.prototype).filter(method => method !== 'constructor');
             let tracer = Reflect.getMetadata('tracer', controller) || null;
+            const controllerVersion = Reflect.getMetadata('version', controller);
             const instance = new controller();
             for (const methodName of methodNames) {
                 const routeConfig = Reflect.getMetadata('route', controller.prototype, methodName);
                 const middlewares = Reflect.getMetadata('middlewares', controller.prototype, methodName);
                 const responseType = Reflect.getMetadata('responseType', controller.prototype, methodName) || 'json';
                 tracer = Reflect.getMetadata('tracer', controller.prototype, methodName) || tracer;
+                const methodVersion = Reflect.getMetadata('version', controller.prototype, methodName);
+                const resolvedVersion = methodVersion ?? controllerVersion ?? this.version;
+                const route = this.buildRoute(basePath + routeConfig.path, resolvedVersion, this.prefix);
                 controllers.push({
                     method: routeConfig.method,
-                    route: basePath + routeConfig.path,
+                    route,
                     params: routeConfig.params,
                     query: routeConfig.query,
                     headers: routeConfig.headers,
@@ -143,6 +149,37 @@ export default class ControllerHandler {
         }
         return middleware;
     }
+    buildRoute(baseRoute, version, prefix) {
+        let route = baseRoute;
+        if (version !== undefined) {
+            route = this.joinSegments(`v${version}`, route);
+        }
+        if (prefix) {
+            route = this.joinSegments(prefix, route);
+        }
+        return route;
+    }
+    joinSegments(left, right) {
+        const normalizedLeft = this.trimSlashes(left);
+        const normalizedRight = this.trimLeadingSlash(right);
+        const combined = [normalizedLeft, normalizedRight].filter(Boolean).join('/');
+        return combined ? `/${combined}` : '/';
+    }
+    trimLeadingSlash(value) {
+        return value.startsWith('/') ? value.slice(1) : value;
+    }
+    trimTrailingSlash(value) {
+        if (value === '/')
+            return '';
+        return value.endsWith('/') ? value.slice(0, -1) : value;
+    }
+    trimSlashes(value) {
+        if (value === '/')
+            return '';
+        let trimmed = this.trimLeadingSlash(value);
+        trimmed = this.trimTrailingSlash(trimmed);
+        return trimmed;
+    }
 }
 function isValidatorDefinition(value) {
     return !!value && typeof value === 'object' && 'validator' in value;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Post, Get, Put, Delete, Patch, Controller, Input, Middleware, UseMiddleware, UseMiddlewares, Tracer, Tracing, TracerData, Entity, Restrict, VirtualProperty, GetterPrefix, Transform, Model, model, column, UseCase, DecorateUseCase, Hook, BeforeHook, AfterHook, HookBefore, HookAfter, Storage, CacheGateway, EventDispatcher } from "./application";
+import { Post, Get, Put, Delete, Patch, Controller, Input, Version, Middleware, UseMiddleware, UseMiddlewares, Tracer, Tracing, TracerData, Entity, Restrict, VirtualProperty, GetterPrefix, Transform, Model, model, column, UseCase, DecorateUseCase, Hook, BeforeHook, AfterHook, HookBefore, HookAfter, Storage, CacheGateway, EventDispatcher } from "./application";
 import { Container, DefaultContainer, Inject, setDefaultContainer } from './infra/di/registry';
 import { Dede, type Options, Register } from './dede';
 import { ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError, CustomServerError } from './http/errors/server';
@@ -6,5 +6,5 @@ import { AppError } from './domain/errors/app-error';
 import type { ValidatorDefinition } from './interface/validation/validator';
 import type { StorageGateway, Event, EventPayload } from './application';
 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, Transform, Model, model, column, UseCase, DecorateUseCase, Hook, BeforeHook, AfterHook, HookBefore, HookAfter, Storage, CacheGateway, EventDispatcher, 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 { Controller, Post, Get, Put, Delete, Patch, Input, Version, Middleware, UseMiddleware, UseMiddlewares, Tracer, Tracing, TracerData, Entity, Restrict, VirtualProperty, GetterPrefix, Transform, Model, model, column, UseCase, DecorateUseCase, Hook, BeforeHook, AfterHook, HookBefore, HookAfter, Storage, CacheGateway, EventDispatcher, 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, StorageGateway, Event, EventPayload };

package/dist/index.js

@@ -1,6 +1,6 @@
 import { 
 // controller
-Post, Get, Put, Delete, Patch, Controller, UseMiddleware, UseMiddlewares, Tracing, 
+Post, Get, Put, Delete, Patch, Controller, Version, UseMiddleware, UseMiddlewares, Tracing, 
 // controller
 // entity
 Entity, Restrict, VirtualProperty, GetterPrefix, Transform, Model, model, column, 
@@ -16,4 +16,4 @@ import { Container, DefaultContainer, Inject, setDefaultContainer } from './infr
 import { Dede } from './dede';
 import { ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError, CustomServerError } from './http/errors/server';
 import { AppError } from './domain/errors/app-error';
-export { Controller, Post, Get, Put, Delete, Patch, UseMiddleware, UseMiddlewares, Tracing, Entity, Restrict, VirtualProperty, GetterPrefix, Transform, Model, model, column, UseCase, DecorateUseCase, Hook, BeforeHook, AfterHook, HookBefore, HookAfter, Storage, CacheGateway, EventDispatcher, Inject, Container, DefaultContainer, setDefaultContainer, Dede, ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError, CustomServerError, AppError };
+export { Controller, Post, Get, Put, Delete, Patch, Version, UseMiddleware, UseMiddlewares, Tracing, Entity, Restrict, VirtualProperty, GetterPrefix, Transform, Model, model, column, UseCase, DecorateUseCase, Hook, BeforeHook, AfterHook, HookBefore, HookAfter, Storage, CacheGateway, EventDispatcher, Inject, Container, DefaultContainer, setDefaultContainer, Dede, ServerError, NotFound, Forbidden, Conflict, Unauthorized, UnprocessableEntity, BadRequest, InternalServerError, CustomServerError, AppError };

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

@@ -5,4 +5,4 @@ export type ValidationErrorOptions = {
     errorName?: string;
     validatorOptions?: ValidatorOptions;
 };
-export declare function validateWithClassValidator<T extends object>(dtoClass: new () => T, input: T, options?: ValidationErrorOptions): Promise<void>;
+export declare function validateWithClassValidator<T extends object>(dtoClass: new () => T, input: T, options?: ValidationErrorOptions): Promise<T>;

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

@@ -9,7 +9,7 @@ export async function validateWithClassValidator(dtoClass, input, options = {})
     };
     const errors = await validate(instance, validatorOptions);
     if (errors.length === 0)
-        return;
+        return instance;
     const details = flattenErrors(errors);
     const statusCode = options.statusCode ?? 400;
     const errorName = options.errorName ?? 'BadRequest';

package/package.json

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