framework-do-dede 1.0.31 → 1.0.33

package/dist/decorators/entity.d.ts

@@ -5,9 +5,8 @@ export type ExposeConfig = {
 };
 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>;
-    serialize?: (value: any) => any | Promise<any>;
+export type DbColumnConfig<T = any> = {
+    column?: string | Record<string, string>;
+    serialize?: (value: T) => any | Promise<any>;
 };
-export declare function DbColumn(config: string | Record<string, string> | DbColumnConfig): (target: Object, propertyKey: string) => void;
-export {};
+export declare function DbColumn<T>(configOrColumn: DbColumnConfig<T> | string): PropertyDecorator;

package/dist/decorators/entity.js

@@ -39,27 +39,27 @@ export function VirtualProperty(propertyName) {
         ctor._virtualProperties.set(propertyName, methodName);
     };
 }
-export function DbColumn(config) {
+export function DbColumn(configOrColumn) {
     return function (target, propertyKey) {
         const ctor = target.constructor;
-        let actualMapping;
-        let serialize;
-        if (typeof config === 'string') {
-            actualMapping = config;
-        }
-        else if (typeof config === 'object') {
-            if ('serialize' in config || 'mapping' in config) {
-                actualMapping = config.mapping ?? propertyKey;
-                // @ts-ignore
-                serialize = config.serialize;
-            }
-            else {
-                // @ts-ignore
-                actualMapping = config;
-            }
+        const configs = ctor._dbColumnConfigs || (ctor._dbColumnConfigs = new Map());
+        if (typeof configOrColumn === "string") {
+            configs.set(propertyKey, [
+                ...(configs.get(propertyKey) || []),
+                {
+                    column: configOrColumn,
+                    serialize: (value) => value
+                }
+            ]);
         }
         else {
-            throw new Error('Configuração inválida para @DbColumn');
+            configs.set(propertyKey, [
+                ...(configs.get(propertyKey) || []),
+                {
+                    column: configOrColumn.column,
+                    serialize: configOrColumn.serialize || ((value) => value)
+                }
+            ]);
         }
     };
 }

package/dist/domain/Entity.d.ts

@@ -2,5 +2,4 @@ export declare abstract class Entity {
     get(): Promise<Record<string, any>>;
     toEntity(): Promise<Record<string, any>>;
     toMap(properties: string[]): Promise<Record<string, any>>;
-    protected beforeSave(): Promise<void>;
 }

package/dist/domain/Entity.js

@@ -52,41 +52,44 @@ export class Entity {
         return attributes;
     }
     async toEntity() {
-        await this.beforeSave();
-        const result = {};
-        const processedKeys = new Set();
-        const dbColumns = this.constructor._dbColumns;
-        if (dbColumns) {
-            for (const { property, mapping } of dbColumns) {
-                const value = this[property];
-                if (value === undefined)
-                    continue;
-                processedKeys.add(property);
-                if (typeof mapping === 'string') {
-                    result[mapping] = value;
-                }
-                else {
-                    for (const [subProp, column] of Object.entries(mapping)) {
-                        const subValue = value[subProp];
-                        if (subValue !== undefined) {
-                            result[column] = subValue;
+        const ctor = this.constructor;
+        const dbColumnConfigs = ctor._dbColumnConfigs || new Map();
+        const dbRecord = {};
+        for (const [propertyKey, configs] of dbColumnConfigs) {
+            const rawValue = this[propertyKey];
+            for (const config of configs) {
+                try {
+                    let serializedValue = config.serialize ? await config.serialize(rawValue) : rawValue;
+                    if (config.column) {
+                        if (typeof config.column === "string") {
+                            dbRecord[config.column] = serializedValue;
+                        }
+                        else {
+                            for (const [srcKey, destKey] of Object.entries(config.column)) {
+                                dbRecord[destKey] = serializedValue[srcKey];
+                            }
                         }
                     }
+                    else {
+                        dbRecord[propertyKey] = serializedValue;
+                    }
+                }
+                catch (error) {
+                    console.error(`Error in @DbColumn for ${String(propertyKey)}:`, error);
                 }
             }
         }
-        for (const [key, value] of Object.entries(this)) {
-            if (!processedKeys.has(key) && value !== undefined) {
-                result[key] = value;
-            }
-        }
-        return result;
+        return dbRecord;
     }
     async toMap(properties) {
         const ctor = this.constructor;
         const exposeConfigs = ctor._exposeConfigs || new Map();
         const attributes = {};
         for (const property of properties) {
+            const rawValue = this[property];
+            if (!rawValue)
+                continue;
+            attributes[property] = rawValue;
             if (exposeConfigs.has(property)) {
                 const rawValue = this[property];
                 const config = exposeConfigs.get(property);
@@ -119,5 +122,4 @@ export class Entity {
         }
         return attributes;
     }
-    async beforeSave() { }
 }

package/package.json

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