@arcaelas/dynamite 1.0.29 → 3.1.0

package/build/esm/core/table.js

@@ -0,0 +1,950 @@
+/**
+ * @file table.ts
+ * @description Tabla autocontenida con arquitectura minimalista y Symbol storage
+ * @autor Miguel Alejandro
+ * @fecha 2025-01-28
+ */
+import { DeleteItemCommand, GetItemCommand, PutItemCommand, QueryCommand, ScanCommand, UpdateItemCommand, } from "@aws-sdk/client-dynamodb";
+import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";
+import { processIncludes } from "../utils/relations.js";
+import { requireClient } from "./client.js";
+import { SCHEMA } from "./decorator.js";
+const OP_MAP = {
+    '=': '=', '<>': '<>', '!=': '<>', '<': '<', '<=': '<=', '>': '>', '>=': '>=',
+    in: 'in', include: 'include', contains: 'include',
+    $eq: '=', $ne: '<>', $lt: '<', $lte: '<=', $gt: '>', $gte: '>=',
+    $in: 'in', $include: 'include', $contains: 'include',
+    $exists: 'attribute_exists', $notExists: 'attribute_not_exists',
+};
+const OPERATORS = new Set(Object.keys(OP_MAP));
+export default class Table {
+    constructor(props = {}) {
+        requireClient();
+        const schema = this.constructor[SCHEMA];
+        // Flag de persistencia con closure (no enumerable)
+        let __isPersisted = false;
+        Object.defineProperty(this, "__isPersisted", {
+            enumerable: false,
+            configurable: false,
+            get: () => __isPersisted,
+            set: (v) => {
+                __isPersisted = v;
+            },
+        });
+        for (const column_name in schema.columns) {
+            const column = schema.columns[column_name];
+            if (column.store?.relation) {
+                let relation_value = props[column_name] ?? undefined;
+                let cached = undefined;
+                let dirty = true;
+                Object.defineProperty(this, column_name, {
+                    enumerable: true,
+                    configurable: true,
+                    set: (v) => {
+                        relation_value = v;
+                        dirty = true;
+                    },
+                    get: () => {
+                        if (relation_value === undefined)
+                            return undefined;
+                        if (!dirty)
+                            return cached;
+                        const RelatedModel = column.store.relation.model();
+                        const type = column.store.relation.type;
+                        if (type === "HasMany" || type === "ManyToMany") {
+                            cached = []
+                                .concat(relation_value ?? [])
+                                .filter(Boolean)
+                                .map((item) => item instanceof RelatedModel ? item : new RelatedModel(item));
+                        }
+                        else {
+                            if (relation_value === null) {
+                                cached = null;
+                                dirty = false;
+                                return null;
+                            }
+                            cached =
+                                relation_value instanceof RelatedModel
+                                    ? relation_value
+                                    : new RelatedModel(relation_value);
+                        }
+                        dirty = false;
+                        return cached;
+                    },
+                });
+            }
+            else {
+                // Columna normal con closure
+                let value = props[column_name];
+                Object.defineProperty(this, column_name, {
+                    enumerable: true,
+                    configurable: true,
+                    get: () => {
+                        const computed = column.get.reduce((v, fn) => fn(v), value);
+                        // Cache default values so they don't regenerate on each access
+                        if (value == null && computed != null) {
+                            value = computed;
+                        }
+                        return computed;
+                    },
+                    set: (next) => {
+                        value = column.set.reduce((accumulated, fn) => fn(accumulated, value), next);
+                    },
+                });
+                this[column_name] = props[column_name];
+            }
+        }
+    }
+    toJSON() {
+        const schema = this.constructor[SCHEMA];
+        const result = {};
+        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) {
+                result[column_name] = Array.isArray(value)
+                    ? value.map((item) => (item?.toJSON ? item.toJSON() : item))
+                    : value?.toJSON
+                        ? value.toJSON()
+                        : value;
+            }
+            else {
+                result[column_name] = value;
+            }
+        }
+        return result;
+    }
+    /**
+     * @description Convierte la instancia a un payload listo para DynamoDB
+     * @returns Objeto con nombres de columnas de DB y valores apropiados
+     */
+    _toDBPayload() {
+        const schema = this.constructor[SCHEMA];
+        const payload = {};
+        for (const prop_name in schema.columns) {
+            const column = schema.columns[prop_name];
+            // Skip relations
+            if (column.store?.relation) {
+                continue;
+            }
+            const value = this[prop_name];
+            const db_name = column.name || prop_name;
+            // Skip undefined values (DynamoDB doesn't support them)
+            if (value !== undefined) {
+                payload[db_name] = value;
+            }
+        }
+        return payload;
+    }
+    toString() {
+        return JSON.stringify(this);
+    }
+    async save(options) {
+        const schema = this.constructor[SCHEMA];
+        const tx = options?.tx;
+        if (this.__isPersisted) {
+            if (options?.hook)
+                await Table._run_hooks(this, 'beforeUpdate', {});
+            if (tx) {
+                tx.addPut(schema.name, this._toDBPayload());
+                if (options?.hook)
+                    tx.onCommit(() => Table._run_hooks(this, 'afterUpdate', {}));
+            }
+            else {
+                await requireClient().send(new PutItemCommand({
+                    TableName: schema.name,
+                    Item: marshall(this._toDBPayload(), { removeUndefinedValues: true }),
+                }));
+                if (options?.hook)
+                    await Table._run_hooks(this, 'afterUpdate', {});
+            }
+            return true;
+        }
+        if (options?.hook)
+            await Table._run_hooks(this, 'beforeCreate');
+        const created = await this.constructor.create(Object.fromEntries(Object.keys(schema.columns)
+            .filter(k => !schema.columns[k].store?.relation)
+            .map(k => [k, this[k]])), { hook: false, tx });
+        for (const key in schema.columns) {
+            if (!schema.columns[key].store?.relation) {
+                this[key] = created[key];
+            }
+        }
+        this.__isPersisted = true;
+        if (options?.hook)
+            await Table._run_hooks(this, 'afterCreate');
+        return true;
+    }
+    async update(data, options) {
+        const schema = this.constructor[SCHEMA];
+        // Filtrar relaciones (ignorarlas) en vez de lanzar error
+        const filtered_data = {};
+        for (const key in data) {
+            const column = schema.columns[key];
+            // Solo incluir campos que NO son relaciones
+            if (!column?.store?.relation) {
+                filtered_data[key] = data[key];
+            }
+        }
+        // Ruta con hooks: aplicar cambios y persistir sobre esta misma instancia
+        if (options?.hook) {
+            for (const key in filtered_data) {
+                this[key] = filtered_data[key];
+            }
+            // Auto-renovar campos @UpdatedAt no incluidos en los cambios
+            for (const col_name in schema.columns) {
+                if (schema.columns[col_name].store?.updatedAt && !(col_name in filtered_data)) {
+                    this[col_name] = undefined;
+                }
+            }
+            await Table._run_hooks(this, 'beforeUpdate', filtered_data);
+            const tx = options.tx;
+            if (tx) {
+                tx.addPut(schema.name, this._toDBPayload());
+                tx.onCommit(() => Table._run_hooks(this, 'afterUpdate', filtered_data));
+            }
+            else {
+                await requireClient().send(new PutItemCommand({
+                    TableName: schema.name,
+                    Item: marshall(this._toDBPayload(), { removeUndefinedValues: true }),
+                }));
+                await Table._run_hooks(this, 'afterUpdate', filtered_data);
+            }
+            return true;
+        }
+        const affected = await this.constructor.update(filtered_data, {
+            [schema.primary_key]: this[schema.primary_key],
+        }, { tx: options?.tx });
+        if (affected > 0) {
+            // Actualizar la instancia con los nuevos valores (incluyendo updated_at)
+            for (const key in filtered_data) {
+                this[key] = filtered_data[key];
+            }
+        }
+        return affected > 0;
+    }
+    async destroy(options) {
+        const schema = this.constructor[SCHEMA];
+        const id = this[schema.primary_key];
+        if (!id)
+            throw new Error("Cannot destroy record without ID");
+        if (options?.hook)
+            await Table._run_hooks(this, 'beforeDestroy');
+        let soft_col = null;
+        for (const column_name in schema.columns) {
+            if (schema.columns[column_name].store?.softDelete) {
+                soft_col = column_name;
+                break;
+            }
+        }
+        if (soft_col) {
+            this[soft_col] = new Date().toISOString();
+            await this.save({ tx: options?.tx });
+        }
+        else {
+            await this.forceDestroy({ tx: options?.tx });
+        }
+        if (options?.hook) {
+            if (options.tx)
+                options.tx.onCommit(() => Table._run_hooks(this, 'afterDestroy'));
+            else
+                await Table._run_hooks(this, 'afterDestroy');
+        }
+        return null;
+    }
+    async forceDestroy(options) {
+        const schema = this.constructor[SCHEMA];
+        const id = this[schema.primary_key];
+        if (!id)
+            throw new Error("Cannot destroy record without ID");
+        if (options?.hook)
+            await Table._run_hooks(this, 'beforeDestroy');
+        const tx = options?.tx;
+        if (tx) {
+            tx.addDelete(schema.name, { [schema.primary_key]: id });
+        }
+        else {
+            await requireClient().send(new DeleteItemCommand({
+                TableName: schema.name,
+                Key: marshall({ [schema.primary_key]: id }),
+            }));
+        }
+        if (options?.hook) {
+            if (tx)
+                tx.onCommit(() => Table._run_hooks(this, 'afterDestroy'));
+            else
+                await Table._run_hooks(this, 'afterDestroy');
+        }
+        return null;
+    }
+    async attach(RelatedModel, related_id, pivot_data) {
+        const schema = this.constructor[SCHEMA];
+        const primary_key = schema.primary_key || "id";
+        // VALIDACIÓN PRIORITARIA: Verificar que la instancia esté persistida
+        const local_id = this[primary_key];
+        const is_persisted = this.__isPersisted;
+        if (!local_id || !is_persisted) {
+            throw new Error("No se puede attach sin ID: la instancia debe persistirse primero con save() o create()");
+        }
+        const related_table_name = RelatedModel[SCHEMA]?.name;
+        if (!related_table_name) {
+            throw new Error("Related model no tiene SCHEMA definido");
+        }
+        let relation = null;
+        for (const column_name in schema.columns) {
+            const rel = schema.columns[column_name].store?.relation;
+            if (rel?.type === "ManyToMany" &&
+                rel.model()[SCHEMA]?.name === related_table_name) {
+                relation = rel;
+                break;
+            }
+        }
+        if (!relation) {
+            throw new Error(`No se encontró relación ManyToMany entre ${schema.name} y ${related_table_name}`);
+        }
+        const foreign_key_value = this[relation.localKey];
+        const result = await requireClient().send(new ScanCommand({
+            TableName: relation.pivotTable,
+            FilterExpression: "#fk = :local_id AND #rk = :related_id",
+            ExpressionAttributeNames: {
+                "#fk": relation.foreignKey,
+                "#rk": relation.relatedKey,
+            },
+            ExpressionAttributeValues: marshall({
+                ":local_id": foreign_key_value,
+                ":related_id": related_id,
+            }),
+        }));
+        if (result.Items && result.Items.length > 0)
+            return;
+        await requireClient().send(new PutItemCommand({
+            TableName: relation.pivotTable,
+            Item: marshall({
+                id: `${foreign_key_value}_${related_id}`,
+                [relation.foreignKey]: foreign_key_value,
+                [relation.relatedKey]: related_id,
+                created_at: new Date().toISOString(),
+                ...pivot_data,
+            }, { removeUndefinedValues: true }),
+        }));
+    }
+    async detach(RelatedModel, related_id) {
+        const schema = this.constructor[SCHEMA];
+        const related_table_name = RelatedModel[SCHEMA]?.name;
+        if (!related_table_name)
+            return;
+        let relation = null;
+        for (const column_name in schema.columns) {
+            const rel = schema.columns[column_name].store?.relation;
+            if (rel?.type === "ManyToMany" &&
+                rel.model()[SCHEMA]?.name === related_table_name) {
+                relation = rel;
+                break;
+            }
+        }
+        if (!relation)
+            return;
+        const local_id = this[relation.localKey];
+        if (!local_id)
+            return;
+        const result = await requireClient().send(new ScanCommand({
+            TableName: relation.pivotTable,
+            FilterExpression: "#fk = :local_id AND #rk = :related_id",
+            ExpressionAttributeNames: {
+                "#fk": relation.foreignKey,
+                "#rk": relation.relatedKey,
+            },
+            ExpressionAttributeValues: marshall({
+                ":local_id": local_id,
+                ":related_id": related_id,
+            }),
+        }));
+        if (!result.Items || result.Items.length === 0)
+            return;
+        await requireClient().send(new DeleteItemCommand({
+            TableName: relation.pivotTable,
+            Key: marshall({ id: unmarshall(result.Items[0]).id }),
+        }));
+    }
+    /**
+     * Sincronizar relación ManyToMany reemplazando todas las relaciones existentes
+     * @param RelatedModel Modelo relacionado
+     * @param related_ids Array de IDs a sincronizar
+     */
+    async sync(RelatedModel, related_ids) {
+        const schema = this.constructor[SCHEMA];
+        const related_table_name = RelatedModel[SCHEMA]?.name;
+        if (!related_table_name) {
+            throw new Error(`No se encontró schema para el modelo relacionado`);
+        }
+        // Buscar la relación ManyToMany
+        let relation = null;
+        for (const column_name in schema.columns) {
+            const rel = schema.columns[column_name].store?.relation;
+            if (rel?.type === "ManyToMany" &&
+                rel.model()[SCHEMA]?.name === related_table_name) {
+                relation = rel;
+                break;
+            }
+        }
+        if (!relation) {
+            throw new Error(`No se encontró relación ManyToMany entre ${schema.name} y ${related_table_name}`);
+        }
+        const local_id = this[relation.localKey];
+        if (!local_id) {
+            throw new Error(`El valor de ${relation.localKey} no está definido`);
+        }
+        // 1. Obtener todas las relaciones existentes
+        const scan_result = await requireClient().send(new ScanCommand({
+            TableName: relation.pivotTable,
+            FilterExpression: "#fk = :local_id",
+            ExpressionAttributeNames: { "#fk": relation.foreignKey },
+            ExpressionAttributeValues: marshall({ ":local_id": local_id }),
+        }));
+        const existing_ids = new Set((scan_result.Items || []).map((item) => unmarshall(item)[relation.relatedKey]));
+        const target_ids = new Set(related_ids);
+        // 2. Detach relaciones que no están en la lista objetivo
+        for (const existing_id of existing_ids) {
+            if (!target_ids.has(existing_id)) {
+                await this.detach(RelatedModel, existing_id);
+            }
+        }
+        // 3. Attach nuevas relaciones que no existen
+        for (const target_id of target_ids) {
+            if (!existing_ids.has(target_id)) {
+                await this.attach(RelatedModel, target_id);
+            }
+        }
+    }
+    /**
+     * @description Run the registered hooks of a given type on an instance, in declaration order.
+     * @description Ejecuta los hooks registrados de un tipo dado sobre una instancia, en orden de declaración.
+     */
+    static async _run_hooks(instance, type, changes) {
+        const schema = instance.constructor[SCHEMA];
+        for (const method_name of schema.hooks[type]) {
+            await instance[method_name]?.(changes);
+        }
+    }
+    static async create(data, options) {
+        const instance = new this(data);
+        const schema = this[SCHEMA];
+        const tx = options?.tx;
+        if (options?.hook)
+            await Table._run_hooks(instance, 'beforeCreate');
+        const payload = instance._toDBPayload();
+        const pk_db_name = schema.columns[schema.primary_key]?.name || schema.primary_key;
+        const condition = {
+            expression: 'attribute_not_exists(#pk)',
+            names: { '#pk': pk_db_name },
+        };
+        if (tx) {
+            tx.addPut(schema.name, payload, condition);
+            tx.onCommit(() => { instance.__isPersisted = true; });
+            if (options?.hook)
+                tx.onCommit(() => Table._run_hooks(instance, 'afterCreate'));
+        }
+        else {
+            try {
+                await requireClient().send(new PutItemCommand({
+                    TableName: schema.name,
+                    Item: marshall(payload, { removeUndefinedValues: true }),
+                    ConditionExpression: condition.expression,
+                    ExpressionAttributeNames: condition.names,
+                }));
+            }
+            catch (e) {
+                if (e.name === 'ConditionalCheckFailedException') {
+                    throw new Error(`Record with ${schema.primary_key} '${instance[schema.primary_key]}' already exists in ${schema.name}`);
+                }
+                throw e;
+            }
+            instance.__isPersisted = true;
+            if (options?.hook)
+                await Table._run_hooks(instance, 'afterCreate');
+        }
+        return instance;
+    }
+    /**
+     * @description Extract PK value from filters if the filter is a simple PK equality. Returns null otherwise.
+     * @description Extrae el valor de PK de los filtros si es una igualdad simple por PK. Retorna null en otro caso.
+     */
+    static _extractPK(filters) {
+        const schema = this[SCHEMA];
+        const keys = Object.keys(filters);
+        if (keys.length !== 1 || keys[0] !== schema.primary_key)
+            return null;
+        const val = filters[schema.primary_key];
+        if (val === null || val === undefined)
+            return null;
+        // Valor plano o { $eq: value }
+        if (typeof val !== 'object' || Array.isArray(val))
+            return val;
+        const op_keys = Object.keys(val);
+        if (op_keys.length === 1 && (OP_MAP[op_keys[0]] || op_keys[0]) === '=')
+            return val[op_keys[0]];
+        return null;
+    }
+    static async update(updates, filters, options) {
+        const schema = this[SCHEMA];
+        const tx = options?.tx;
+        const parsed_updates = {};
+        for (const key in updates) {
+            const column = schema.columns[key];
+            if (!column?.store?.relation) {
+                parsed_updates[key] = updates[key];
+            }
+        }
+        // Optimización: si el filtro es PK exacta, GetItem directo
+        const pk_value = this._extractPK(filters);
+        let records;
+        if (pk_value !== null) {
+            const client = requireClient();
+            const result = await client.send(new GetItemCommand({
+                TableName: schema.name,
+                Key: marshall({ [schema.primary_key]: pk_value }),
+            }));
+            if (!result.Item)
+                return 0;
+            const raw = unmarshall(result.Item);
+            const db_to_prop = {};
+            for (const p in schema.columns)
+                db_to_prop[schema.columns[p].name] = p;
+            const mapped = {};
+            for (const k in raw) {
+                if (raw[k] != null)
+                    mapped[db_to_prop[k] || k] = raw[k];
+            }
+            const instance = new this(mapped);
+            instance.__isPersisted = true;
+            records = [instance];
+        }
+        else {
+            records = await this.where(filters);
+            if (records.length === 0)
+                return 0;
+        }
+        for (const record of records) {
+            for (const [key, value] of Object.entries(parsed_updates)) {
+                record[key] = value;
+            }
+            // Auto-renovar campos @UpdatedAt
+            for (const col_name in schema.columns) {
+                if (schema.columns[col_name].store?.updatedAt && !(col_name in parsed_updates)) {
+                    record[col_name] = undefined;
+                }
+            }
+            if (options?.hook)
+                await Table._run_hooks(record, 'beforeUpdate', parsed_updates);
+            if (tx) {
+                tx.addPut(schema.name, record._toDBPayload());
+                if (options?.hook)
+                    tx.onCommit(() => Table._run_hooks(record, 'afterUpdate', parsed_updates));
+            }
+            else {
+                await requireClient().send(new PutItemCommand({
+                    TableName: schema.name,
+                    Item: marshall(record._toDBPayload(), { removeUndefinedValues: true }),
+                }));
+                if (options?.hook)
+                    await Table._run_hooks(record, 'afterUpdate', parsed_updates);
+            }
+        }
+        return records.length;
+    }
+    static async delete(filters, options) {
+        const schema = this[SCHEMA];
+        const tx = options?.tx;
+        // Optimización: si el filtro es PK exacta, sin softDelete y sin hooks de destroy, DeleteItem directo
+        const pk_value = this._extractPK(filters);
+        const has_soft_delete = Object.values(schema.columns).some(c => c.store.softDelete);
+        const has_destroy_hooks = !!options?.hook && (schema.hooks.beforeDestroy.length > 0 || schema.hooks.afterDestroy.length > 0);
+        if (pk_value !== null && !has_soft_delete && !has_destroy_hooks) {
+            if (tx) {
+                tx.addDelete(schema.name, { [schema.primary_key]: pk_value });
+            }
+            else {
+                await requireClient().send(new DeleteItemCommand({
+                    TableName: schema.name,
+                    Key: marshall({ [schema.primary_key]: pk_value }),
+                }));
+            }
+            return 1;
+        }
+        // Fallback: where() + delete por cada uno
+        const records = await this.where(filters);
+        if (records.length === 0)
+            return 0;
+        for (const record of records) {
+            const id = record[schema.primary_key];
+            if (!id)
+                continue;
+            if (options?.hook)
+                await Table._run_hooks(record, 'beforeDestroy');
+            if (tx) {
+                tx.addDelete(schema.name, { [schema.primary_key]: id });
+                if (options?.hook)
+                    tx.onCommit(() => Table._run_hooks(record, 'afterDestroy'));
+            }
+            else {
+                await requireClient().send(new DeleteItemCommand({
+                    TableName: schema.name,
+                    Key: marshall({ [schema.primary_key]: id }),
+                }));
+                if (options?.hook)
+                    await Table._run_hooks(record, 'afterDestroy');
+            }
+        }
+        return records.length;
+    }
+    /**
+     * @description Atomically increment a numeric field by amount. Uses DynamoDB SET expression.
+     * @description Incrementa atómicamente un campo numérico. Usa expresión SET de DynamoDB.
+     */
+    static async _atomicAdd(table_class, field, amount, filters, tx) {
+        const schema = table_class[SCHEMA];
+        const column = schema.columns[field];
+        if (!column)
+            throw new Error(`Unknown column '${field}' in ${schema.name}`);
+        const db_name = column.name || field;
+        const expr = `SET #f = if_not_exists(#f, :zero) + :amt`;
+        const names = { '#f': db_name };
+        const values = { ':amt': amount, ':zero': 0 };
+        const pk_value = table_class._extractPK(filters);
+        if (pk_value !== null) {
+            const key = { [schema.primary_key]: pk_value };
+            if (tx) {
+                tx.addUpdate(schema.name, key, expr, names, values);
+            }
+            else {
+                await requireClient().send(new UpdateItemCommand({
+                    TableName: schema.name,
+                    Key: marshall(key),
+                    UpdateExpression: expr,
+                    ExpressionAttributeNames: names,
+                    ExpressionAttributeValues: marshall(values),
+                }));
+            }
+            return 1;
+        }
+        const records = await table_class.where(filters);
+        if (records.length === 0)
+            return 0;
+        if (tx) {
+            for (const record of records) {
+                tx.addUpdate(schema.name, { [schema.primary_key]: record[schema.primary_key] }, expr, names, values);
+            }
+        }
+        else {
+            const client = requireClient();
+            await Promise.all(records.map((record) => client.send(new UpdateItemCommand({
+                TableName: schema.name,
+                Key: marshall({ [schema.primary_key]: record[schema.primary_key] }),
+                UpdateExpression: expr,
+                ExpressionAttributeNames: names,
+                ExpressionAttributeValues: marshall(values),
+            }))));
+        }
+        return records.length;
+    }
+    static async increment(field, amount, filters, options) {
+        return Table._atomicAdd(this, field, amount, filters, options?.tx);
+    }
+    static async decrement(field, amount, filters, options) {
+        return Table._atomicAdd(this, field, -amount, filters, options?.tx);
+    }
+    async increment(field, amount = 1) {
+        const schema = this.constructor[SCHEMA];
+        const pk = this[schema.primary_key];
+        if (!pk)
+            throw new Error('Cannot increment without primary key');
+        await Table._atomicAdd(this.constructor, field, amount, { [schema.primary_key]: pk });
+        this[field] = (this[field] || 0) + amount;
+    }
+    async decrement(field, amount = 1) {
+        const schema = this.constructor[SCHEMA];
+        const pk = this[schema.primary_key];
+        if (!pk)
+            throw new Error('Cannot decrement without primary key');
+        await Table._atomicAdd(this.constructor, field, -amount, { [schema.primary_key]: pk });
+        this[field] = (this[field] || 0) - amount;
+    }
+    static async where(field_or_filters, operator_or_value, value, options) {
+        const schema = this[SCHEMA];
+        // -- Normalización: todas las sobrecargas -> { field: { $op: value } } --
+        let raw_filters;
+        let opts;
+        if (typeof field_or_filters === 'string') {
+            if (OPERATORS.has(operator_or_value)) {
+                raw_filters = { [field_or_filters]: { [operator_or_value]: value } };
+                opts = options || {};
+            }
+            else {
+                raw_filters = { [field_or_filters]: { $eq: operator_or_value } };
+                opts = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+            }
+        }
+        else {
+            raw_filters = field_or_filters ?? {};
+            opts = operator_or_value && typeof operator_or_value === 'object' && !Array.isArray(operator_or_value)
+                ? operator_or_value : {};
+        }
+        const filters = {};
+        for (const [field, val] of Object.entries(raw_filters)) {
+            if (val === undefined)
+                continue;
+            if (!schema.columns[field])
+                throw new Error(`Unknown column '${field}' in ${schema.name}`);
+            if (val !== null && typeof val === 'object' && !Array.isArray(val) && Object.keys(val).some(k => OPERATORS.has(k))) {
+                filters[field] = val;
+            }
+            else {
+                filters[field] = { $eq: val };
+            }
+        }
+        if (opts.limit === 0)
+            return [];
+        // Soft delete: excluir registros eliminados salvo que se pida lo contrario
+        if (!opts._includeTrashed) {
+            for (const col_name in schema.columns) {
+                if (schema.columns[col_name].store?.softDelete && !(col_name in filters)) {
+                    filters[col_name] = { $notExists: true };
+                    break;
+                }
+            }
+        }
+        // -- Índice inverso db_name → prop_name --
+        const db_to_prop = {};
+        for (const prop_name in schema.columns) {
+            db_to_prop[schema.columns[prop_name].name] = prop_name;
+        }
+        // -- Detectar mejor índice para QueryCommand --
+        // Prioridad: 1) PK con $eq  2) GSI con $eq  3) Scan
+        let query_field = null;
+        let query_value = null;
+        let query_index = undefined;
+        // Primero buscar PK
+        for (const [field, ops] of Object.entries(filters)) {
+            if (field !== schema.primary_key)
+                continue;
+            const eq_key = Object.keys(ops).find(k => (OP_MAP[k] || k) === '=');
+            if (eq_key && ops[eq_key] !== null) {
+                query_field = field;
+                query_value = ops[eq_key];
+                query_index = undefined;
+                break;
+            }
+        }
+        // Si no hay PK, buscar el mejor GSI
+        if (!query_field) {
+            for (const [field, ops] of Object.entries(filters)) {
+                const eq_key = Object.keys(ops).find(k => (OP_MAP[k] || k) === '=');
+                if (!eq_key || ops[eq_key] === null)
+                    continue;
+                const db_name = schema.columns[field]?.name || field;
+                if (schema.gsis?.has(db_name)) {
+                    query_field = field;
+                    query_value = ops[eq_key];
+                    query_index = `${db_name}_index`;
+                    break;
+                }
+            }
+        }
+        // -- Construir expressions --
+        // El campo elegido para Query va a KeyConditionExpression
+        // TODO el resto (incluyendo soft delete, otros filtros) va a FilterExpression (server-side)
+        const key_expressions = [];
+        const filter_expressions = [];
+        const attr_names = {};
+        const attr_values = {};
+        let idx = 0;
+        for (const [field, ops] of Object.entries(filters)) {
+            const column = schema.columns[field];
+            const db_name = column?.name || field;
+            for (const [op_key, op_val] of Object.entries(ops)) {
+                if (op_val === undefined)
+                    continue;
+                const op = OP_MAP[op_key] || op_key;
+                const nk = `#a${idx}`;
+                const vk = `:v${idx}`;
+                attr_names[nk] = db_name;
+                // KeyConditionExpression: solo el campo de Query con $eq
+                const is_query_key = query_field === field && op === '=' && op_val === query_value;
+                if ((op === '=' && op_val === null) || op === 'attribute_not_exists') {
+                    filter_expressions.push(`attribute_not_exists(${nk})`);
+                }
+                else if ((op === '<>' && op_val === null) || op === 'attribute_exists') {
+                    filter_expressions.push(`attribute_exists(${nk})`);
+                }
+                else if (op === 'in' && Array.isArray(op_val)) {
+                    if (op_val.length === 0)
+                        throw new Error(`Operator 'in' requires a non-empty array.`);
+                    const conds = op_val.map((v, i) => { const k = `${vk}_${i}`; attr_values[k] = v; return `${nk} = ${k}`; });
+                    filter_expressions.push(`(${conds.join(' OR ')})`);
+                }
+                else if (op === 'include') {
+                    attr_values[vk] = op_val;
+                    filter_expressions.push(`contains(${nk}, ${vk})`);
+                }
+                else if (is_query_key) {
+                    attr_values[vk] = op_val;
+                    key_expressions.push(`${nk} ${op} ${vk}`);
+                }
+                else {
+                    attr_values[vk] = op_val;
+                    filter_expressions.push(`${nk} ${op} ${vk}`);
+                }
+                idx++;
+            }
+        }
+        // Proyección
+        if (opts.attributes?.length) {
+            for (const attr of opts.attributes) {
+                const col = schema.columns[String(attr)];
+                const pk = `#p${idx++}`;
+                attr_names[pk] = col?.name || String(attr);
+            }
+        }
+        // -- Ejecución: Query o Scan --
+        let use_query = query_field !== null && key_expressions.length > 0;
+        let items = [];
+        const base_params = { TableName: schema.name };
+        if (Object.keys(attr_names).length > 0)
+            base_params.ExpressionAttributeNames = attr_names;
+        if (Object.keys(attr_values).length > 0)
+            base_params.ExpressionAttributeValues = marshall(attr_values, { removeUndefinedValues: true });
+        if (filter_expressions.length > 0)
+            base_params.FilterExpression = filter_expressions.join(' AND ');
+        if (opts.attributes?.length) {
+            base_params.ProjectionExpression = Object.keys(attr_names).filter(k => k.startsWith('#p')).join(', ');
+        }
+        if (use_query) {
+            base_params.KeyConditionExpression = key_expressions.join(' AND ');
+            if (query_index)
+                base_params.IndexName = query_index;
+        }
+        const client = requireClient();
+        const unmarshal_items = (raw_items) => {
+            for (const item of raw_items) {
+                const raw = unmarshall(item);
+                const mapped = {};
+                for (const k in raw) {
+                    if (raw[k] != null)
+                        mapped[db_to_prop[k] || k] = raw[k];
+                }
+                items.push(mapped);
+            }
+        };
+        // Intentar Query. Si el GSI no existe, fall back a Scan y desregistrar GSI.
+        if (use_query && query_index) {
+            try {
+                let last_key;
+                do {
+                    if (last_key)
+                        base_params.ExclusiveStartKey = last_key;
+                    const result = await client.send(new QueryCommand(base_params));
+                    if (result.Items)
+                        unmarshal_items(result.Items);
+                    last_key = result.LastEvaluatedKey;
+                } while (last_key);
+            }
+            catch (e) {
+                if (e.name === 'ResourceNotFoundException' || e.message?.includes('index')) {
+                    // GSI no existe: remover del cache, mover KeyCondition a Filter, reintentar como Scan
+                    schema.gsis.delete(query_field);
+                    delete base_params.KeyConditionExpression;
+                    delete base_params.IndexName;
+                    delete base_params.ExclusiveStartKey;
+                    const key_as_filter = key_expressions.join(' AND ');
+                    base_params.FilterExpression = base_params.FilterExpression
+                        ? `${key_as_filter} AND ${base_params.FilterExpression}`
+                        : key_as_filter;
+                    use_query = false;
+                    items = [];
+                }
+                else {
+                    throw e;
+                }
+            }
+        }
+        // Query por PK (sin GSI, no puede fallar por índice faltante) o Scan fallback
+        if (!use_query || (use_query && !query_index)) {
+            let last_key;
+            const cmd = use_query ? QueryCommand : ScanCommand;
+            do {
+                if (last_key)
+                    base_params.ExclusiveStartKey = last_key;
+                const result = await client.send(new cmd(base_params));
+                if (result.Items)
+                    unmarshal_items(result.Items);
+                last_key = result.LastEvaluatedKey;
+            } while (last_key);
+        }
+        // Ordenar antes de paginar
+        if (opts.order) {
+            let sort_field = schema.primary_key;
+            let sort_dir = 'ASC';
+            if (typeof opts.order === 'string') {
+                sort_dir = opts.order;
+                for (const cn in schema.columns) {
+                    if (schema.columns[cn].store?.createdAt) {
+                        sort_field = cn;
+                        break;
+                    }
+                }
+            }
+            else {
+                const [f] = Object.keys(opts.order);
+                sort_field = f;
+                sort_dir = opts.order[f];
+            }
+            items.sort((a, b) => {
+                if (a[sort_field] < b[sort_field])
+                    return sort_dir === 'ASC' ? -1 : 1;
+                if (a[sort_field] > b[sort_field])
+                    return sort_dir === 'ASC' ? 1 : -1;
+                return 0;
+            });
+        }
+        // Paginar
+        const skip = opts.skip ?? opts.offset ?? 0;
+        if (skip > 0 || opts.limit !== undefined) {
+            items = items.slice(skip, opts.limit !== undefined ? skip + opts.limit : undefined);
+        }
+        // Instanciar
+        const instances = items.map((item) => {
+            if (opts.attributes) {
+                const instance = Object.create(this.prototype);
+                for (const attr of opts.attributes) {
+                    const column = schema.columns[attr];
+                    if (!column)
+                        continue;
+                    const val = item[attr] ?? null;
+                    Object.defineProperty(instance, attr, {
+                        enumerable: true, configurable: true,
+                        get: () => column.get.reduce((v, fn) => fn(v), val),
+                    });
+                }
+                return instance;
+            }
+            const instance = new this(item);
+            instance.__isPersisted = true;
+            return instance;
+        });
+        if (opts.include) {
+            await processIncludes(instances, opts.include, this);
+        }
+        return instances;
+    }
+    static async first(filters, options) {
+        const results = await this.where(filters, { ...options, limit: 1 });
+        return results[0];
+    }
+    static async last(filters, options) {
+        const results = await this.where(filters ?? {}, { ...options, order: 'DESC', limit: 1 });
+        return results[0];
+    }
+}
+//# sourceMappingURL=table.js.map