@arcaelas/dynamite 1.0.17 → 1.0.19

package/src/core/table.js

@@ -1,82 +1,144 @@
 "use strict";
 /**
  * @file table.ts
- * @descripcion Clase Table rediseñada con API completa y tipado estricto
+ * @description Tabla autocontenida con arquitectura minimalista y Symbol storage
  * @autor Miguel Alejandro
- * @fecha 2025-07-30
+ * @fecha 2025-01-28
  */
 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 */
+const decorator_1 = require("./decorator");
+const relations_1 = require("../utils/relations");
+// Alias de operadores para sintaxis objeto
+const OPERATOR_ALIASES = {
+    '$eq': '=',
+    '$ne': '!=',
+    '$lt': '<',
+    '$lte': '<=',
+    '$gt': '>',
+    '$gte': '>=',
+    '$in': 'in',
+    '$nin': 'not-in',
+    'contains': 'contains',
+    'begins-with': 'begins-with',
+    'beginsWith': 'begins-with',
+    // Operadores directos también soportados
+    '=': '=',
+    '!=': '!=',
+    '<': '<',
+    '<=': '<=',
+    '>': '>',
+    '>=': '>=',
+    'in': 'in',
+    'not-in': 'not-in',
+};
 // =============================================================================
-// FUNCIONES UTILITARIAS
+// FUNCIONES UTILITARIAS SIMPLIFICADAS
 // =============================================================================
 function validateOperator(operator) {
-    const validOps = [
-        "=",
-        "!=",
-        "<",
-        "<=",
-        ">",
-        ">=",
-        "in",
-        "not-in",
-        "contains",
-        "begins-with",
-    ];
+    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 = "=") {
+/**
+ * @description Detecta si un valor es un objeto con operadores
+ */
+function isOperatorObject(value) {
+    if (value === null || value === undefined || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    // Es objeto con operadores si alguna key es un operador conocido
+    return Object.keys(value).some(key => key in OPERATOR_ALIASES);
+}
+/**
+ * @description Genera expresión para un operador y valor específico
+ */
+function buildSingleExpression(nameKey, valueKeyPrefix, op, val, names, values, fieldName) {
+    // Manejar arrays vacíos
+    if (op === "in" && Array.isArray(val) && val.length === 0) {
+        return "1 = 0"; // Ningún resultado coincide
+    }
+    if (op === "not-in" && Array.isArray(val) && val.length === 0) {
+        return null; // Excluir nada = todo pasa
+    }
+    names[nameKey] = fieldName;
+    if (op === "in" && Array.isArray(val)) {
+        const inValues = val.map((v, i) => {
+            const inValueKey = `${valueKeyPrefix}_${i}`;
+            values[inValueKey] = v;
+            return inValueKey;
+        });
+        return `${nameKey} IN (${inValues.join(", ")})`;
+    }
+    else if (op === "not-in" && Array.isArray(val)) {
+        const notInValues = val.map((v, i) => {
+            const notInValueKey = `${valueKeyPrefix}_${i}`;
+            values[notInValueKey] = v;
+            return notInValueKey;
+        });
+        return `NOT ${nameKey} IN (${notInValues.join(", ")})`;
+    }
+    else if (op === "contains") {
+        values[valueKeyPrefix] = val;
+        return `contains(${nameKey}, ${valueKeyPrefix})`;
+    }
+    else if (op === "begins-with") {
+        values[valueKeyPrefix] = val;
+        return `begins_with(${nameKey}, ${valueKeyPrefix})`;
+    }
+    else if (op === "!=") {
+        values[valueKeyPrefix] = val;
+        return `${nameKey} <> ${valueKeyPrefix}`;
+    }
+    else {
+        values[valueKeyPrefix] = val;
+        return `${nameKey} ${op} ${valueKeyPrefix}`;
+    }
+}
+function buildConditionExpression(filters, defaultOperator = "=") {
     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}`);
+    let index = 0;
+    for (const [fieldName, filterValue] of Object.entries(filters)) {
+        // Ignorar valores undefined
+        if (filterValue === undefined)
+            continue;
+        // Detectar sintaxis objeto con operadores: { campo: { operador: valor } }
+        if (isOperatorObject(filterValue)) {
+            // Procesar cada operador en el objeto
+            for (const [opKey, opValue] of Object.entries(filterValue)) {
+                // Ignorar valores undefined dentro del objeto
+                if (opValue === undefined)
+                    continue;
+                const resolvedOp = OPERATOR_ALIASES[opKey];
+                if (!resolvedOp)
+                    continue; // Ignorar keys desconocidas
+                const nameKey = `#attr${index}`;
+                const valueKey = `:val${index}`;
+                const expr = buildSingleExpression(nameKey, valueKey, resolvedOp, opValue, names, values, fieldName);
+                if (expr)
+                    expressions.push(expr);
+                index++;
+            }
         }
         else {
-            values[valueKey] = value;
-            expressions.push(`${nameKey} ${operator} ${valueKey}`);
+            // Valor simple: usar operador default
+            // Ignorar null solo si no hay operador explícito
+            if (filterValue === null)
+                continue;
+            const nameKey = `#attr${index}`;
+            const valueKey = `:val${index}`;
+            const expr = buildSingleExpression(nameKey, valueKey, defaultOperator, filterValue, names, values, fieldName);
+            if (expr)
+                expressions.push(expr);
+            index++;
         }
-    });
+    }
     return {
         expression: expressions.join(" AND "),
         names,
@@ -84,297 +146,398 @@ function buildConditionExpression(filters, operator = "=") {
     };
 }
 // =============================================================================
-// CLASE TABLE REDISEÑADA
+// CLASE TABLE AUTOCONTENIDA
 // =============================================================================
 class Table {
-    constructor(data) {
+    constructor(props = {}) {
         (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;
+        const schema = this.constructor[decorator_1.SCHEMA];
+        // Inicializar VALUES
+        this[decorator_1.VALUES] = {};
+        // Procesar cada columna del schema
+        for (const column_name in schema.columns) {
+            const column = schema.columns[column_name];
+            if (column.store?.relation) {
+                // ═══════════════════════════════════════════════════════════════
+                // RELACIONES: getter lazy que convierte a instancias, setter bloqueado
+                // ═══════════════════════════════════════════════════════════════
+                let relation_data = props[column_name] ?? undefined;
+                Object.defineProperty(this, column_name, {
+                    enumerable: true,
+                    configurable: true, // Permite reconfigurar cuando processIncludes carga datos
+                    set: () => undefined, // Relaciones son read-only
+                    get: () => {
+                        if (relation_data === undefined)
+                            return undefined;
+                        const RelatedModel = column.store.relation.model();
+                        const type = column.store.relation.type;
+                        if (type === 'HasMany') {
+                            // HasMany: Array de instancias
+                            return [].concat(relation_data ?? [])
+                                .filter(Boolean)
+                                .map((item) => item instanceof RelatedModel ? item : new RelatedModel(item));
+                        }
+                        else {
+                            // HasOne / BelongsTo: Instancia única o null
+                            if (relation_data === null)
+                                return null;
+                            return relation_data instanceof RelatedModel
+                                ? relation_data
+                                : new RelatedModel(relation_data);
+                        }
+                    },
+                });
+            }
+            else {
+                // ═══════════════════════════════════════════════════════════════
+                // COLUMNAS REGULARES: getter/setter con pipelines via reduce
+                // ═══════════════════════════════════════════════════════════════
+                const has_initial_value = column_name in props;
+                let value = has_initial_value ? props[column_name] : null;
+                // Aplicar set pipeline en inicialización (solo si usuario proporciona valor)
+                if (has_initial_value) {
+                    value = column.set.reduce((v, fn) => fn(v), value);
                 }
+                // Almacenar en VALUES para compatibilidad con métodos existentes
+                this[decorator_1.VALUES][column_name] = value;
+                Object.defineProperty(this, column_name, {
+                    enumerable: true,
+                    configurable: true,
+                    get: () => {
+                        // Aplicar get pipeline
+                        let v = column.get.reduce((val, fn) => fn(val), value);
+                        // Almacenar si se generó default (para consistencia)
+                        if (value === null && v !== null) {
+                            value = v;
+                            this[decorator_1.VALUES][column_name] = v;
+                        }
+                        return v;
+                    },
+                    set: (new_value) => {
+                        // Aplicar set pipeline
+                        value = column.set.reduce((v, fn) => fn(v), new_value ?? null);
+                        this[decorator_1.VALUES][column_name] = value;
+                    },
+                });
             }
-        });
-        Object.assign(this, data);
+        }
     }
-    /** Serializar instancia a JSON plano */
+    // **Métodos de instancia con API preservada**
+    /**
+     * @description Serializa la instancia a JSON incluyendo relaciones recursivamente
+     * @returns Objeto JSON con todas las propiedades y relaciones
+     */
     toJSON() {
-        const meta = (0, wrapper_1.mustMeta)(Object.getPrototypeOf(this).constructor);
+        const schema = this.constructor[decorator_1.SCHEMA];
         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;
+        for (const column_name in schema.columns) {
+            const column = schema.columns[column_name];
+            const value = this[column_name];
+            if (value === null || value === undefined)
+                continue;
+            if (column.store?.relation) {
+                // Serializar relaciones recursivamente
+                if (Array.isArray(value)) {
+                    result[column_name] = value.map(item => item?.toJSON ? item.toJSON() : item);
+                }
+                else {
+                    result[column_name] = value?.toJSON ? value.toJSON() : 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")
+            else {
+                result[column_name] = value;
+            }
+        }
+        return result;
+    }
+    /**
+     * @description Serializa la instancia a string JSON
+     * @returns String JSON con todas las propiedades y relaciones
+     */
+    toString() {
+        return JSON.stringify(this);
+    }
+    /**
+     * @description Genera payload para operaciones de DB (excluye relaciones)
+     */
+    _toDBPayload() {
+        const schema = this.constructor[decorator_1.SCHEMA];
+        const result = {};
+        for (const column_name in schema.columns) {
+            const column = schema.columns[column_name];
+            if (column.store?.relation)
                 continue;
-            result[key] = val;
+            const value = this[column_name];
+            if (value !== null && value !== undefined) {
+                result[column_name] = value;
+            }
         }
         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;
+        const schema = this.constructor[decorator_1.SCHEMA];
+        const id = this[decorator_1.VALUES][schema.primary_key];
+        const is_new = id === undefined || id === null;
+        // Validación lazy
+        for (const column_name in schema.columns) {
+            const column = schema.columns[column_name];
+            if (column.store?.lazy_validators && !column.store?.relation) {
+                const value = this[decorator_1.VALUES][column_name];
+                for (const validator of column.store.lazy_validators) {
+                    const result = validator(value);
+                    if (result !== true) {
+                        throw new Error(typeof result === "string" ? result : "Validación fallida");
+                    }
+                }
             }
-            else if (col.updatedAt) {
-                // Actualizar updatedAt en cada guardado
-                this[key] = now;
+        }
+        // Timestamps automáticos (updatedAt solamente, createdAt se genera via pipeline)
+        const now = new Date().toISOString();
+        for (const column_name in schema.columns) {
+            const column = schema.columns[column_name];
+            if (column.store?.updatedAt) {
+                // Usar setter para sincronizar closure y VALUES
+                this[column_name] = 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);
+        }
+        // Preparar datos para DB (omitir relaciones)
+        const db_data = this._toDBPayload();
+        if (is_new) {
+            // Insertar nuevo registro
+            await this.insertIntoDynamoDB(db_data);
         }
         else {
             // Actualizar registro existente
-            await client.send(new client_dynamodb_1.PutItemCommand({
-                TableName: meta.name,
-                Item: (0, util_dynamodb_1.marshall)(payload, { removeUndefinedValues: true }),
-            }));
+            await this.updateInDynamoDB(db_data);
         }
         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 schema = this.constructor[decorator_1.SCHEMA];
+        const id = this[decorator_1.VALUES][schema.primary_key];
+        if (!id) {
+            throw new Error('Cannot destroy record without ID');
         }
-        const Ctor = this.constructor;
-        return await Ctor.delete({ id: String(id) });
+        // Buscar si hay soft delete configurado
+        let softDeleteColumn = null;
+        for (const column_name in schema.columns) {
+            const column = schema.columns[column_name];
+            if (column.store?.softDelete) {
+                softDeleteColumn = column_name;
+                break;
+            }
+        }
+        if (softDeleteColumn) {
+            // Soft delete
+            this[decorator_1.VALUES][softDeleteColumn] = new Date().toISOString();
+            await this.save();
+        }
+        else {
+            // Hard delete
+            await this.deleteFromDynamoDB(id);
+        }
+        return null;
     }
-    // ===========================================================================
-    // 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);
+    async forceDestroy() {
+        const schema = this.constructor[decorator_1.SCHEMA];
+        const id = this[decorator_1.VALUES][schema.primary_key];
+        if (!id) {
+            throw new Error('Cannot destroy record without ID');
+        }
+        await this.deleteFromDynamoDB(id);
+        return null;
+    }
+    // **Métodos estáticos con API preservada**
+    static async create(data, tx) {
         const instance = new this(data);
         // Establecer timestamps si corresponde
+        const schema = this[decorator_1.SCHEMA];
         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;
+        // Solo updatedAt, createdAt se genera via pipeline
+        for (const column_name in schema.columns) {
+            const column = schema.columns[column_name];
+            if (column.store?.updatedAt) {
+                // Usar setter para sincronizar closure y VALUES
+                instance[column_name] = 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 }),
-        }));
+        }
+        const payload = instance._toDBPayload();
+        if (tx) {
+            tx.addPut(schema.name, payload);
+        }
+        else {
+            const client = (0, client_1.requireClient)();
+            await client.send(new client_dynamodb_1.PutItemCommand({
+                TableName: schema.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) {
+    static async update(updates, filters, tx) {
+        const records = await this.where(filters);
+        if (records.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;
-                }
+        let updatedCount = 0;
+        const schema = this[decorator_1.SCHEMA];
+        const client = tx ? null : (0, client_1.requireClient)();
+        for (const record of records) {
+            // Aplicar actualizaciones
+            for (const [key, value] of Object.entries(updates)) {
+                record[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;
+            // Actualizar timestamp
+            const now = new Date().toISOString();
+            for (const column_name in schema.columns) {
+                const column = schema.columns[column_name];
+                if (column.store?.updatedAt) {
+                    // Usar setter para sincronizar closure y VALUES
+                    record[column_name] = now;
                     break;
                 }
             }
-            if (updatedAtKey !== undefined) {
-                updatedData[String(updatedAtKey)] = new Date().toISOString();
+            const updated_data = record._toDBPayload();
+            if (tx) {
+                tx.addPut(schema.name, updated_data);
             }
-            // 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;
+            else {
+                await client.send(new client_dynamodb_1.PutItemCommand({
+                    TableName: schema.name,
+                    Item: (0, util_dynamodb_1.marshall)(updated_data, { removeUndefinedValues: true }),
+                }));
+            }
+            updatedCount++;
+        }
+        return updatedCount;
     }
-    /**
-     * Eliminar registros de la base de datos
-     */
-    static async delete(filters) {
-        const recordsToDelete = await this.where(filters);
-        if (recordsToDelete.length === 0) {
+    static async delete(filters, tx) {
+        const records = await this.where(filters);
+        if (records.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;
+        const schema = this[decorator_1.SCHEMA];
+        const client = tx ? null : (0, client_1.requireClient)();
+        let deletedCount = 0;
+        for (const record of records) {
+            const id = record[decorator_1.VALUES][schema.primary_key];
             if (id) {
-                await client.send(new client_dynamodb_1.DeleteItemCommand({
-                    TableName: meta.name,
-                    Key: (0, util_dynamodb_1.marshall)({ id: String(id) }),
-                }));
+                if (tx) {
+                    tx.addDelete(schema.name, { [schema.primary_key]: id });
+                }
+                else {
+                    await client.send(new client_dynamodb_1.DeleteItemCommand({
+                        TableName: schema.name,
+                        Key: (0, util_dynamodb_1.marshall)({ [schema.primary_key]: id }),
+                    }));
+                }
+                deletedCount++;
             }
-        });
-        await Promise.all(deletePromises);
-        return recordsToDelete.length;
+        }
+        return deletedCount;
     }
-    /** Implementación del método where */
-    static async where(...args) {
+    static async where(field_or_filters, operator_or_value, value, options) {
         const client = (0, client_1.requireClient)();
-        const meta = (0, wrapper_1.mustMeta)(this);
+        const schema = this[decorator_1.SCHEMA];
+        // Parsear argumentos dinámicamente (como el original)
         let filters;
-        let options = {};
+        let queryOptions;
         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] || {};
-            }
+        if (typeof operator_or_value === 'string') {
+            // where(field, operator, value, options?)
+            operator = validateOperator(operator_or_value);
+            filters = { [field_or_filters]: value };
+            queryOptions = options || {};
         }
-        else if (args.length === 3) {
-            // where(field, operator, value)
-            const [field, op, value] = args;
-            operator = validateOperator(op);
-            filters = { [field]: value };
+        else if (value !== undefined) {
+            // where(field, value, options?)
+            filters = { [field_or_filters]: Array.isArray(operator_or_value) ? { in: operator_or_value } : operator_or_value };
+            queryOptions = value || {};
         }
-        else if (args.length === 1) {
-            // where(filters)
-            filters = args[0];
+        else if (operator_or_value !== undefined && typeof operator_or_value === 'object') {
+            // where(filters, options?)
+            filters = field_or_filters;
+            queryOptions = operator_or_value;
         }
         else {
-            throw new Error("Argumentos inválidos para where()");
+            // where(filters?)
+            filters = field_or_filters;
+            queryOptions = {};
         }
-        // Validar límites y opciones
-        if (options.limit && options.limit < 0) {
+        // Validar opciones
+        if (queryOptions.limit === 0)
+            return [];
+        if (queryOptions.limit && queryOptions.limit < 0) {
             throw new Error("limit debe ser mayor o igual a 0");
         }
-        if (options.skip && options.skip < 0) {
+        if (queryOptions.skip && queryOptions.skip < 0) {
             throw new Error("skip debe ser mayor o igual a 0");
         }
-        if (options.order && !["ASC", "DESC"].includes(options.order)) {
+        if (queryOptions.order && !["ASC", "DESC"].includes(queryOptions.order)) {
             throw new Error('order debe ser "ASC" o "DESC"');
         }
-        // Construir la consulta DynamoDB
+        // Auto-excluir soft deleted
+        if (!queryOptions._includeTrashed) {
+            for (const column_name in schema.columns) {
+                const column = schema.columns[column_name];
+                if (column.store?.softDelete && !(column_name in filters)) {
+                    filters[column_name] = null;
+                    break;
+                }
+            }
+        }
+        // Construir consulta DynamoDB
         const { expression, names, values } = buildConditionExpression(filters, operator);
         const scanParams = {
-            TableName: meta.name,
+            TableName: schema.name,
+            ExpressionAttributeNames: names || {},
         };
-        // 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);
+            scanParams.ExpressionAttributeValues = (0, util_dynamodb_1.marshall)(values || {}, { removeUndefinedValues: true });
         }
-        if (options.attributes) {
-            // Handle projection attributes with proper aliases
-            const projectionExpressions = options.attributes.map((attr, index) => {
+        // Proyección solo si hay atributos específicos (ignorar array vacío)
+        if (queryOptions.attributes && queryOptions.attributes.length > 0) {
+            const projectionExpressions = queryOptions.attributes.map((attr, index) => {
                 const aliasKey = `#proj${index}`;
-                scanParams.ExpressionAttributeNames[aliasKey] = attr;
+                scanParams.ExpressionAttributeNames[aliasKey] = String(attr);
                 return aliasKey;
             });
             scanParams.ProjectionExpression = projectionExpressions.join(", ");
         }
+        // Limpiar ExpressionAttributeNames si está vacío (DynamoDB lo rechaza)
+        if (Object.keys(scanParams.ExpressionAttributeNames).length === 0) {
+            delete scanParams.ExpressionAttributeNames;
+        }
         // Ejecutar consulta con paginación
         let allItems = [];
         let lastEvaluatedKey = undefined;
         let scannedCount = 0;
-        const targetSkip = options.skip || 0;
-        const targetLimit = options.limit || 100;
+        const targetSkip = queryOptions.skip || 0;
+        const targetLimit = queryOptions.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));
+                const items = result.Items.map((item) => {
+                    const raw = (0, util_dynamodb_1.unmarshall)(item);
+                    // Limpiar null/undefined
+                    for (const k of Object.keys(raw)) {
+                        if (raw[k] === null || raw[k] === undefined) {
+                            delete raw[k];
+                        }
+                    }
+                    return raw;
+                });
                 for (const item of items) {
                     if (scannedCount < targetSkip) {
                         scannedCount++;
                         continue;
                     }
-                    if (allItems.length >= targetLimit) {
+                    if (allItems.length >= targetLimit)
                         break;
-                    }
                     allItems.push(item);
                     scannedCount++;
                 }
@@ -382,77 +545,114 @@ class Table {
             lastEvaluatedKey = result.LastEvaluatedKey;
         } while (lastEvaluatedKey && allItems.length < targetLimit);
         // Aplicar ordenamiento
-        if (options.order) {
+        if (queryOptions.order) {
             allItems.sort((a, b) => {
-                const sortField = Object.keys(filters)[0] || "id";
+                const sortField = Object.keys(filters)[0] || schema.primary_key;
                 const aVal = a[sortField];
                 const bVal = b[sortField];
                 if (aVal < bVal)
-                    return options.order === "ASC" ? -1 : 1;
+                    return queryOptions.order === "ASC" ? -1 : 1;
                 if (aVal > bVal)
-                    return options.order === "ASC" ? 1 : -1;
+                    return queryOptions.order === "ASC" ? 1 : -1;
                 return 0;
             });
         }
-        // Convertir a instancias del modelo
+        // Convertir a instancias (schema ya definido arriba)
         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
+            if (queryOptions.attributes) {
+                // Proyección parcial: crear instancia con solo los atributos solicitados
                 const instance = Object.create(this.prototype);
-                Object.assign(instance, item);
+                instance[decorator_1.VALUES] = item;
+                // Definir getters para los atributos proyectados
+                for (const attr of queryOptions.attributes) {
+                    const column = schema.columns[attr];
+                    if (column) {
+                        Object.defineProperty(instance, attr, {
+                            enumerable: true,
+                            configurable: true,
+                            get: () => {
+                                let value = instance[decorator_1.VALUES][attr] ?? null;
+                                // Aplicar get pipeline
+                                for (const fn of column.get) {
+                                    value = fn(value);
+                                }
+                                return value;
+                            }
+                        });
+                    }
+                }
                 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);
+        // Procesar includes para cargar relaciones
+        if (queryOptions.include) {
+            await (0, relations_1.processIncludes)(instances, queryOptions.include, this);
         }
         return instances;
     }
-    static async first(...args) {
-        const results = await this.where(...args);
-        return results[0] || undefined;
+    static async first(field_or_filters, operator_or_value, value_or_options) {
+        const results = await this.where(field_or_filters, operator_or_value, value_or_options, { limit: 1 });
+        return results[0];
     }
-    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;
+    static async last(field_or_filters, operator_or_value) {
+        if (field_or_filters === undefined) {
+            const results = await this.where({}, { order: 'DESC', limit: 1 });
+            return results[0];
+        }
+        else {
+            const results = await this.where(field_or_filters, operator_or_value, undefined, { order: 'DESC', limit: 1 });
+            return results[0];
+        }
+    }
+    static async withTrashed(filters, options) {
+        return await this.where(filters ?? {}, { ...options, _includeTrashed: true });
+    }
+    static async onlyTrashed(filters, options) {
+        const schema = this[decorator_1.SCHEMA];
+        let softDeleteColumn = null;
+        for (const column_name in schema.columns) {
+            const column = schema.columns[column_name];
+            if (column.store?.softDelete) {
+                softDeleteColumn = column_name;
+                break;
             }
-            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()");
+        if (!softDeleteColumn) {
+            throw new Error("onlyTrashed() requiere un campo @SoftDelete configurado");
+        }
+        const merged_filters = {
+            ...filters,
+            [softDeleteColumn]: { "!=": null },
+        };
+        return await this.where(merged_filters, { ...options, _includeTrashed: true });
+    }
+    // **Métodos privados para DynamoDB**
+    async insertIntoDynamoDB(data) {
+        const client = (0, client_1.requireClient)();
+        const schema = this.constructor[decorator_1.SCHEMA];
+        await client.send(new client_dynamodb_1.PutItemCommand({
+            TableName: schema.name,
+            Item: (0, util_dynamodb_1.marshall)(data, { removeUndefinedValues: true }),
+        }));
+    }
+    async updateInDynamoDB(data) {
+        const client = (0, client_1.requireClient)();
+        const schema = this.constructor[decorator_1.SCHEMA];
+        await client.send(new client_dynamodb_1.PutItemCommand({
+            TableName: schema.name,
+            Item: (0, util_dynamodb_1.marshall)(data, { removeUndefinedValues: true }),
+        }));
+    }
+    async deleteFromDynamoDB(id) {
+        const client = (0, client_1.requireClient)();
+        const schema = this.constructor[decorator_1.SCHEMA];
+        await client.send(new client_dynamodb_1.DeleteItemCommand({
+            TableName: schema.name,
+            Key: (0, util_dynamodb_1.marshall)({ [schema.primary_key]: id }),
+        }));
     }
 }
 exports.default = Table;