@arcaelas/dynamite 1.0.17 → 1.0.19

package/src/core/method.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @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

@@ -0,0 +1,140 @@
+"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,98 +1,56 @@
 /**
  * @file table.ts
- * @descripcion Clase Table rediseñada con API completa y tipado estricto
+ * @description Tabla autocontenida con arquitectura minimalista y Symbol storage
  * @autor Miguel Alejandro
- * @fecha 2025-07-30
+ * @fecha 2025-01-28
  */
-import type { InferAttributes, QueryOperator, WhereQueryOptions, WrapperEntry } from "../@types/index";
-import { STORE } from "./wrapper";
-export default class Table<T = any> {
-    protected [STORE]: {
-        [K in keyof T]?: T[K];
+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;
     };
-    constructor(data: InferAttributes<T>);
-    /** Serializar instancia a JSON plano */
-    toJSON(): Record<string, any>;
-    /** Guardar instancia (crear o actualizar) */
-    save(): Promise<this>;
-    /** Actualizar instancia */
-    update(patch: Partial<InferAttributes<T>>): Promise<this>;
-    /** Eliminar instancia */
-    destroy(): Promise<null>;
-    /**
-     * Crear un nuevo registro en la base de datos
-     */
-    static create<M extends Table>(this: {
-        new (data: InferAttributes<M>): M;
-        prototype: M;
-    }, data: InferAttributes<M>): Promise<M>;
-    /**
-     * Actualizar registros en la base de datos
-     * @param updates - Campos a actualizar. Los campos con valor `undefined` se ignoran.
-     * @param filters - Filtros para seleccionar los registros a actualizar
-     * @returns Número de registros actualizados
-     */
-    static update<M extends Table>(this: {
-        new (data: InferAttributes<M>): M;
-        prototype: M;
-    }, updates: Partial<InferAttributes<M>>, filters: Partial<InferAttributes<M>>): Promise<number>;
+}
+type QueryOperator = "=" | "!=" | "<" | "<=" | ">" | ">=" | "in" | "not-in" | "contains" | "begins-with";
+export default class Table<T = any> {
+    private readonly [VALUES];
+    constructor(props?: Partial<T>);
     /**
-     * Eliminar registros de la base de datos
+     * @description Serializa la instancia a JSON incluyendo relaciones recursivamente
+     * @returns Objeto JSON con todas las propiedades y relaciones
      */
-    static delete<M extends Table>(this: {
-        new (data: InferAttributes<M>): M;
-        prototype: M;
-    }, filters: Partial<InferAttributes<M>>): Promise<number>;
-    /** Filtrar registros por campo igual a valor */
-    static where<M extends Table, K extends keyof InferAttributes<M>>(this: {
-        new (data: InferAttributes<M>): M;
-        prototype: M;
-    }, field: K, value: InferAttributes<M>[K] | InferAttributes<M>[K][]): Promise<M[]>;
-    /** Filtrar registros por campo con operador específico */
-    static where<M extends Table, K extends keyof InferAttributes<M>>(this: {
-        new (data: InferAttributes<M>): M;
-        prototype: M;
-    }, field: K, operator: QueryOperator, value: InferAttributes<M>[K] | InferAttributes<M>[K][]): Promise<M[]>;
-    /** Filtrar registros por múltiples campos (AND) */
-    static where<M extends Table>(this: {
-        new (data: InferAttributes<M>): M;
-        prototype: M;
-    }, filters: Partial<InferAttributes<M>>): Promise<M[]>;
-    /** Filtrar registros con opciones avanzadas */
-    static where<M extends Table>(this: {
-        new (data: InferAttributes<M>): M;
-        prototype: M;
-    }, filters: Partial<InferAttributes<M>>, options: WhereQueryOptions<M>): Promise<M[]>;
+    toJSON(): Record<string, unknown>;
     /**
-     * Obtener el primer registro que coincida con los filtros
+     * @description Serializa la instancia a string JSON
+     * @returns String JSON con todas las propiedades y relaciones
      */
-    static first<M extends Table, K extends keyof InferAttributes<M>>(this: {
-        new (data: InferAttributes<M>): M;
-        prototype: M;
-    }, field: K, value: InferAttributes<M>[K]): Promise<M | undefined>;
-    static first<M extends Table, K extends keyof InferAttributes<M>>(this: {
-        new (data: InferAttributes<M>): M;
-        prototype: M;
-    }, field: K, operator: QueryOperator, value: InferAttributes<M>[K] | InferAttributes<M>[K][]): Promise<M | undefined>;
-    static first<M extends Table>(this: {
-        new (data: InferAttributes<M>): M;
-        prototype: M;
-    }, filters: Partial<InferAttributes<M>>): Promise<M | undefined>;
+    toString(): string;
     /**
-     * Obtener el último registro que coincida con los filtros
+     * @description Genera payload para operaciones de DB (excluye relaciones)
      */
-    static last<M extends Table, K extends keyof InferAttributes<M>>(this: {
-        new (data: InferAttributes<M>): M;
-        prototype: M;
-    }, field: K, value: InferAttributes<M>[K]): Promise<M | undefined>;
-    static last<M extends Table, K extends keyof InferAttributes<M>>(this: {
-        new (data: InferAttributes<M>): M;
-        prototype: M;
-    }, field: K, operator: QueryOperator, value: InferAttributes<M>[K] | InferAttributes<M>[K][]): Promise<M | undefined>;
-    static last<M extends Table>(this: {
-        new (data: InferAttributes<M>): M;
-        prototype: M;
-    }, filters: Partial<InferAttributes<M>>): Promise<M | undefined>;
+    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 { STORE };
-export type { WrapperEntry };
+export type { QueryOptions, IncludeRelationOptions, QueryOperator };