@arcaelas/dynamite 1.0.14 → 1.0.17

package/package.json

@@ -49,5 +49,5 @@
     "prepublishOnly": "yarn build",
     "postpublish": "find src -type f \\( -name '*.js' -o -name '*.d.ts' -o -name '*.map' \\) -delete"
   },
-  "version": "1.0.14"
+  "version": "1.0.17"
 }

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

@@ -0,0 +1,96 @@
+export declare const HasManyBrand: unique symbol;
+export declare const BelongsToBrand: unique symbol;
+export declare const NonAttributeBrand: unique symbol;
+export declare const CreationOptionalBrand: unique symbol;
+export type HasMany<T> = T[] & {
+    [HasManyBrand]?: true;
+};
+export type BelongsTo<T> = (T | null) & {
+    [BelongsToBrand]?: true;
+};
+export type NonAttribute<T> = T & {
+    [NonAttributeBrand]?: true;
+};
+export type CreationOptional<T> = T & {
+    [CreationOptionalBrand]?: true;
+};
+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 {
+        [NonAttributeBrand]?: true;
+    } ? never : K]: T[K];
+};
+export type FilterableAttributes<T> = {
+    [K in keyof InferAttributes<T>]: InferAttributes<T>[K];
+};
+type SelectResult<T, A extends keyof T> = Pick<T, A>;
+type ResolveIncludeType<T, K extends keyof T> = T[K] extends HasMany<infer U> ? U[] : T[K] extends BelongsTo<infer U> ? U | null : never;
+export type IncludeOptions = {
+    where?: Record<string, any>;
+    attributes?: string[];
+    limit?: number;
+    skip?: number;
+    order?: "ASC" | "DESC";
+};
+export type QueryResult<T, A extends keyof T = keyof T, I extends Record<string, any> = {}> = SelectResult<T & {
+    [K in keyof I]: K extends keyof T ? ResolveIncludeType<T, K> : never;
+}, A>;
+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> ? IncludeOptions | {} : never;
+    };
+};
+export type WhereOptionsWithoutWhere<T> = Omit<WhereOptions<T>, "where">;
+export type QueryOperator = "=" | "!=" | "<" | "<=" | ">" | ">=" | "in" | "not-in" | "contains" | "begins-with";
+export interface Column {
+    name: string;
+    default?: any | (() => any);
+    mutate?: ((value: any) => any)[];
+    validate?: ((value: any) => boolean | string)[];
+    index?: true;
+    indexSort?: true;
+    primaryKey?: boolean;
+    nullable?: boolean;
+    unique?: true;
+    createdAt?: boolean;
+    updatedAt?: boolean;
+}
+export interface RelationMetadata {
+    type: "hasMany" | "belongsTo";
+    targetModel: () => any;
+    foreignKey: string;
+    localKey?: string;
+}
+export interface WrapperEntry {
+    name: string;
+    columns: Map<string | symbol, Column>;
+    relations: Map<string | symbol, RelationMetadata>;
+}
+export type IncludeRelationOptions = {
+    where?: Record<string, any>;
+    attributes?: string[];
+    order?: "ASC" | "DESC";
+    skip?: number;
+    limit?: number;
+    include?: Record<string, IncludeRelationOptions | true>;
+};
+export type WhereQueryOptions<T> = {
+    order?: "ASC" | "DESC";
+    skip?: number;
+    limit?: number;
+    attributes?: (keyof InferAttributes<T>)[];
+    include?: {
+        [K in keyof T]?: T[K] extends HasMany<any> | BelongsTo<any> ? IncludeRelationOptions | true : never;
+    };
+};
+export type Mutate = (value: any) => any;
+export type Validate = (value: any) => boolean | string;
+export {};

package/src/@types/index.js

@@ -0,0 +1,9 @@
+"use strict";
+/*
+@file index.ts
+@descripcion Tipos públicos de Dynamite ORM
+@autor Miguel Alejandro
+@fecha 2025-08-07
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/src/core/client.d.ts

@@ -0,0 +1,69 @@
+/**
+ * @file client.ts
+ * @description Centralized Dynamite client with multi-client support and table sync
+ * @autor Miguel Alejandro
+ * @fecha 2025-01-27
+ */
+import { DynamoDBClient, DynamoDBClientConfig } from "@aws-sdk/client-dynamodb";
+/**
+ * Configuration for Dynamite client initialization
+ */
+export interface DynamiteConfig extends DynamoDBClientConfig {
+    tables: Array<new (...args: any[]) => any>;
+}
+/**
+ * Centralized Dynamite client for managing DynamoDB connections and table synchronization
+ */
+export declare class Dynamite {
+    private client;
+    private tables;
+    private connected;
+    private synced;
+    /**
+     * Initialize Dynamite client with configuration
+     * @param config Dynamite client configuration
+     */
+    constructor(config: DynamiteConfig);
+    /**
+     * Synchronize all declared tables and their GSIs
+     */
+    sync(): Promise<void>;
+    /**
+     * Connect the client for Table operations
+     */
+    connect(): void;
+    /**
+     * Get the underlying DynamoDB client
+     */
+    getClient(): DynamoDBClient;
+    /**
+     * Check if client is connected and tables are synced
+     */
+    isReady(): boolean;
+    /**
+     * Disconnect and cleanup DynamoDB client
+     */
+    disconnect(): void;
+    /**
+     * Create table with automatic GSI detection and creation
+     * @param ctor Table class constructor
+     */
+    private createTableWithGSI;
+}
+/**
+ * Set global client for Table class operations
+ * @param client DynamoDB client instance
+ */
+export declare const setGlobalClient: (client: DynamoDBClient) => void;
+/**
+ * Get global client for Table class operations
+ */
+export declare const getGlobalClient: () => DynamoDBClient;
+/**
+ * Check if global client is available
+ */
+export declare const hasGlobalClient: () => boolean;
+/**
+ * Require global client for Table operations (throws if not available)
+ */
+export declare const requireClient: () => DynamoDBClient;

package/src/core/client.js

@@ -0,0 +1,164 @@
+"use strict";
+/**
+ * @file client.ts
+ * @description Centralized Dynamite client with multi-client support and table sync
+ * @autor Miguel Alejandro
+ * @fecha 2025-01-27
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireClient = exports.hasGlobalClient = exports.getGlobalClient = exports.setGlobalClient = exports.Dynamite = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const wrapper_1 = __importDefault(require("./wrapper"));
+/**
+ * Centralized Dynamite client for managing DynamoDB connections and table synchronization
+ */
+class Dynamite {
+    /**
+     * Initialize Dynamite client with configuration
+     * @param config Dynamite client configuration
+     */
+    constructor(config) {
+        this.connected = false;
+        this.synced = false;
+        const { tables, ...clientConfig } = config;
+        this.client = new client_dynamodb_1.DynamoDBClient(clientConfig);
+        this.tables = tables;
+    }
+    /**
+     * Synchronize all declared tables and their GSIs
+     */
+    async sync() {
+        if (this.synced && this.connected)
+            return;
+        await Promise.all(this.tables.map((table) => this.createTableWithGSI(table)));
+        this.synced = true;
+    }
+    /**
+     * Connect the client for Table operations
+     */
+    connect() {
+        if (this.connected)
+            return;
+        (0, exports.setGlobalClient)(this.client);
+        this.connected = true;
+    }
+    /**
+     * Get the underlying DynamoDB client
+     */
+    getClient() {
+        return this.client;
+    }
+    /**
+     * Check if client is connected and tables are synced
+     */
+    isReady() {
+        return this.connected && this.synced;
+    }
+    /**
+     * Disconnect and cleanup DynamoDB client
+     */
+    disconnect() {
+        try {
+            this.client.destroy();
+            this.connected = false;
+            this.synced = false;
+            if (globalClient === this.client)
+                globalClient = undefined;
+        }
+        catch (error) {
+            console.warn("Error during Dynamite disconnect:", error);
+        }
+    }
+    /**
+     * Create table with automatic GSI detection and creation
+     * @param ctor Table class constructor
+     */
+    async createTableWithGSI(ctor) {
+        const meta = wrapper_1.default.get(ctor);
+        if (!meta)
+            throw new Error(`Class ${ctor.name} not registered in wrapper`);
+        const cols = [...meta.columns.values()];
+        const pk = cols.find((c) => c.index);
+        if (!pk)
+            throw new Error(`PartitionKey missing in ${ctor.name}`);
+        const sk = cols.find((c) => c.indexSort);
+        const attr = new Map();
+        attr.set(pk.name, "S");
+        if (sk)
+            attr.set(sk.name, "S");
+        let gsiIndex = 1;
+        const gsiDefinitions = [...meta.relations.values()]
+            .filter((relation) => relation.type === "hasMany")
+            .map((relation) => {
+            const { foreignKey } = relation;
+            if (!attr.has(foreignKey))
+                attr.set(foreignKey, "S");
+            return {
+                IndexName: `GSI${gsiIndex++}_${foreignKey}`,
+                KeySchema: [{ AttributeName: foreignKey, KeyType: "HASH" }],
+                Projection: { ProjectionType: "ALL" },
+            };
+        });
+        const schema = [{ AttributeName: pk.name, KeyType: "HASH" }];
+        if (sk && sk.name !== pk.name)
+            schema.push({ AttributeName: sk.name, KeyType: "RANGE" });
+        try {
+            await this.client.send(new client_dynamodb_1.CreateTableCommand({
+                TableName: meta.name,
+                BillingMode: "PAY_PER_REQUEST",
+                AttributeDefinitions: [...attr].map(([AttributeName, AttributeType]) => ({
+                    AttributeName,
+                    AttributeType,
+                })),
+                KeySchema: schema,
+                ...(gsiDefinitions.length > 0 && {
+                    GlobalSecondaryIndexes: gsiDefinitions,
+                }),
+            }));
+        }
+        catch (error) {
+            if (error.name !== "ResourceInUseException")
+                throw error;
+        }
+    }
+}
+exports.Dynamite = Dynamite;
+let globalClient;
+/**
+ * Set global client for Table class operations
+ * @param client DynamoDB client instance
+ */
+const setGlobalClient = (client) => {
+    globalClient = client;
+};
+exports.setGlobalClient = setGlobalClient;
+/**
+ * Get global client for Table class operations
+ */
+const getGlobalClient = () => {
+    if (!globalClient)
+        throw new Error("No global DynamoDB client set. Call setGlobalClient() first.");
+    return globalClient;
+};
+exports.getGlobalClient = getGlobalClient;
+/**
+ * Check if global client is available
+ */
+const hasGlobalClient = () => {
+    return globalClient !== undefined;
+};
+exports.hasGlobalClient = hasGlobalClient;
+/**
+ * Require global client for Table operations (throws if not available)
+ */
+const requireClient = () => {
+    if (!globalClient) {
+        throw new Error("DynamoDB client no configurado. Use Dynamite.connect() primero.");
+    }
+    return globalClient;
+};
+exports.requireClient = requireClient;
+//# sourceMappingURL=client.js.map

package/src/core/table.d.ts

@@ -0,0 +1,98 @@
+/**
+ * @file table.ts
+ * @descripcion Clase Table rediseñada con API completa y tipado estricto
+ * @autor Miguel Alejandro
+ * @fecha 2025-07-30
+ */
+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];
+    };
+    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>;
+    /**
+     * Eliminar registros de la base de datos
+     */
+    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[]>;
+    /**
+     * Obtener el primer registro que coincida con los filtros
+     */
+    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>;
+    /**
+     * Obtener el último registro que coincida con los filtros
+     */
+    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>;
+}
+export { STORE };
+export type { WrapperEntry };