@arcaelas/dynamite 1.0.15 → 1.0.18

package/src/core/table.js

@@ -0,0 +1,659 @@
+"use strict";
+/**
+ * @file table.ts
+ * @description Tabla autocontenida con arquitectura minimalista y Symbol storage
+ * @autor Miguel Alejandro
+ * @fecha 2025-01-28
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
+const client_1 = require("./client");
+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 SIMPLIFICADAS
+// =============================================================================
+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;
+}
+/**
+ * @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 = {};
+    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 {
+            // 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,
+        values,
+    };
+}
+// =============================================================================
+// CLASE TABLE AUTOCONTENIDA
+// =============================================================================
+class Table {
+    constructor(props = {}) {
+        (0, client_1.requireClient)();
+        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;
+                    },
+                });
+            }
+        }
+    }
+    // **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 schema = this.constructor[decorator_1.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) {
+                // 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;
+                }
+            }
+            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;
+            const value = this[column_name];
+            if (value !== null && value !== undefined) {
+                result[column_name] = value;
+            }
+        }
+        return result;
+    }
+    async save() {
+        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");
+                    }
+                }
+            }
+        }
+        // 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;
+            }
+        }
+        // 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 this.updateInDynamoDB(db_data);
+        }
+        return this;
+    }
+    async destroy() {
+        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');
+        }
+        // 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;
+    }
+    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();
+        // 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._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;
+    }
+    static async update(updates, filters, tx) {
+        const records = await this.where(filters);
+        if (records.length === 0) {
+            return 0;
+        }
+        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
+            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;
+                }
+            }
+            const updated_data = record._toDBPayload();
+            if (tx) {
+                tx.addPut(schema.name, updated_data);
+            }
+            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;
+    }
+    static async delete(filters, tx) {
+        const records = await this.where(filters);
+        if (records.length === 0) {
+            return 0;
+        }
+        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) {
+                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++;
+            }
+        }
+        return deletedCount;
+    }
+    static async where(field_or_filters, operator_or_value, value, options) {
+        const client = (0, client_1.requireClient)();
+        const schema = this[decorator_1.SCHEMA];
+        // Parsear argumentos dinámicamente (como el original)
+        let filters;
+        let queryOptions;
+        let operator = "=";
+        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 (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 (operator_or_value !== undefined && typeof operator_or_value === 'object') {
+            // where(filters, options?)
+            filters = field_or_filters;
+            queryOptions = operator_or_value;
+        }
+        else {
+            // where(filters?)
+            filters = field_or_filters;
+            queryOptions = {};
+        }
+        // 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 (queryOptions.skip && queryOptions.skip < 0) {
+            throw new Error("skip debe ser mayor o igual a 0");
+        }
+        if (queryOptions.order && !["ASC", "DESC"].includes(queryOptions.order)) {
+            throw new Error('order debe ser "ASC" o "DESC"');
+        }
+        // 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: schema.name,
+            ExpressionAttributeNames: names || {},
+        };
+        if (expression) {
+            scanParams.FilterExpression = expression;
+            scanParams.ExpressionAttributeValues = (0, util_dynamodb_1.marshall)(values || {}, { removeUndefinedValues: true });
+        }
+        // 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] = 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 = 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) => {
+                    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)
+                        break;
+                    allItems.push(item);
+                    scannedCount++;
+                }
+            }
+            lastEvaluatedKey = result.LastEvaluatedKey;
+        } while (lastEvaluatedKey && allItems.length < targetLimit);
+        // Aplicar ordenamiento
+        if (queryOptions.order) {
+            allItems.sort((a, b) => {
+                const sortField = Object.keys(filters)[0] || schema.primary_key;
+                const aVal = a[sortField];
+                const bVal = b[sortField];
+                if (aVal < bVal)
+                    return queryOptions.order === "ASC" ? -1 : 1;
+                if (aVal > bVal)
+                    return queryOptions.order === "ASC" ? 1 : -1;
+                return 0;
+            });
+        }
+        // Convertir a instancias (schema ya definido arriba)
+        const instances = allItems.map((item) => {
+            if (queryOptions.attributes) {
+                // Proyección parcial: crear instancia con solo los atributos solicitados
+                const instance = Object.create(this.prototype);
+                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 {
+                return new this(item);
+            }
+        });
+        // Procesar includes para cargar relaciones
+        if (queryOptions.include) {
+            await (0, relations_1.processIncludes)(instances, queryOptions.include, this);
+        }
+        return instances;
+    }
+    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(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;
+            }
+        }
+        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;
+//# sourceMappingURL=table.js.map

package/src/decorators/indexes.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @file indexes.ts
+ * @description Decoradores de índices con Symbol storage
+ * @autor Miguel Alejandro
+ * @fecha 2025-01-28
+ */
+/**
+ * @description Decorador para marcar propiedad como Partition Key
+ * @example
+ * ```typescript
+ * class User extends Table<User> {
+ *   @Index() id: string;
+ * }
+ * ```
+ */
+export declare const Index: (...params: any[]) => (target: any, propertyKey: string | symbol) => void;
+/**
+ * @description Decorador para marcar propiedad como Sort Key
+ * @example
+ * ```typescript
+ * class Post extends Table<Post> {
+ *   @Index() user_id: string;
+ *   @IndexSort() created_at: string;
+ * }
+ * ```
+ */
+export declare const IndexSort: (...params: any[]) => (target: any, propertyKey: string | symbol) => void;
+/**
+ * @description Decorador para marcar una propiedad como clave primaria
+ * @example
+ * ```typescript
+ * class User extends Table<User> {
+ *   @PrimaryKey() id: string;
+ *   name: string;
+ * }
+ * ```
+ */
+export declare function PrimaryKey(): PropertyDecorator;