framework-do-dede 1.0.24 → 1.0.26

package/dist/decorators/entity.d.ts

@@ -1,4 +1,9 @@
 export declare function Restrict(): (target: any, propertyKey: string) => void;
+export type ExposeConfig = {
+    mapping?: string | Record<string, string>;
+    deserialize?: (value: any) => any | Promise<any>;
+};
+export declare function Expose(configOrMapping: ExposeConfig | string): PropertyDecorator;
 export declare function VirtualProperty(propertyName: string): (target: any, methodName: string, descriptor: PropertyDescriptor) => void;
 type DbColumnConfig = {
     mapping?: string | Record<string, string>;

package/dist/decorators/entity.js

@@ -6,13 +6,37 @@ export function Restrict() {
         target.constructor._restrictedProperties.add(propertyKey);
     };
 }
+export function Expose(configOrMapping) {
+    return function (target, propertyKey) {
+        const ctor = target.constructor;
+        const configs = ctor._exposeConfigs || (ctor._exposeConfigs = new Map());
+        if (typeof configOrMapping === "string") {
+            configs.set(propertyKey, [
+                ...(configs.get(propertyKey) || []),
+                {
+                    mapping: configOrMapping,
+                    deserialize: (value) => value
+                }
+            ]);
+        }
+        else {
+            configs.set(propertyKey, [
+                ...(configs.get(propertyKey) || []),
+                {
+                    mapping: configOrMapping.mapping,
+                    deserialize: configOrMapping.deserialize || ((value) => value)
+                }
+            ]);
+        }
+    };
+}
 export function VirtualProperty(propertyName) {
     return function (target, methodName, descriptor) {
         const ctor = target.constructor;
-        if (!ctor._exposedProperties) {
-            ctor._exposedProperties = new Map();
+        if (!ctor._virtualProperties) {
+            ctor._virtualProperties = new Map();
         }
-        ctor._exposedProperties.set(propertyName, methodName);
+        ctor._virtualProperties.set(propertyName, methodName);
     };
 }
 export function DbColumn(config) {

package/dist/decorators/index.d.ts

@@ -1,6 +1,6 @@
 import { Controller, Post, Get, Put, Delete, Patch, Validator, Middleware, Metrics, OffConsoleLog } from './controller';
 import { Context } from './usecase';
 import { Inject } from './di';
-import { Restrict, DbColumn, VirtualProperty } from './entity';
+import { Restrict, DbColumn, VirtualProperty, Expose } from './entity';
 import { Storage } from './services';
-export { Controller, Middleware, Validator, Metrics, OffConsoleLog, Post, Get, Put, Delete, Patch, Context, Inject, Restrict, DbColumn, Storage, VirtualProperty };
+export { Controller, Middleware, Validator, Metrics, OffConsoleLog, Post, Get, Put, Delete, Patch, Context, Inject, Restrict, DbColumn, Storage, Expose, VirtualProperty };

package/dist/decorators/index.js

@@ -1,6 +1,6 @@
 import { Controller, Post, Get, Put, Delete, Patch, Validator, Middleware, Metrics, OffConsoleLog } from './controller';
 import { Context } from './usecase';
 import { Inject } from './di';
-import { Restrict, DbColumn, VirtualProperty } from './entity';
+import { Restrict, DbColumn, VirtualProperty, Expose } from './entity';
 import { Storage } from './services';
-export { Controller, Middleware, Validator, Metrics, OffConsoleLog, Post, Get, Put, Delete, Patch, Context, Inject, Restrict, DbColumn, Storage, VirtualProperty };
+export { Controller, Middleware, Validator, Metrics, OffConsoleLog, Post, Get, Put, Delete, Patch, Context, Inject, Restrict, DbColumn, Storage, Expose, VirtualProperty };

package/dist/decorators/services.js

@@ -1,13 +1,7 @@
 import { Registry } from "../di/registry";
 import { StorageGateway } from "../protocols/StorageGateway";
-import { Log } from "../utils/Log";
-import { Testing } from "../utils/Testing";
 export function Storage(gatewayName) {
     return function (target, propertyKey) {
-        if (Testing.isEnabled()) {
-            Log.info(`@Storage ${gatewayName} is ignored in testing mode`);
-            return;
-        }
         // Verifica se a classe está registrada
         if (!Registry.has(gatewayName)) {
             throw new Error(`StorageGateway ${gatewayName} not registered`);

package/dist/domain/Entity.js

@@ -2,7 +2,8 @@ export class Entity {
     async get() {
         const ctor = this.constructor;
         const restrictedProps = ctor._restrictedProperties || new Set();
-        const exposedProps = ctor._exposedProperties || new Map();
+        const virtualProperties = ctor._virtualProperties || new Map();
+        const exposeConfigs = ctor._exposeConfigs || new Map();
         const attributes = {};
         await this.beforeGet();
         for (const [key, value] of Object.entries(this)) {
@@ -10,11 +11,43 @@ export class Entity {
                 attributes[key] = value;
             }
         }
-        for (const [propName, methodName] of exposedProps) {
+        for await (const [propName, methodName] of virtualProperties) {
             // @ts-ignore
             if (!restrictedProps.has(propName) && typeof this[methodName] === "function") {
                 // @ts-ignore
-                attributes[propName] = this[methodName]();
+                attributes[propName] = await this[methodName]();
+            }
+        }
+        for (const [propertyKey, configs] of exposeConfigs) {
+            if (restrictedProps.has(propertyKey))
+                continue;
+            const rawValue = this[propertyKey];
+            for (const config of configs) {
+                try {
+                    let value = config.deserialize ? await config.deserialize(rawValue) : rawValue;
+                    if (config.mapping) {
+                        if (typeof config.mapping === "string") {
+                            attributes[config.mapping] = value;
+                        }
+                        else {
+                            Object.entries(config.mapping).forEach(([srcKey, destKey]) => {
+                                // @ts-ignore
+                                attributes[destKey] = value[srcKey];
+                            });
+                        }
+                    }
+                    else {
+                        if (typeof value === "object" && value !== null) {
+                            Object.assign(attributes, value);
+                        }
+                        else {
+                            attributes[propertyKey] = value;
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error(`Error in @Expose for ${String(propertyKey)}:`, error);
+                }
             }
         }
         return attributes;

package/dist/handlers/controller.handler.js

@@ -112,7 +112,7 @@ export default class ControllerHandler {
                 if (middlewareData)
                     request.middlewareData = middlewareData;
                 try {
-                    const response = await instance[instanceMethod](mergedParams, request);
+                    const response = await instance[instanceMethod]({ input: mergedParams, request });
                     if (!offLogs) {
                         const endTime = performance.now();
                         Log.success(`✅ [LOG] Finish: "${logger.handler.instance}.${logger.handler.method}" - in: ${(endTime - startTime).toFixed(2)} ms`);

package/dist/index.d.ts

@@ -1,10 +1,9 @@
 import { Dede, Register as DedeRegister, Options as DedeOptions } from './dede';
-import { Controller, Post, Put, Get, Delete, Patch, Validator, Middleware, Context, Inject, Restrict, Metrics, DbColumn, VirtualProperty, OffConsoleLog, Storage } from './decorators';
+import { Controller, Post, Put, Get, Delete, Patch, Validator, Middleware, Context, Inject, Restrict, Metrics, DbColumn, VirtualProperty, OffConsoleLog, Storage, Expose } from './decorators';
 import { BadRequest, Conflict, Forbidden, HttpServer, NotFound, ServerError, Unauthorized, UnprocessableEntity } from './http';
 import { Validation, HttpMiddleware, UseCase, CreateRepository, ExistsById, DeleteRepository, UpdateRepository, RestoreRepository, RestoreManyRepository, RequestMetricsHandler, RequestData, RequestMetrics, HttpServerError, StorageGateway } from './protocols';
 import { Entity } from './domain/Entity';
-import { Testing } from './utils/Testing';
 declare class UseCaseHandler {
     static load<T extends UseCase<any, any>>(useCaseClass: new (...args: any[]) => T, request?: RequestData): T;
 }
-export { UseCase, HttpMiddleware, Validation, RequestMetricsHandler, RequestMetrics, HttpServerError, CreateRepository, DeleteRepository, UpdateRepository, RestoreRepository, ExistsById, RestoreManyRepository, RequestData, Dede, DedeRegister, DedeOptions, UseCaseHandler, ServerError, BadRequest, Conflict, Forbidden, HttpServer, NotFound, Unauthorized, UnprocessableEntity, Controller, Post, Put, Get, Delete, Patch, Validator, Middleware, Context, Inject, Entity, Restrict, DbColumn, VirtualProperty, Metrics, OffConsoleLog, StorageGateway, Storage, Testing };
+export { UseCase, HttpMiddleware, Validation, RequestMetricsHandler, RequestMetrics, HttpServerError, CreateRepository, DeleteRepository, UpdateRepository, RestoreRepository, ExistsById, RestoreManyRepository, RequestData, Dede, DedeRegister, DedeOptions, UseCaseHandler, ServerError, BadRequest, Conflict, Forbidden, HttpServer, NotFound, Unauthorized, UnprocessableEntity, Controller, Post, Put, Get, Delete, Patch, Validator, Middleware, Context, Inject, Entity, Restrict, DbColumn, VirtualProperty, Metrics, OffConsoleLog, StorageGateway, Storage, Expose };

package/dist/index.js

@@ -1,9 +1,8 @@
 import { Dede } from './dede';
-import { Controller, Post, Put, Get, Delete, Patch, Validator, Middleware, Context, Inject, Restrict, Metrics, DbColumn, VirtualProperty, OffConsoleLog, Storage } from './decorators';
+import { Controller, Post, Put, Get, Delete, Patch, Validator, Middleware, Context, Inject, Restrict, Metrics, DbColumn, VirtualProperty, OffConsoleLog, Storage, Expose } from './decorators';
 import { BadRequest, Conflict, Forbidden, HttpServer, NotFound, ServerError, Unauthorized, UnprocessableEntity } from './http';
 import { Registry } from './di/registry';
 import { Entity } from './domain/Entity';
-import { Testing } from './utils/Testing';
 class UseCaseHandler {
     static load(useCaseClass, request) {
         const instance = Registry.classLoader(useCaseClass);
@@ -17,4 +16,4 @@ class UseCaseHandler {
         return instance;
     }
 }
-export { Dede, UseCaseHandler, ServerError, BadRequest, Conflict, Forbidden, HttpServer, NotFound, Unauthorized, UnprocessableEntity, Controller, Post, Put, Get, Delete, Patch, Validator, Middleware, Context, Inject, Entity, Restrict, DbColumn, VirtualProperty, Metrics, OffConsoleLog, Storage, Testing };
+export { Dede, UseCaseHandler, ServerError, BadRequest, Conflict, Forbidden, HttpServer, NotFound, Unauthorized, UnprocessableEntity, Controller, Post, Put, Get, Delete, Patch, Validator, Middleware, Context, Inject, Entity, Restrict, DbColumn, VirtualProperty, Metrics, OffConsoleLog, Storage, Expose };

package/package.json

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

package/dist/utils/Testing.d.ts

@@ -1,6 +0,0 @@
-export declare class Testing {
-    private static enabled;
-    static enable(): void;
-    static disable(): void;
-    static isEnabled(): typeof Testing.isEnabled;
-}

package/dist/utils/Testing.js

@@ -1,12 +0,0 @@
-export class Testing {
-    static enabled = false;
-    static enable() {
-        this.enabled = true;
-    }
-    static disable() {
-        this.enabled = false;
-    }
-    static isEnabled() {
-        return this.isEnabled;
-    }
-}