@arcaelas/dynamite 1.0.19 → 1.0.24

package/src/{utils → src/utils}/relations.d.ts

@@ -9,17 +9,19 @@
  */
 interface IncludeOptions {
     where?: Record<string, any>;
+    attributes?: string[];
     limit?: number;
     offset?: number;
     order?: 'asc' | 'desc';
     include?: Record<string, IncludeOptions | boolean>;
 }
 /**
- * @description Procesa includes recursivamente para cargar relaciones
+ * @description Procesa includes recursivamente para cargar relaciones con caché
  * @param items Array de instancias a poblar
  * @param include Objeto con relaciones a incluir
  * @param TableClass Clase de la tabla actual
- * @param depth Profundidad actual (máximo 10)
+ * @param depth Profundidad actual (máximo 5 para prevenir deep nesting)
+ * @param queryCache Caché de queries para evitar duplicados (opcional)
  * @returns Items con relaciones pobladas
  * @example
  * ```typescript
@@ -35,5 +37,5 @@ interface IncludeOptions {
  * }, User);
  * ```
  */
-export declare const processIncludes: (items: any[], include: Record<string, IncludeOptions | boolean>, TableClass: any, depth?: number) => Promise<any[]>;
+export declare const processIncludes: (items: any[], include: Record<string, IncludeOptions | boolean>, TableClass: any, depth?: number, queryCache?: Map<string, Map<string, any>>) => Promise<any[]>;
 export {};

package/src/src/utils/relations.js

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * @file relations.ts
+ * @description Sistema de carga de relaciones con batch loading
+ * @autor Miguel Alejandro
+ * @fecha 2025-01-28
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processIncludes = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
+const client_1 = require("../core/client");
+const decorator_1 = require("../core/decorator");
+/**
+ * @description Batch load para HasMany/HasOne
+ * Obtiene items relacionados donde foreignKey IN parent_ids
+ */
+const batchLoadHasMany = async (items, relation, options = {}) => {
+    const parent_ids = items.map(i => i[relation.localKey]).filter(Boolean);
+    if (!parent_ids.length)
+        return new Map();
+    // Obtener clase del modelo relacionado
+    const RelatedModel = relation.model();
+    // Construir filtros combinados
+    const filters = {
+        [relation.foreignKey]: { $in: parent_ids },
+        ...options.where
+    };
+    // Query con todas las opciones aplicadas
+    const related = await RelatedModel.where(filters, {
+        attributes: options.attributes,
+        order: options.order?.toUpperCase(),
+        limit: undefined, // Se aplica después de agrupar
+        offset: undefined,
+    });
+    // Agrupar por foreignKey
+    const grouped = new Map();
+    for (const item of related) {
+        const key = String(item[relation.foreignKey]);
+        if (!grouped.has(key))
+            grouped.set(key, []);
+        grouped.get(key).push(item);
+    }
+    // Aplicar limit por grupo
+    if (options.limit) {
+        for (const [key, groupItems] of grouped) {
+            grouped.set(key, groupItems.slice(options.offset ?? 0, (options.offset ?? 0) + options.limit));
+        }
+    }
+    return grouped;
+};
+/**
+ * @description Batch load para BelongsTo
+ * Obtiene items donde id IN local_keys
+ */
+const batchLoadBelongsTo = async (items, relation, options = {}) => {
+    const local_keys = items.map(i => i[relation.localKey]).filter(Boolean);
+    if (!local_keys.length)
+        return new Map();
+    const RelatedModel = relation.model();
+    // Query con opciones aplicadas
+    const related = await RelatedModel.where({ [relation.foreignKey]: { $in: local_keys } }, { attributes: options.attributes });
+    const result = new Map();
+    for (const item of related) {
+        result.set(String(item[relation.foreignKey]), item);
+    }
+    return result;
+};
+/**
+ * @description Batch load para ManyToMany
+ * Obtiene items relacionados usando tabla pivot
+ */
+const batchLoadManyToMany = async (items, relation, options = {}) => {
+    const parent_ids = items.map(i => i[relation.localKey]).filter(Boolean);
+    if (!parent_ids.length)
+        return new Map();
+    const client = (0, client_1.requireClient)();
+    // [1] Query pivot table usando OR chain (DynamoDB no soporta IN nativo)
+    const or_conditions = parent_ids.map((_, i) => `#fk = :id${i}`).join(' OR ');
+    const pivot_result = await client.send(new client_dynamodb_1.ScanCommand({
+        TableName: relation.pivotTable,
+        FilterExpression: parent_ids.length > 0 ? `(${or_conditions})` : undefined,
+        ExpressionAttributeNames: { '#fk': relation.foreignKey },
+        ExpressionAttributeValues: (0, util_dynamodb_1.marshall)(parent_ids.reduce((acc, id, i) => ({ ...acc, [`:id${i}`]: id }), {}))
+    }));
+    const pivot_rows = (pivot_result.Items ?? []).map(item => (0, util_dynamodb_1.unmarshall)(item));
+    if (pivot_rows.length === 0)
+        return new Map();
+    // [2] Extract unique related IDs
+    const related_ids = [...new Set(pivot_rows.map(row => row[relation.relatedKey]))];
+    // [3] Batch load related models con opciones aplicadas
+    const RelatedModel = relation.model();
+    // Construir filtros combinados
+    const filters = {
+        [relation.relatedPK]: { $in: related_ids },
+        ...options.where
+    };
+    const related_items = await RelatedModel.where(filters, {
+        attributes: options.attributes,
+        order: options.order?.toUpperCase(),
+    });
+    // [5] Map related items by ID
+    const related_map = new Map(related_items.map((item) => [String(item[relation.relatedPK]), item]));
+    // [6] Group by parent ID using pivot as bridge
+    const grouped = new Map();
+    for (const pivot of pivot_rows) {
+        const parent_id = String(pivot[relation.foreignKey]);
+        const related_id = String(pivot[relation.relatedKey]);
+        const related_item = related_map.get(related_id);
+        if (related_item) {
+            if (!grouped.has(parent_id))
+                grouped.set(parent_id, []);
+            grouped.get(parent_id).push(related_item);
+        }
+    }
+    // [7] Apply limit per group
+    if (options.limit) {
+        for (const [key, items_arr] of grouped) {
+            grouped.set(key, items_arr.slice(options.offset ?? 0, (options.offset ?? 0) + options.limit));
+        }
+    }
+    return grouped;
+};
+/**
+ * @description Procesa includes recursivamente para cargar relaciones con caché
+ * @param items Array de instancias a poblar
+ * @param include Objeto con relaciones a incluir
+ * @param TableClass Clase de la tabla actual
+ * @param depth Profundidad actual (máximo 5 para prevenir deep nesting)
+ * @param queryCache Caché de queries para evitar duplicados (opcional)
+ * @returns Items con relaciones pobladas
+ * @example
+ * ```typescript
+ * // Uso interno en Table.where()
+ * await processIncludes(users, {
+ *   posts: {
+ *     where: { published: true },
+ *     limit: 5,
+ *     include: {
+ *       comments: true
+ *     }
+ *   }
+ * }, User);
+ * ```
+ */
+const processIncludes = async (items, include, TableClass, depth = 0, queryCache = new Map()) => {
+    // Límite reducido de 10 a 5 para mejor performance
+    if (!include || depth > 5 || !items.length)
+        return items;
+    const schema = TableClass[decorator_1.SCHEMA];
+    if (!schema)
+        return items;
+    const promises = Object.entries(include)
+        .filter(([key]) => Object.prototype.hasOwnProperty.call(schema.columns, key))
+        .map(async ([relation_key, options]) => {
+        const column = schema.columns[relation_key];
+        if (!column?.store?.relation)
+            return;
+        const relation = column.store.relation;
+        const opts = typeof options === 'boolean' ? {} : options;
+        // Generar clave de caché basada en tipo de relación y IDs de padres
+        const parent_ids = items.map(i => i[relation.localKey]).filter(Boolean);
+        const cache_key = `${relation.type}:${relation.model().name}:${JSON.stringify(parent_ids.sort())}:${JSON.stringify(opts.where || {})}`;
+        // Batch load según tipo con caché
+        let data;
+        // Verificar caché primero
+        if (queryCache.has(cache_key)) {
+            data = queryCache.get(cache_key);
+        }
+        else {
+            if (relation.type === 'HasMany') {
+                data = await batchLoadHasMany(items, relation, opts);
+            }
+            else if (relation.type === 'HasOne') {
+                const hasMany = await batchLoadHasMany(items, relation, { ...opts, limit: 1 });
+                data = new Map();
+                for (const [k, v] of hasMany) {
+                    data.set(k, v[0] ?? null);
+                }
+            }
+            else if (relation.type === 'ManyToMany') {
+                data = await batchLoadManyToMany(items, relation, opts);
+            }
+            else {
+                // BelongsTo
+                data = await batchLoadBelongsTo(items, relation, opts);
+            }
+            // Guardar en caché
+            queryCache.set(cache_key, data);
+        }
+        // Asignar datos relacionados a cada item
+        for (const item of items) {
+            const key = String(item[relation.localKey]);
+            const value = (relation.type === 'HasMany' || relation.type === 'ManyToMany')
+                ? data.get(key) ?? []
+                : data.get(key) ?? null;
+            Object.defineProperty(item, relation_key, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+        }
+        // Recursión para includes anidados con caché propagado
+        if (opts.include && data.size) {
+            const all_related = Array.from(data.values()).flat().filter(Boolean);
+            if (all_related.length) {
+                await (0, exports.processIncludes)(all_related, opts.include, relation.model(), depth + 1, queryCache);
+            }
+        }
+    });
+    await Promise.all(promises);
+    return items;
+};
+exports.processIncludes = processIncludes;
+//# sourceMappingURL=relations.js.map

package/src/@types/index.d.ts

@@ -1,137 +0,0 @@
-/*
-@file index.ts
-@descripcion Tipos públicos de Dynamite ORM
-@autor Miguel Alejandro
-@fecha 2025-08-07
-*/
-
-// Brands para tipos especiales
-export declare const HasManyBrand: unique symbol;
-export declare const BelongsToBrand: unique symbol;
-export declare const HasOneBrand: unique symbol;
-export declare const NonAttributeBrand: unique symbol;
-export declare const CreationOptionalBrand: unique symbol;
-
-// Relaciones y atributos especiales
-export type HasMany<T> = T[] & { [HasManyBrand]?: true };
-export type BelongsTo<T> = (T | null) & { [BelongsToBrand]?: true };
-export type HasOne<T> = (T | null) & { [HasOneBrand]?: true };
-export type NonAttribute<T> = T & { [NonAttributeBrand]?: true };
-export type CreationOptional<T> = T & { [CreationOptionalBrand]?: true };
-
-// Atributos inferidos (excluye relaciones, non-attributes y funciones)
-export type InferAttributes<T> = {
-  [K in keyof T as T[K] extends (...args: any[]) => any
-    ? never
-    : T[K] extends { [HasManyBrand]?: true }
-    ? never
-    : T[K] extends { [BelongsToBrand]?: true }
-    ? never
-    : T[K] extends { [HasOneBrand]?: true }
-    ? never
-    : T[K] extends { [NonAttributeBrand]?: true }
-    ? never
-    : K]: T[K];
-};
-
-export type FilterableAttributes<T> = {
-  [K in keyof InferAttributes<T>]: InferAttributes<T>[K];
-};
-
-export type WhereOptions<T> = {
-  where?: Partial<FilterableAttributes<T>>;
-  skip?: number;
-  limit?: number;
-  order?: "ASC" | "DESC";
-  attributes?: (keyof FilterableAttributes<T>)[];
-  include?: {
-    [K in keyof T]?: T[K] extends HasMany<any> | BelongsTo<any> | HasOne<any>
-      ? IncludeRelationOptions | true
-      : never;
-  };
-};
-
-/** Filtros de query sin cláusula where */
-export type QueryFilters<T> = Omit<WhereOptions<T>, "where">;
-
-/** @deprecated Usa QueryFilters */
-export type WhereOptionsWithoutWhere<T> = QueryFilters<T>;
-
-export type QueryOperator =
-  | "="
-  | "!="
-  | "<"
-  | "<="
-  | ">"
-  | ">="
-  | "in"
-  | "not-in"
-  | "contains"
-  | "begins-with";
-
-/** Entrada de validador con soporte lazy */
-export interface ValidatorEntry {
-  fn: (value: any) => boolean | string;
-  lazy?: boolean;
-}
-
-// Tipos para core/wrapper
-export interface Column {
-  name: string;
-  index?: true;
-  indexSort?: true;
-  primaryKey?: boolean;
-  nullable?: boolean;
-  unique?: true;
-  createdAt?: boolean;
-  updatedAt?: boolean;
-  softDelete?: boolean;
-  lazy_validators?: ((value: any) => boolean | string)[];
-  relation?: RelationMetadata;
-}
-
-export interface RelationMetadata {
-  type: "hasMany" | "belongsTo" | "hasOne";
-  targetModel: () => any;
-  foreignKey: string;
-  localKey?: string;
-}
-
-export interface WrapperEntry {
-  name: string;
-  columns: Map<string | symbol, Column>;
-  relations: Map<string | symbol, RelationMetadata>;
-}
-
-/** Alias para WrapperEntry (usado internamente con SCHEMA symbol) */
-export type SchemaEntry = WrapperEntry;
-
-// Tipos internos del where de Table
-export type IncludeRelationOptions = {
-  where?: Record<string, any>;
-  attributes?: string[];
-  order?: "ASC" | "DESC";
-  skip?: number;
-  limit?: number;
-  include?: Record<string, IncludeRelationOptions | true>;
-};
-
-/** Opciones de query para métodos where(), first(), last(), etc. */
-export type QueryOptions<T> = {
-  order?: "ASC" | "DESC";
-  skip?: number;
-  limit?: number;
-  attributes?: (keyof InferAttributes<T>)[];
-  include?: {
-    [K in keyof T]?: T[K] extends HasMany<any> | BelongsTo<any> | HasOne<any>
-      ? IncludeRelationOptions | true
-      : never;
-  };
-};
-
-/** @deprecated Usa QueryOptions */
-export type WhereQueryOptions<T> = QueryOptions<T>;
-
-// Tipos utilitarios para decoradores
-export type Mutate = (value: any) => any;
-export type Validate = (value: any) => boolean | string;

package/src/core/method.d.ts

@@ -1,73 +0,0 @@
-/**
- * @file method.ts
- * @descripcion Sistema de métodos extensibles para Table
- * @autor Miguel Alejandro
- */
-/** Handler para métodos estáticos: (TableClass, args) => result */
-export type StaticMethodHandler<R = any> = (table: any, args: any[]) => R | Promise<R>;
-/** Handler para métodos de instancia: (TableClass, instance, args) => result */
-export type InstanceMethodHandler<R = any> = (table: any, instance: any, args: any[]) => R | Promise<R>;
-/**
- * @description Configura la clase Table para el sistema de métodos
- * @param TableClass Clase Table
- */
-export declare function setTableClass(TableClass: any): void;
-/**
- * @description Registra un método estático en Table y lo define en la clase
- * @param name Nombre del método
- * @param handler Función que implementa el método
- * @example
- * ```typescript
- * registerStaticMethod('customFind', function(t, args) {
- *   const meta = mustMeta(t);
- *   return instances;
- * });
- * // Uso: User.customFind(...)
- * ```
- */
-export declare function registerStaticMethod<R = any>(name: string, handler: StaticMethodHandler<R>): void;
-/**
- * @description Registra un método de instancia en Table y lo define en el prototype
- * @param name Nombre del método
- * @param handler Función que implementa el método
- * @example
- * ```typescript
- * registerInstanceMethod('duplicate', function(t, m, args) {
- *   return t.create({ ...m.toJSON(), id: undefined });
- * });
- * // Uso: user.duplicate()
- * ```
- */
-export declare function registerInstanceMethod<R = any>(name: string, handler: InstanceMethodHandler<R>): void;
-/**
- * @description Obtiene un método estático registrado
- */
-export declare function getStaticMethod(name: string): StaticMethodHandler | undefined;
-/**
- * @description Obtiene un método de instancia registrado
- */
-export declare function getInstanceMethod(name: string): InstanceMethodHandler | undefined;
-/**
- * @description Ejecuta un método estático registrado
- */
-export declare function callStaticMethod<R = any>(name: string, table: any, args: any[]): R | Promise<R>;
-/**
- * @description Ejecuta un método de instancia registrado
- */
-export declare function callInstanceMethod<R = any>(name: string, table: any, instance: any, args: any[]): R | Promise<R>;
-/**
- * @description Verifica si un método estático está registrado
- */
-export declare function hasStaticMethod(name: string): boolean;
-/**
- * @description Verifica si un método de instancia está registrado
- */
-export declare function hasInstanceMethod(name: string): boolean;
-/**
- * @description Lista todos los métodos estáticos registrados
- */
-export declare function listStaticMethods(): string[];
-/**
- * @description Lista todos los métodos de instancia registrados
- */
-export declare function listInstanceMethods(): string[];

package/src/core/method.js

@@ -1,140 +0,0 @@
-"use strict";
-/**
- * @file method.ts
- * @descripcion Sistema de métodos extensibles para Table
- * @autor Miguel Alejandro
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setTableClass = setTableClass;
-exports.registerStaticMethod = registerStaticMethod;
-exports.registerInstanceMethod = registerInstanceMethod;
-exports.getStaticMethod = getStaticMethod;
-exports.getInstanceMethod = getInstanceMethod;
-exports.callStaticMethod = callStaticMethod;
-exports.callInstanceMethod = callInstanceMethod;
-exports.hasStaticMethod = hasStaticMethod;
-exports.hasInstanceMethod = hasInstanceMethod;
-exports.listStaticMethods = listStaticMethods;
-exports.listInstanceMethods = listInstanceMethods;
-/** Registro de métodos estáticos */
-const static_methods = new Map();
-/** Registro de métodos de instancia */
-const instance_methods = new Map();
-/** Referencia a la clase Table para definir propiedades */
-let table_class = null;
-/**
- * @description Configura la clase Table para el sistema de métodos
- * @param TableClass Clase Table
- */
-function setTableClass(TableClass) {
-    table_class = TableClass;
-}
-/**
- * @description Registra un método estático en Table y lo define en la clase
- * @param name Nombre del método
- * @param handler Función que implementa el método
- * @example
- * ```typescript
- * registerStaticMethod('customFind', function(t, args) {
- *   const meta = mustMeta(t);
- *   return instances;
- * });
- * // Uso: User.customFind(...)
- * ```
- */
-function registerStaticMethod(name, handler) {
-    static_methods.set(name, handler);
-    // Definir método en la clase Table si está configurada
-    if (table_class && !Object.prototype.hasOwnProperty.call(table_class, name)) {
-        Object.defineProperty(table_class, name, {
-            value: function (...args) {
-                return callStaticMethod(name, this, args);
-            },
-            writable: true,
-            configurable: true,
-        });
-    }
-}
-/**
- * @description Registra un método de instancia en Table y lo define en el prototype
- * @param name Nombre del método
- * @param handler Función que implementa el método
- * @example
- * ```typescript
- * registerInstanceMethod('duplicate', function(t, m, args) {
- *   return t.create({ ...m.toJSON(), id: undefined });
- * });
- * // Uso: user.duplicate()
- * ```
- */
-function registerInstanceMethod(name, handler) {
-    instance_methods.set(name, handler);
-    // Definir método en el prototype de Table si está configurado
-    if (table_class &&
-        !Object.prototype.hasOwnProperty.call(table_class.prototype, name)) {
-        Object.defineProperty(table_class.prototype, name, {
-            value: function (...args) {
-                return callInstanceMethod(name, this.constructor, this, args);
-            },
-            writable: true,
-            configurable: true,
-        });
-    }
-}
-/**
- * @description Obtiene un método estático registrado
- */
-function getStaticMethod(name) {
-    return static_methods.get(name);
-}
-/**
- * @description Obtiene un método de instancia registrado
- */
-function getInstanceMethod(name) {
-    return instance_methods.get(name);
-}
-/**
- * @description Ejecuta un método estático registrado
- */
-function callStaticMethod(name, table, args) {
-    const handler = static_methods.get(name);
-    if (!handler) {
-        throw new Error(`Método estático '${name}' no registrado`);
-    }
-    return handler(table, args);
-}
-/**
- * @description Ejecuta un método de instancia registrado
- */
-function callInstanceMethod(name, table, instance, args) {
-    const handler = instance_methods.get(name);
-    if (!handler) {
-        throw new Error(`Método de instancia '${name}' no registrado`);
-    }
-    return handler(table, instance, args);
-}
-/**
- * @description Verifica si un método estático está registrado
- */
-function hasStaticMethod(name) {
-    return static_methods.has(name);
-}
-/**
- * @description Verifica si un método de instancia está registrado
- */
-function hasInstanceMethod(name) {
-    return instance_methods.has(name);
-}
-/**
- * @description Lista todos los métodos estáticos registrados
- */
-function listStaticMethods() {
-    return Array.from(static_methods.keys());
-}
-/**
- * @description Lista todos los métodos de instancia registrados
- */
-function listInstanceMethods() {
-    return Array.from(instance_methods.keys());
-}
-//# sourceMappingURL=method.js.map

package/src/core/table.d.ts

@@ -1,56 +0,0 @@
-/**
- * @file table.ts
- * @description Tabla autocontenida con arquitectura minimalista y Symbol storage
- * @autor Miguel Alejandro
- * @fecha 2025-01-28
- */
-import { TransactionContext } from "./client";
-import { VALUES } from "./decorator";
-interface QueryOptions<T> {
-    order?: 'ASC' | 'DESC';
-    skip?: number;
-    limit?: number;
-    attributes?: (keyof T)[];
-    include?: IncludeRelationOptions;
-    _includeTrashed?: boolean;
-}
-interface IncludeRelationOptions {
-    [relationName: string]: boolean | {
-        where?: any;
-        limit?: number;
-    };
-}
-type QueryOperator = "=" | "!=" | "<" | "<=" | ">" | ">=" | "in" | "not-in" | "contains" | "begins-with";
-export default class Table<T = any> {
-    private readonly [VALUES];
-    constructor(props?: Partial<T>);
-    /**
-     * @description Serializa la instancia a JSON incluyendo relaciones recursivamente
-     * @returns Objeto JSON con todas las propiedades y relaciones
-     */
-    toJSON(): Record<string, unknown>;
-    /**
-     * @description Serializa la instancia a string JSON
-     * @returns String JSON con todas las propiedades y relaciones
-     */
-    toString(): string;
-    /**
-     * @description Genera payload para operaciones de DB (excluye relaciones)
-     */
-    private _toDBPayload;
-    save(): Promise<this>;
-    destroy(): Promise<null>;
-    forceDestroy(): Promise<null>;
-    static create<T extends Table>(this: new (data: any) => T, data: any, tx?: TransactionContext): Promise<T>;
-    static update<T extends Table>(this: new (data: any) => T, updates: any, filters: any, tx?: TransactionContext): Promise<number>;
-    static delete<T extends Table>(this: new (data: any) => T, filters: any, tx?: TransactionContext): Promise<number>;
-    static where<T extends Table>(this: new (props?: any) => T, field_or_filters: any, operator_or_value?: any, value?: any, options?: QueryOptions<T>): Promise<T[]>;
-    static first<T extends Table>(this: new (props?: any) => T, field_or_filters: any, operator_or_value?: any, value_or_options?: any): Promise<T | undefined>;
-    static last<T extends Table>(this: new (props?: any) => T, field_or_filters?: any, operator_or_value?: any): Promise<T | undefined>;
-    static withTrashed<T extends Table>(this: new (props?: any) => T, filters?: any, options?: QueryOptions<T>): Promise<T[]>;
-    static onlyTrashed<T extends Table>(this: new (props?: any) => T, filters?: any, options?: QueryOptions<T>): Promise<T[]>;
-    private insertIntoDynamoDB;
-    private updateInDynamoDB;
-    private deleteFromDynamoDB;
-}
-export type { QueryOptions, IncludeRelationOptions, QueryOperator };