@arcaelas/dynamite 1.0.9 → 1.0.13

package/src/core/table.d.ts

@@ -0,0 +1,98 @@
+/**
+ * @file table.ts
+ * @descripcion Clase Table rediseñada con API completa y tipado estricto
+ * @autor Miguel Alejandro
+ * @fecha 2025-07-30
+ */
+import type { InferAttributes, QueryOperator, WrapperEntry, WhereQueryOptions } from "../@types/index";
+import { STORE } from "./wrapper";
+export default class Table<T = any> {
+    protected [STORE]: {
+        [K in keyof T]?: T[K];
+    };
+    constructor(data: InferAttributes<T>);
+    /** Serializar instancia a JSON plano */
+    toJSON(): Record<string, any>;
+    /** Guardar instancia (crear o actualizar) */
+    save(): Promise<this>;
+    /** Actualizar instancia */
+    update(patch: Partial<InferAttributes<T>>): Promise<this>;
+    /** Eliminar instancia */
+    destroy(): Promise<null>;
+    /**
+     * Crear un nuevo registro en la base de datos
+     */
+    static create<M extends Table>(this: {
+        new (data: InferAttributes<M>): M;
+        prototype: M;
+    }, data: InferAttributes<M>): Promise<M>;
+    /**
+     * Actualizar registros en la base de datos
+     * @param updates - Campos a actualizar. Los campos con valor `undefined` se ignoran.
+     * @param filters - Filtros para seleccionar los registros a actualizar
+     * @returns Número de registros actualizados
+     */
+    static update<M extends Table>(this: {
+        new (data: InferAttributes<M>): M;
+        prototype: M;
+    }, updates: Partial<InferAttributes<M>>, filters: Partial<InferAttributes<M>>): Promise<number>;
+    /**
+     * Eliminar registros de la base de datos
+     */
+    static delete<M extends Table>(this: {
+        new (data: InferAttributes<M>): M;
+        prototype: M;
+    }, filters: Partial<InferAttributes<M>>): Promise<number>;
+    /** Filtrar registros por campo igual a valor */
+    static where<M extends Table, K extends keyof InferAttributes<M>>(this: {
+        new (data: InferAttributes<M>): M;
+        prototype: M;
+    }, field: K, value: InferAttributes<M>[K] | InferAttributes<M>[K][]): Promise<M[]>;
+    /** Filtrar registros por campo con operador específico */
+    static where<M extends Table, K extends keyof InferAttributes<M>>(this: {
+        new (data: InferAttributes<M>): M;
+        prototype: M;
+    }, field: K, operator: QueryOperator, value: InferAttributes<M>[K] | InferAttributes<M>[K][]): Promise<M[]>;
+    /** Filtrar registros por múltiples campos (AND) */
+    static where<M extends Table>(this: {
+        new (data: InferAttributes<M>): M;
+        prototype: M;
+    }, filters: Partial<InferAttributes<M>>): Promise<M[]>;
+    /** Filtrar registros con opciones avanzadas */
+    static where<M extends Table>(this: {
+        new (data: InferAttributes<M>): M;
+        prototype: M;
+    }, filters: Partial<InferAttributes<M>>, options: WhereQueryOptions<M>): Promise<M[]>;
+    /**
+     * Obtener el primer registro que coincida con los filtros
+     */
+    static first<M extends Table, K extends keyof InferAttributes<M>>(this: {
+        new (data: InferAttributes<M>): M;
+        prototype: M;
+    }, field: K, value: InferAttributes<M>[K]): Promise<M | undefined>;
+    static first<M extends Table, K extends keyof InferAttributes<M>>(this: {
+        new (data: InferAttributes<M>): M;
+        prototype: M;
+    }, field: K, operator: QueryOperator, value: InferAttributes<M>[K] | InferAttributes<M>[K][]): Promise<M | undefined>;
+    static first<M extends Table>(this: {
+        new (data: InferAttributes<M>): M;
+        prototype: M;
+    }, filters: Partial<InferAttributes<M>>): Promise<M | undefined>;
+    /**
+     * Obtener el último registro que coincida con los filtros
+     */
+    static last<M extends Table, K extends keyof InferAttributes<M>>(this: {
+        new (data: InferAttributes<M>): M;
+        prototype: M;
+    }, field: K, value: InferAttributes<M>[K]): Promise<M | undefined>;
+    static last<M extends Table, K extends keyof InferAttributes<M>>(this: {
+        new (data: InferAttributes<M>): M;
+        prototype: M;
+    }, field: K, operator: QueryOperator, value: InferAttributes<M>[K] | InferAttributes<M>[K][]): Promise<M | undefined>;
+    static last<M extends Table>(this: {
+        new (data: InferAttributes<M>): M;
+        prototype: M;
+    }, filters: Partial<InferAttributes<M>>): Promise<M | undefined>;
+}
+export { STORE };
+export type { WrapperEntry };

package/src/core/table.js

@@ -0,0 +1,459 @@
+"use strict";
+/**
+ * @file table.ts
+ * @descripcion Clase Table rediseñada con API completa y tipado estricto
+ * @autor Miguel Alejandro
+ * @fecha 2025-07-30
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STORE = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
+const relations_1 = require("../utils/relations");
+const client_1 = require("./client");
+const wrapper_1 = require("./wrapper");
+Object.defineProperty(exports, "STORE", { enumerable: true, get: function () { return wrapper_1.STORE; } });
+/** Tipos importados desde @types */
+// =============================================================================
+// FUNCIONES UTILITARIAS
+// =============================================================================
+function validateOperator(operator) {
+    const validOps = [
+        "=",
+        "!=",
+        "<",
+        "<=",
+        ">",
+        ">=",
+        "in",
+        "not-in",
+        "contains",
+        "begins-with",
+    ];
+    if (!validOps.includes(operator)) {
+        throw new Error(`Operador inválido: ${operator}. Válidos: ${validOps.join(", ")}`);
+    }
+    return operator;
+}
+function buildConditionExpression(filters, operator = "=") {
+    const expressions = [];
+    const names = {};
+    const values = {};
+    Object.entries(filters).forEach(([key, value], index) => {
+        const nameKey = `#attr${index}`;
+        const valueKey = `:val${index}`;
+        names[nameKey] = key;
+        if (operator === "in" && Array.isArray(value)) {
+            const inValues = value.map((v, i) => {
+                const inValueKey = `:val${index}_${i}`;
+                values[inValueKey] = v;
+                return inValueKey;
+            });
+            expressions.push(`${nameKey} IN (${inValues.join(", ")})`);
+        }
+        else if (operator === "not-in" && Array.isArray(value)) {
+            const notInValues = value.map((v, i) => {
+                const notInValueKey = `:val${index}_${i}`;
+                values[notInValueKey] = v;
+                return notInValueKey;
+            });
+            expressions.push(`NOT ${nameKey} IN (${notInValues.join(", ")})`);
+        }
+        else if (operator === "contains") {
+            values[valueKey] = value;
+            expressions.push(`contains(${nameKey}, ${valueKey})`);
+        }
+        else if (operator === "begins-with") {
+            values[valueKey] = value;
+            expressions.push(`begins_with(${nameKey}, ${valueKey})`);
+        }
+        else if (operator === "!=") {
+            // DynamoDB uses <> for not equal
+            values[valueKey] = value;
+            expressions.push(`${nameKey} <> ${valueKey}`);
+        }
+        else {
+            values[valueKey] = value;
+            expressions.push(`${nameKey} ${operator} ${valueKey}`);
+        }
+    });
+    return {
+        expression: expressions.join(" AND "),
+        names,
+        values,
+    };
+}
+// =============================================================================
+// CLASE TABLE REDISEÑADA
+// =============================================================================
+class Table {
+    constructor(data) {
+        (0, client_1.requireClient)();
+        const meta = (0, wrapper_1.mustMeta)(Object.getPrototypeOf(this).constructor);
+        // Inicializar propiedades con valores por defecto
+        meta.columns.forEach((col, key) => {
+            if (typeof key === "string" && !(key in data)) {
+                // Forzar aplicación de valor por defecto mediante setter
+                if (col.default !== undefined) {
+                    const defaultValue = typeof col.default === "function" ? col.default() : col.default;
+                    this[key] = defaultValue;
+                }
+                else {
+                    this[key] = undefined;
+                }
+            }
+        });
+        Object.assign(this, data);
+    }
+    /** Serializar instancia a JSON plano */
+    toJSON() {
+        const meta = (0, wrapper_1.mustMeta)(Object.getPrototypeOf(this).constructor);
+        const result = {};
+        meta.columns.forEach((column, key) => {
+            if (typeof key === "string") {
+                // Acceder a la propiedad directamente para activar getters virtuales
+                const value = this[key];
+                if (value !== undefined) {
+                    result[key] = value;
+                }
+            }
+        });
+        // Incluir propiedades enumerables ad-hoc no registradas como relaciones
+        // Esto permite persistir campos opcionales sin decoradores (p.ej. 'notes')
+        for (const key of Object.keys(this)) {
+            if (result[key] !== undefined)
+                continue;
+            if (meta.relations.has && meta.relations.has(key))
+                continue;
+            const val = this[key];
+            if (val === undefined)
+                continue;
+            if (typeof val === "function")
+                continue;
+            result[key] = val;
+        }
+        return result;
+    }
+    /** Guardar instancia (crear o actualizar) */
+    async save() {
+        const id = this.id;
+        const Ctor = this.constructor;
+        const meta = (0, wrapper_1.mustMeta)(Ctor);
+        const now = new Date().toISOString();
+        const isNew = id === undefined || id === null;
+        // Actualizar campos de timestamp
+        meta.columns.forEach((col, key) => {
+            if (col.createdAt && isNew) {
+                // Solo establecer createdAt si es un nuevo registro
+                this[key] = now;
+            }
+            else if (col.updatedAt) {
+                // Actualizar updatedAt en cada guardado
+                this[key] = now;
+            }
+        });
+        const payload = this.toJSON();
+        const client = (0, client_1.requireClient)();
+        if (isNew) {
+            // Crear nuevo registro
+            const created = await Ctor.create(payload);
+            Object.assign(this, created);
+        }
+        else {
+            // Actualizar registro existente
+            await client.send(new client_dynamodb_1.PutItemCommand({
+                TableName: meta.name,
+                Item: (0, util_dynamodb_1.marshall)(payload, { removeUndefinedValues: true }),
+            }));
+        }
+        return this;
+    }
+    /** Actualizar instancia */
+    async update(patch) {
+        Object.assign(this, patch);
+        return await this.save();
+    }
+    /** Eliminar instancia */
+    async destroy() {
+        const id = this.id;
+        if (id === undefined || id === null) {
+            throw new Error("destroy() requiere que la instancia tenga un id");
+        }
+        const Ctor = this.constructor;
+        return await Ctor.delete({ id: String(id) });
+    }
+    // ===========================================================================
+    // MÉTODOS ESTÁTICOS SEGÚN ESPECIFICACIONES
+    // ===========================================================================
+    /**
+     * Crear un nuevo registro en la base de datos
+     */
+    static async create(data) {
+        const client = (0, client_1.requireClient)();
+        const meta = (0, wrapper_1.mustMeta)(this);
+        const instance = new this(data);
+        // Establecer timestamps si corresponde
+        const now = new Date().toISOString();
+        meta.columns.forEach((col, key) => {
+            if (col.createdAt && instance[key] === undefined) {
+                instance[key] = now;
+            }
+            if (col.updatedAt) {
+                instance[key] = now;
+            }
+        });
+        const payload = instance.toJSON();
+        await client.send(new client_dynamodb_1.PutItemCommand({
+            TableName: meta.name,
+            Item: (0, util_dynamodb_1.marshall)(payload, { removeUndefinedValues: true }),
+        }));
+        return instance;
+    }
+    /**
+     * Actualizar registros en la base de datos
+     * @param updates - Campos a actualizar. Los campos con valor `undefined` se ignoran.
+     * @param filters - Filtros para seleccionar los registros a actualizar
+     * @returns Número de registros actualizados
+     */
+    static async update(updates, filters) {
+        // Obtener metadatos del modelo para manejar timestamps
+        const meta = (0, wrapper_1.mustMeta)(this);
+        const client = (0, client_1.requireClient)();
+        // Buscar registros que coincidan con los filtros
+        const recordsToUpdate = await this.where(filters);
+        if (recordsToUpdate.length === 0) {
+            return 0;
+        }
+        // No filtrar campos undefined aquí para permitir establecer valores nulos/explicitos
+        const cleanUpdates = { ...updates };
+        // Verificar si hay campos para actualizar
+        if (Object.keys(cleanUpdates).length === 0) {
+            return recordsToUpdate.length; // No hay cambios que hacer
+        }
+        // Actualizar cada registro
+        const updatePromises = recordsToUpdate.map(async (record) => {
+            // Obtener datos actuales
+            const currentData = record.toJSON();
+            // Aplicar actualizaciones, preservando valores existentes
+            const updatedData = { ...currentData };
+            // Aplicar solo los campos que no son undefined
+            for (const [key, value] of Object.entries(cleanUpdates)) {
+                if (value !== undefined) {
+                    updatedData[key] = value;
+                }
+            }
+            // Actualizar timestamp updated_at si está configurado
+            let updatedAtKey = undefined;
+            for (const [k, col] of meta.columns.entries()) {
+                if (col.updatedAt === true) {
+                    updatedAtKey = k;
+                    break;
+                }
+            }
+            if (updatedAtKey !== undefined) {
+                updatedData[String(updatedAtKey)] = new Date().toISOString();
+            }
+            // Actualizar en la base de datos
+            await client.send(new client_dynamodb_1.PutItemCommand({
+                TableName: meta.name,
+                Item: (0, util_dynamodb_1.marshall)(updatedData, { removeUndefinedValues: true }),
+            }));
+        });
+        await Promise.all(updatePromises);
+        return recordsToUpdate.length;
+    }
+    /**
+     * Eliminar registros de la base de datos
+     */
+    static async delete(filters) {
+        const recordsToDelete = await this.where(filters);
+        if (recordsToDelete.length === 0) {
+            return 0;
+        }
+        const client = (0, client_1.requireClient)();
+        const meta = (0, wrapper_1.mustMeta)(this);
+        const deletePromises = recordsToDelete.map(async (record) => {
+            const id = record.id;
+            if (id) {
+                await client.send(new client_dynamodb_1.DeleteItemCommand({
+                    TableName: meta.name,
+                    Key: (0, util_dynamodb_1.marshall)({ id: String(id) }),
+                }));
+            }
+        });
+        await Promise.all(deletePromises);
+        return recordsToDelete.length;
+    }
+    /** Implementación del método where */
+    static async where(...args) {
+        const client = (0, client_1.requireClient)();
+        const meta = (0, wrapper_1.mustMeta)(this);
+        let filters;
+        let options = {};
+        let operator = "=";
+        // Parsear argumentos según la sobrecarga utilizada
+        if (args.length === 2) {
+            if (typeof args[0] === "string") {
+                // where(field, value) - check if value is array for IN operation
+                const value = args[1];
+                if (Array.isArray(value)) {
+                    operator = "in";
+                }
+                filters = { [args[0]]: value };
+            }
+            else {
+                // where(filters, options)
+                filters = args[0];
+                options = args[1] || {};
+            }
+        }
+        else if (args.length === 3) {
+            // where(field, operator, value)
+            const [field, op, value] = args;
+            operator = validateOperator(op);
+            filters = { [field]: value };
+        }
+        else if (args.length === 1) {
+            // where(filters)
+            filters = args[0];
+        }
+        else {
+            throw new Error("Argumentos inválidos para where()");
+        }
+        // Validar límites y opciones
+        if (options.limit && options.limit < 0) {
+            throw new Error("limit debe ser mayor o igual a 0");
+        }
+        if (options.skip && options.skip < 0) {
+            throw new Error("skip debe ser mayor o igual a 0");
+        }
+        if (options.order && !["ASC", "DESC"].includes(options.order)) {
+            throw new Error('order debe ser "ASC" o "DESC"');
+        }
+        // Construir la consulta DynamoDB
+        const { expression, names, values } = buildConditionExpression(filters, operator);
+        const scanParams = {
+            TableName: meta.name,
+        };
+        // Initialize ExpressionAttributeNames to avoid conflicts
+        if (!scanParams.ExpressionAttributeNames) {
+            scanParams.ExpressionAttributeNames = {};
+        }
+        if (expression) {
+            scanParams.FilterExpression = expression;
+            // Merge filter attribute names
+            Object.assign(scanParams.ExpressionAttributeNames, names);
+            scanParams.ExpressionAttributeValues = (0, util_dynamodb_1.marshall)(values);
+        }
+        if (options.attributes) {
+            // Handle projection attributes with proper aliases
+            const projectionExpressions = options.attributes.map((attr, index) => {
+                const aliasKey = `#proj${index}`;
+                scanParams.ExpressionAttributeNames[aliasKey] = attr;
+                return aliasKey;
+            });
+            scanParams.ProjectionExpression = projectionExpressions.join(", ");
+        }
+        // Ejecutar consulta con paginación
+        let allItems = [];
+        let lastEvaluatedKey = undefined;
+        let scannedCount = 0;
+        const targetSkip = options.skip || 0;
+        const targetLimit = options.limit || 100;
+        do {
+            if (lastEvaluatedKey) {
+                scanParams.ExclusiveStartKey = lastEvaluatedKey;
+            }
+            const result = await client.send(new client_dynamodb_1.ScanCommand(scanParams));
+            if (result.Items) {
+                const items = result.Items.map((item) => (0, util_dynamodb_1.unmarshall)(item));
+                for (const item of items) {
+                    if (scannedCount < targetSkip) {
+                        scannedCount++;
+                        continue;
+                    }
+                    if (allItems.length >= targetLimit) {
+                        break;
+                    }
+                    allItems.push(item);
+                    scannedCount++;
+                }
+            }
+            lastEvaluatedKey = result.LastEvaluatedKey;
+        } while (lastEvaluatedKey && allItems.length < targetLimit);
+        // Aplicar ordenamiento
+        if (options.order) {
+            allItems.sort((a, b) => {
+                const sortField = Object.keys(filters)[0] || "id";
+                const aVal = a[sortField];
+                const bVal = b[sortField];
+                if (aVal < bVal)
+                    return options.order === "ASC" ? -1 : 1;
+                if (aVal > bVal)
+                    return options.order === "ASC" ? 1 : -1;
+                return 0;
+            });
+        }
+        // Convertir a instancias del modelo
+        const instances = allItems.map((item) => {
+            if (options.attributes) {
+                // When using attribute selection, create minimal instances
+                // only with the requested fields to avoid default value population
+                const instance = Object.create(this.prototype);
+                Object.assign(instance, item);
+                return instance;
+            }
+            else {
+                // Normal instantiation with all defaults
+                return new this(item);
+            }
+        });
+        // Procesar includes si están presentes
+        if (options.include) {
+            return await (0, relations_1.processIncludes)(this, instances, options.include);
+        }
+        return instances;
+    }
+    static async first(...args) {
+        const results = await this.where(...args);
+        return results[0] || undefined;
+    }
+    static async last(...args) {
+        // Soporte de firmas sin generar una cuarta sobrecarga inválida para where()
+        if (args.length === 0) {
+            const results = await this.where({}, { order: "DESC", limit: 1 });
+            return results[0] || undefined;
+        }
+        if (args.length === 1) {
+            if (typeof args[0] === "object" && !Array.isArray(args[0])) {
+                const results = await this.where(args[0], {
+                    order: "DESC",
+                    limit: 1,
+                });
+                return results[0] || undefined;
+            }
+            throw new Error("Se requiere un valor para el campo de filtro");
+        }
+        if (args.length === 2) {
+            // field, value
+            const results = await this.where(args[0], args[1]);
+            return results[results.length - 1];
+        }
+        if (args.length === 3) {
+            // field, operator, value
+            const results = await this.where(args[0], args[1], args[2]);
+            return results[results.length - 1];
+        }
+        if (args.length === 2 && typeof args[1] === "object") {
+            const results = await this.where(args[0], {
+                ...(args[1] || {}),
+                order: "DESC",
+                limit: 1,
+            });
+            return results[0] || undefined;
+        }
+        throw new Error("Argumentos no válidos para last()");
+    }
+}
+exports.default = Table;
+//# sourceMappingURL=table.js.map

package/src/core/wrapper.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @file wrapper.ts
+ * @descripcion Sistema de tipos y wrapper optimizado
+ * @autor Miguel Alejandro
+ * @fecha 2025-01-28
+ */
+import type { Column, WrapperEntry } from "../@types/index";
+export type { Column, WrapperEntry, HasMany, BelongsTo, NonAttribute, CreationOptional, InferAttributes, FilterableAttributes, QueryResult, WhereOptions, WhereOptionsWithoutWhere, QueryOperator, IncludeOptions, IncludeRelationOptions, WhereQueryOptions, Mutate, Validate, } from "../@types/index";
+export declare const STORE: unique symbol;
+declare const wrapper: Map<Function, WrapperEntry>;
+/** Obtener o crear entrada wrapper para constructor */
+export declare const ensureConfig: (ctor: Function, table_name: string) => WrapperEntry;
+/** Obtener o crear configuración de columna para propiedad */
+export declare const ensureColumn: (entry: WrapperEntry, prop: string | symbol, column_name: string) => Column;
+/** Obtener metadatos requeridos (throws si no existen) */
+export declare const mustMeta: (ctor: Function) => WrapperEntry;
+export default wrapper;

package/src/core/wrapper.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * @file wrapper.ts
+ * @descripcion Sistema de tipos y wrapper optimizado
+ * @autor Miguel Alejandro
+ * @fecha 2025-01-28
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mustMeta = exports.ensureColumn = exports.ensureConfig = exports.STORE = void 0;
+exports.STORE = Symbol("dynamite:values");
+const wrapper = new Map();
+/** Obtener o crear entrada wrapper para constructor */
+const ensureConfig = (ctor, table_name) => {
+    const existing = wrapper.get(ctor);
+    if (existing)
+        return existing;
+    const entry = {
+        name: table_name,
+        columns: new Map(),
+        relations: new Map(),
+    };
+    wrapper.set(ctor, entry);
+    return entry;
+};
+exports.ensureConfig = ensureConfig;
+/** Obtener o crear configuración de columna para propiedad */
+const ensureColumn = (entry, prop, column_name) => {
+    const existing = entry.columns.get(prop);
+    if (existing)
+        return existing;
+    const column = { name: column_name, mutate: [], validate: [] };
+    entry.columns.set(prop, column);
+    return column;
+};
+exports.ensureColumn = ensureColumn;
+/** Obtener metadatos requeridos (throws si no existen) */
+const mustMeta = (ctor) => {
+    const meta = wrapper.get(ctor);
+    if (!meta) {
+        throw new Error(`Metadatos no encontrados para ${ctor.name}. ¿Usaste decoradores @Index, @PrimaryKey, etc.?`);
+    }
+    return meta;
+};
+exports.mustMeta = mustMeta;
+exports.default = wrapper;
+//# sourceMappingURL=wrapper.js.map

package/src/decorators/belongs_to.d.ts

@@ -0,0 +1 @@
+export default function BelongsTo(targetModel: () => any, localKey: string, foreignKey?: string): PropertyDecorator;

package/src/decorators/belongs_to.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = BelongsTo;
+const wrapper_1 = require("../core/wrapper");
+function BelongsTo(targetModel, localKey, foreignKey) {
+    return (target, prop) => {
+        const entry = (0, wrapper_1.ensureConfig)(target.constructor, target.constructor.name);
+        entry.relations.set(prop, {
+            type: "belongsTo",
+            targetModel,
+            foreignKey: foreignKey || "id",
+            localKey,
+        });
+        // Crear getter dinámico para la relación
+        Object.defineProperty(target, prop, {
+            get() {
+                return this[`_${prop.toString()}`] || null;
+            },
+            enumerable: true,
+            configurable: true,
+        });
+    };
+}
+//# sourceMappingURL=belongs_to.js.map

package/src/decorators/created_at.d.ts

@@ -0,0 +1 @@
+export default function CreatedAt(): PropertyDecorator;

package/{build → src}/decorators/created_at.js

@@ -1,21 +1,10 @@
 "use strict";
-/*
- * Dinamite ORM — @CreatedAt Decorator (wrapper)
- * -------------------------------------------
- * Establece un valor por defecto con la fecha/hora actual (ISO‑string)
- * usando @Default.
- *
- * © 2025 Miguel Alejandro
- */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = CreatedAt;
 const default_1 = __importDefault(require("./default"));
-/**
- * Asigna automáticamente la fecha de creación en nuevas instancias.
- */
 function CreatedAt() {
     return (0, default_1.default)(() => new Date().toISOString());
 }

package/src/decorators/default.d.ts

@@ -0,0 +1 @@
+export default function Default(factory: any): PropertyDecorator;