@arcaelas/dynamite 1.0.29 → 3.1.0

package/build/esm/@types/index.d.ts

@@ -0,0 +1,213 @@
+/**
+ * @file index.ts
+ * @description Sistema de tipos para Dynamite ORM - Arquitectura con type-safety completo
+ * @autor Miguel Alejandro
+ * @fecha 2025-01-28
+ */
+/**
+ * Marca para identificar campos que no son atributos de BD (relaciones, métodos).
+ */
+export declare const NonAttributeBrand: unique symbol;
+/**
+ * Marca para identificar campos opcionales en create() pero presentes en el modelo.
+ */
+export declare const CreationOptionalBrand: unique symbol;
+/**
+ * Wrapper para marcar relaciones y campos virtuales que no se persisten en BD.
+ * @example
+ * ```typescript
+ * class User extends Table<User> {
+ *   @HasMany(() => Post, 'user_id')
+ *   declare posts: NonAttribute<Post[]>;
+ * }
+ * ```
+ */
+export type NonAttribute<T> = T & {
+    [NonAttributeBrand]?: true;
+};
+/**
+ * Wrapper para marcar campos opcionales en create() (auto-generados: id, timestamps).
+ * @example
+ * ```typescript
+ * class User extends Table<User> {
+ *   @PrimaryKey() id: CreationOptional<string>;
+ *   @CreatedAt() created_at: CreationOptional<number>;
+ *   name: string;
+ * }
+ * await User.create({ name: 'Juan' }); // id y created_at opcionales
+ * ```
+ */
+export type CreationOptional<T> = T & {
+    [CreationOptionalBrand]?: true;
+};
+/**
+ * Extrae atributos de BD usando intersección:
+ * - Primera parte: atributos REQUERIDOS con modificador `-?`
+ * - Segunda parte: atributos OPCIONALES (solo CreationOptional)
+ * - Ambos excluyen: never, undefined, null, NonAttribute, métodos
+ * @example
+ * ```typescript
+ * class User {
+ *   id: CreationOptional<string>;
+ *   created_at: CreationOptional<number>;
+ *   name: string;
+ *   email: string;
+ *   posts: NonAttribute<Post[]>;
+ *   save(): void;
+ * }
+ * // InferAttributes<User> = { name: string, email: string } & { id?: string, created_at?: number }
+ * // = { name: string, email: string, id?: string, created_at?: number }
+ * ```
+ */
+export type InferAttributes<T> = {
+    [K in keyof T as T[K] extends ((...args: any[]) => any) | {
+        [NonAttributeBrand]?: true;
+    } | {
+        [CreationOptionalBrand]?: true;
+    } ? never : K]-?: Exclude<T[K], null | undefined | never>;
+} & {
+    [K in keyof T as T[K] extends {
+        [CreationOptionalBrand]?: true;
+    } ? K : never]?: Exclude<T[K], null | undefined | never>;
+};
+/**
+ * Extrae solo relaciones (NonAttribute) preservando tipo Model | Model[]
+ * Excluye propiedades de Object.prototype para evitar conflictos
+ * @example
+ * ```typescript
+ * class User extends Table<User> {
+ *   id: string;
+ *   posts: NonAttribute<Post[]>;      // Array
+ *   profile: NonAttribute<Profile>;   // Individual
+ *   settings: NonAttribute<Settings | null>; // Nullable
+ * }
+ * // InferRelations<User> = { posts: Post[], profile: Profile, settings: Settings | null }
+ * ```
+ */
+type ObjectBuiltinKeys = keyof Record<string, never> | 'toString' | 'valueOf' | 'hasOwnProperty' | 'isPrototypeOf' | 'propertyIsEnumerable' | 'toLocaleString' | 'constructor';
+export type InferRelations<T> = {
+    [K in keyof T as T[K] extends NonAttribute<any> ? K extends ObjectBuiltinKeys ? never : K : never]: T[K] extends NonAttribute<infer P> ? P : never;
+};
+/**
+ * Extrae solo relaciones (campos NonAttribute).
+ * Usado internamente para validación.
+ * @example
+ * ```typescript
+ * class User {
+ *   id: string;
+ *   name: string;
+ *   posts: NonAttribute<Post[]>;
+ *   profile: NonAttribute<Profile>;
+ * }
+ * // PickRelations<User> = { posts: Post[], profile: Profile }
+ * ```
+ */
+export type PickRelations<T> = {
+    [K in keyof T as T[K] extends NonAttribute<any> ? K : never]: T[K] extends NonAttribute<infer U> ? U : never;
+};
+/**
+ * Operadores de comparación soportados.
+ * Solo 8 operadores permitidos según especificación del usuario.
+ */
+export type QueryOperator = "=" | "$eq" | "<>" | "!=" | "$ne" | "<" | "$lt" | "<=" | "$lte" | ">" | "$gt" | ">=" | "$gte" | "in" | "$in" | "include" | "$include";
+/**
+ * Opciones de query con pre-cache de atributos (A) y relaciones (R)
+ * @template T - Modelo de tabla
+ * @template A - Cache de InferAttributes<T>
+ * @template R - Cache de InferRelations<T>
+ * @example
+ * ```typescript
+ * await User.where({}, {
+ *   where: {
+ *     name: 'Juan',
+ *     age: { $gte: 18, $lte: 65 }
+ *   },
+ *   order: 'DESC',
+ *   limit: 10,
+ *   attributes: ['name', 'email'],
+ *   include: {
+ *     posts: {
+ *       where: { published: true },
+ *       limit: 5,
+ *       include: { comments: true }
+ *     },
+ *     profile: {
+ *       attributes: ['bio', 'avatar']
+ *     }
+ *   }
+ * });
+ * ```
+ */
+export interface WhereOptions<T, A = InferAttributes<T>, R = InferRelations<T>> {
+    /** Filtros de búsqueda */
+    where?: {
+        [K in keyof A]?: A[K] | {
+            [N in QueryOperator]?: A[K];
+        };
+    };
+    /** Orden de resultados */
+    order?: "ASC" | "DESC" | {
+        [K in keyof A]?: "ASC" | "DESC";
+    };
+    /** Número de items a saltar */
+    offset?: number;
+    /** Alias de offset */
+    skip?: number;
+    /** Número máximo de items a retornar */
+    limit?: number;
+    /** Campos a seleccionar */
+    attributes?: Array<keyof A>;
+    /** Relaciones a cargar (recursivo) */
+    include?: {
+        [K in keyof R]?: NonNullable<R[K]> extends Array<infer U> ? true | WhereOptions<U> : true | Pick<WhereOptions<NonNullable<R[K]>>, "attributes" | "include">;
+    };
+    /** Incluir registros soft-deleted */
+    _includeTrashed?: boolean;
+}
+/**
+ * Input para create() - InferAttributes ya maneja opcional/requerido con intersección
+ * @example
+ * ```typescript
+ * class User extends Table<User> {
+ *   id: CreationOptional<string>;
+ *   created_at: CreationOptional<number>;
+ *   name: string;
+ *   email: string;
+ * }
+ * // CreateInput<User> = { name: string, email: string, id?: string, created_at?: number }
+ * await User.create({ name: 'Juan', email: 'juan@example.com' }); // id y created_at opcionales
+ * ```
+ */
+export type CreateInput<T> = InferAttributes<T>;
+/**
+ * Tipo para update() - todos los campos parciales.
+ * @example
+ * ```typescript
+ * await user.update({ name: 'Ana' }); // Todos los campos opcionales
+ * ```
+ */
+export type UpdateInput<T> = Partial<InferAttributes<T>>;
+/**
+ * Picks only keys from T whose value extends V.
+ * Selecciona solo las keys de T cuyo valor extiende V.
+ * @example
+ * ```typescript
+ * class User { name: string; age: number; score: number; }
+ * // PickByType<InferAttributes<User>, number> = { age: number, score: number }
+ * ```
+ */
+type StripBrands<T> = T extends number & {
+    [NonAttributeBrand]?: any;
+} ? number : T extends string & {
+    [NonAttributeBrand]?: any;
+} ? string : T extends number & {
+    [CreationOptionalBrand]?: any;
+} ? number : T extends string & {
+    [CreationOptionalBrand]?: any;
+} ? string : T extends boolean & {
+    [CreationOptionalBrand]?: any;
+} ? boolean : T;
+export type PickByType<T, V> = {
+    [K in keyof T as StripBrands<NonNullable<T[K]>> extends V ? K : never]: T[K];
+};
+export {};

package/build/esm/@types/index.js

@@ -0,0 +1,8 @@
+/**
+ * @file index.ts
+ * @description Sistema de tipos para Dynamite ORM - Arquitectura con type-safety completo
+ * @autor Miguel Alejandro
+ * @fecha 2025-01-28
+ */
+export {};
+//# sourceMappingURL=index.js.map

package/build/esm/@types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/@types/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/build/esm/core/client.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @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);
+    /**
+     * @description Configure the DynamoDB client. Does not create tables or GSIs -- use sync() for that.
+     * @description Configura el cliente DynamoDB. No crea tablas ni GSIs -- usar sync() para eso.
+     */
+    connect(): Promise<void>;
+    /**
+     * @description Synchronize all tables, GSIs and pivot tables with DynamoDB.
+     * @description Sincroniza tablas, GSIs y pivot tables con DynamoDB.
+     */
+    sync(): Promise<void>;
+    /**
+     * @description Poll DescribeTable until all GSIs on the given tables are ACTIVE.
+     * @description Polling de DescribeTable hasta que todos los GSIs de las tablas dadas estén ACTIVE.
+     */
+    private waitForActiveGSIs;
+    /**
+     * Ejecutar operaciones en una transacción atómica.
+     * Si cualquier operación falla, todas se revierten automáticamente.
+     *
+     * @param callback Función que recibe el contexto de transacción
+     * @returns Resultado del callback
+     *
+     * @example
+     * await dynamite.tx(async (tx) => {
+     *   const user = await User.create({ name: "Juan" }, tx);
+     *   await Order.create({ user_id: user.id, total: 100 }, tx);
+     * });
+     */
+    tx<R>(callback: (tx: TransactionContext) => Promise<R>): Promise<R>;
+}
+/**
+ * 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;
+/**
+ * @description Transaction context for grouping atomic operations. Max 100 operations (auto-chunked in batches of 25).
+ * @description Contexto de transacción para operaciones atómicas. Máximo 100 operaciones (auto-divididas en lotes de 25).
+ */
+export declare class TransactionContext {
+    private operations;
+    private after_commit;
+    private client;
+    constructor(client: DynamoDBClient);
+    addPut(table_name: string, item: Record<string, any>, condition?: {
+        expression: string;
+        names: Record<string, string>;
+    }): void;
+    addDelete(table_name: string, key: Record<string, any>): void;
+    addUpdate(table_name: string, key: Record<string, any>, expression: string, names: Record<string, string>, values: Record<string, any>): void;
+    /**
+     * @description Register a callback (sync or async) to run after successful commit.
+     * @description Registra un callback (síncrono o asíncrono) que se ejecuta después de un commit exitoso.
+     */
+    onCommit(fn: () => void | Promise<void>): void;
+    commit(): Promise<void>;
+    private guard;
+}

package/build/esm/core/client.js

@@ -0,0 +1,375 @@
+/**
+ * @file client.ts
+ * @description Centralized Dynamite client with multi-client support and table sync
+ * @autor Miguel Alejandro
+ * @fecha 2025-01-27
+ */
+import { CreateTableCommand, DescribeTableCommand, DynamoDBClient, TransactWriteItemsCommand, UpdateTableCommand, } from "@aws-sdk/client-dynamodb";
+import { marshall } from "@aws-sdk/util-dynamodb";
+import { SCHEMA } from "./decorator.js";
+/**
+ * Centralized Dynamite client for managing DynamoDB connections and table synchronization
+ */
+export class Dynamite {
+    /**
+     * Initialize Dynamite client with configuration
+     * @param config Dynamite client configuration
+     */
+    constructor(config) {
+        this.connected = false;
+        this.synced = false;
+        const { tables, ...options } = config;
+        this.client = new DynamoDBClient({
+            ...options,
+        });
+        this.tables = tables;
+    }
+    /**
+     * @description Configure the DynamoDB client. Does not create tables or GSIs -- use sync() for that.
+     * @description Configura el cliente DynamoDB. No crea tablas ni GSIs -- usar sync() para eso.
+     */
+    async connect() {
+        if (this.connected)
+            return;
+        setGlobalClient(this.client);
+        this.connected = true;
+        // Computar GSIs esperados desde los schemas (sin llamadas API)
+        const pk_by_table = new Map();
+        for (const tc of this.tables) {
+            const s = tc[SCHEMA];
+            if (!s)
+                continue;
+            const pk_col = Object.values(s.columns).find(c => c.store.index || c.store.primaryKey);
+            pk_by_table.set(s.name, pk_col?.name ?? 'id');
+        }
+        for (const tc of this.tables) {
+            const s = tc[SCHEMA];
+            if (!s)
+                continue;
+            for (const col_name in s.columns) {
+                const rel = s.columns[col_name].store.relation;
+                if (!rel || (rel.type !== 'HasMany' && rel.type !== 'HasOne'))
+                    continue;
+                const related = rel.model()?.[SCHEMA];
+                if (!related)
+                    continue;
+                const related_pk = pk_by_table.get(related.name);
+                if (rel.foreignKey !== related_pk) {
+                    related.gsis.add(rel.foreignKey);
+                }
+            }
+        }
+    }
+    /**
+     * @description Synchronize all tables, GSIs and pivot tables with DynamoDB.
+     * @description Sincroniza tablas, GSIs y pivot tables con DynamoDB.
+     */
+    async sync() {
+        if (!this.connected)
+            throw new Error('Call connect() before sync()');
+        if (this.synced)
+            return;
+        // Phase 1: Collect requirements
+        const tables = new Map();
+        const pivots = new Map();
+        for (const table_class of this.tables) {
+            const schema = table_class[SCHEMA];
+            if (!schema)
+                throw new Error(`Class ${table_class.name} not registered. Use decorators.`);
+            const cols = Object.values(schema.columns);
+            const pk = cols.find(c => c.store.index || c.store.primaryKey);
+            if (!pk)
+                throw new Error(`PartitionKey missing in ${table_class.name}`);
+            const sk = cols.find(c => c.store.indexSort) ?? null;
+            tables.set(schema.name, { pk: pk.name, sk: sk?.name ?? null, gsis: new Set() });
+        }
+        for (const table_class of this.tables) {
+            const schema = table_class[SCHEMA];
+            for (const col_name in schema.columns) {
+                const relation = schema.columns[col_name].store.relation;
+                if (!relation)
+                    continue;
+                if (relation.type === 'HasMany' || relation.type === 'HasOne') {
+                    const related_schema = relation.model()?.[SCHEMA];
+                    if (related_schema && tables.has(related_schema.name)) {
+                        const entry = tables.get(related_schema.name);
+                        if (relation.foreignKey !== entry.pk) {
+                            entry.gsis.add(relation.foreignKey);
+                        }
+                    }
+                }
+                if (relation.type === 'ManyToMany' && relation.pivotTable) {
+                    pivots.set(relation.pivotTable, {
+                        foreignKey: relation.foreignKey,
+                        relatedKey: relation.relatedKey,
+                    });
+                }
+            }
+        }
+        // Phase 2: Describe all tables + pivots in parallel
+        const all_table_names = [...tables.keys()];
+        const all_pivot_names = [...pivots.keys()];
+        const all_names = [...all_table_names, ...all_pivot_names];
+        const descriptions = await Promise.all(all_names.map(async (name) => {
+            try {
+                const result = await this.client.send(new DescribeTableCommand({ TableName: name }));
+                const existing_gsis = new Set((result.Table?.GlobalSecondaryIndexes ?? []).map(g => g.IndexName));
+                return { name, exists: true, existing_gsis };
+            }
+            catch (e) {
+                if (e.name === 'ResourceNotFoundException')
+                    return { name, exists: false, existing_gsis: new Set() };
+                throw e;
+            }
+        }));
+        const described = new Map(descriptions.map(d => [d.name, d]));
+        // Phase 3: Create missing tables in parallel
+        const to_create = [];
+        for (const [name, entry] of tables) {
+            const desc = described.get(name);
+            if (desc.exists)
+                continue;
+            const attrs = new Map([[entry.pk, 'S']]);
+            if (entry.sk)
+                attrs.set(entry.sk, 'S');
+            for (const gsi_field of entry.gsis)
+                attrs.set(gsi_field, 'S');
+            const key_schema = [
+                { AttributeName: entry.pk, KeyType: 'HASH' },
+            ];
+            if (entry.sk)
+                key_schema.push({ AttributeName: entry.sk, KeyType: 'RANGE' });
+            const gsi_defs = [...entry.gsis].map(field => ({
+                IndexName: `${field}_index`,
+                KeySchema: [{ AttributeName: field, KeyType: 'HASH' }],
+                Projection: { ProjectionType: 'ALL' },
+            }));
+            to_create.push(this.client.send(new CreateTableCommand({
+                TableName: name,
+                BillingMode: 'PAY_PER_REQUEST',
+                AttributeDefinitions: [...attrs].map(([AttributeName, AttributeType]) => ({ AttributeName, AttributeType })),
+                KeySchema: key_schema,
+                ...(gsi_defs.length > 0 && { GlobalSecondaryIndexes: gsi_defs }),
+            })).then(() => { }));
+        }
+        for (const [name, meta] of pivots) {
+            const desc = described.get(name);
+            if (desc.exists)
+                continue;
+            to_create.push(this.client.send(new CreateTableCommand({
+                TableName: name,
+                BillingMode: 'PAY_PER_REQUEST',
+                KeySchema: [{ AttributeName: 'id', KeyType: 'HASH' }],
+                AttributeDefinitions: [
+                    { AttributeName: 'id', AttributeType: 'S' },
+                    { AttributeName: meta.foreignKey, AttributeType: 'S' },
+                    { AttributeName: meta.relatedKey, AttributeType: 'S' },
+                ],
+                GlobalSecondaryIndexes: [
+                    { IndexName: `${meta.foreignKey}_index`, KeySchema: [{ AttributeName: meta.foreignKey, KeyType: 'HASH' }], Projection: { ProjectionType: 'ALL' } },
+                    { IndexName: `${meta.relatedKey}_index`, KeySchema: [{ AttributeName: meta.relatedKey, KeyType: 'HASH' }], Projection: { ProjectionType: 'ALL' } },
+                ],
+            })).then(() => { }));
+        }
+        await Promise.all(to_create);
+        // Phase 4: Add missing GSIs to existing tables (round-robin, parallel across tables)
+        const pending_gsis = new Map();
+        for (const [name, entry] of tables) {
+            const desc = described.get(name);
+            if (!desc.exists)
+                continue;
+            const missing = [...entry.gsis].filter(field => !desc.existing_gsis.has(`${field}_index`));
+            if (missing.length > 0)
+                pending_gsis.set(name, missing);
+        }
+        for (const [name, meta] of pivots) {
+            const desc = described.get(name);
+            if (!desc.exists)
+                continue;
+            const expected = [`${meta.foreignKey}_index`, `${meta.relatedKey}_index`];
+            const missing_fields = [];
+            if (!desc.existing_gsis.has(expected[0]))
+                missing_fields.push(meta.foreignKey);
+            if (!desc.existing_gsis.has(expected[1]))
+                missing_fields.push(meta.relatedKey);
+            if (missing_fields.length > 0)
+                pending_gsis.set(name, missing_fields);
+        }
+        while (pending_gsis.size > 0) {
+            const round = [];
+            for (const [table_name, fields] of pending_gsis) {
+                const field = fields.shift();
+                if (fields.length === 0)
+                    pending_gsis.delete(table_name);
+                round.push(this.client.send(new UpdateTableCommand({
+                    TableName: table_name,
+                    AttributeDefinitions: [{ AttributeName: field, AttributeType: 'S' }],
+                    GlobalSecondaryIndexUpdates: [{
+                            Create: {
+                                IndexName: `${field}_index`,
+                                KeySchema: [{ AttributeName: field, KeyType: 'HASH' }],
+                                Projection: { ProjectionType: 'ALL' },
+                            },
+                        }],
+                })).then(() => { }));
+            }
+            await Promise.all(round);
+            // Wait for all GSIs in this round to become ACTIVE
+            const tables_in_round = round.length;
+            if (tables_in_round > 0) {
+                const active_checks = [...pending_gsis.keys()];
+                // Also check tables that just had their last GSI added
+                for (const [table_name] of tables) {
+                    if (!pending_gsis.has(table_name))
+                        active_checks.push(table_name);
+                }
+                for (const [pivot_name] of pivots) {
+                    if (!pending_gsis.has(pivot_name))
+                        active_checks.push(pivot_name);
+                }
+                await this.waitForActiveGSIs([...new Set(active_checks)]);
+            }
+        }
+        this.synced = true;
+    }
+    /**
+     * @description Poll DescribeTable until all GSIs on the given tables are ACTIVE.
+     * @description Polling de DescribeTable hasta que todos los GSIs de las tablas dadas estén ACTIVE.
+     */
+    async waitForActiveGSIs(table_names) {
+        const pending = new Set(table_names);
+        while (pending.size > 0) {
+            await new Promise(r => setTimeout(r, 3000));
+            const checks = await Promise.all([...pending].map(async (name) => {
+                const result = await this.client.send(new DescribeTableCommand({ TableName: name }));
+                const all_active = (result.Table?.GlobalSecondaryIndexes ?? [])
+                    .every(g => g.IndexStatus === 'ACTIVE');
+                return { name, all_active };
+            }));
+            for (const { name, all_active } of checks) {
+                if (all_active)
+                    pending.delete(name);
+            }
+        }
+    }
+    /**
+     * Ejecutar operaciones en una transacción atómica.
+     * Si cualquier operación falla, todas se revierten automáticamente.
+     *
+     * @param callback Función que recibe el contexto de transacción
+     * @returns Resultado del callback
+     *
+     * @example
+     * await dynamite.tx(async (tx) => {
+     *   const user = await User.create({ name: "Juan" }, tx);
+     *   await Order.create({ user_id: user.id, total: 100 }, tx);
+     * });
+     */
+    async tx(callback) {
+        const ctx = new TransactionContext(this.client);
+        const result = await callback(ctx);
+        await ctx.commit();
+        return result;
+    }
+}
+let globalClient;
+/**
+ * Set global client for Table class operations
+ * @param client DynamoDB client instance
+ */
+export const setGlobalClient = (client) => {
+    globalClient = client;
+};
+/**
+ * Get global client for Table class operations
+ */
+export const getGlobalClient = () => {
+    if (!globalClient)
+        throw new Error("No global DynamoDB client set. Call setGlobalClient() first.");
+    return globalClient;
+};
+/**
+ * Check if global client is available
+ */
+export const hasGlobalClient = () => {
+    return globalClient !== undefined;
+};
+/**
+ * Require global client for Table operations (throws if not available)
+ */
+export const requireClient = () => {
+    if (!globalClient) {
+        throw new Error("DynamoDB client no configurado. Use Dynamite.connect() primero.");
+    }
+    return globalClient;
+};
+/**
+ * @description Transaction context for grouping atomic operations. Max 100 operations (auto-chunked in batches of 25).
+ * @description Contexto de transacción para operaciones atómicas. Máximo 100 operaciones (auto-divididas en lotes de 25).
+ */
+export class TransactionContext {
+    constructor(client) {
+        this.operations = [];
+        this.after_commit = [];
+        this.client = client;
+    }
+    addPut(table_name, item, condition) {
+        this.guard();
+        const op = {
+            Put: {
+                TableName: table_name,
+                Item: marshall(item, { removeUndefinedValues: true }),
+            },
+        };
+        if (condition) {
+            op.Put.ConditionExpression = condition.expression;
+            op.Put.ExpressionAttributeNames = condition.names;
+        }
+        this.operations.push(op);
+    }
+    addDelete(table_name, key) {
+        this.guard();
+        this.operations.push({
+            Delete: {
+                TableName: table_name,
+                Key: marshall(key),
+            },
+        });
+    }
+    addUpdate(table_name, key, expression, names, values) {
+        this.guard();
+        this.operations.push({
+            Update: {
+                TableName: table_name,
+                Key: marshall(key),
+                UpdateExpression: expression,
+                ExpressionAttributeNames: names,
+                ExpressionAttributeValues: marshall(values, { removeUndefinedValues: true }),
+            },
+        });
+    }
+    /**
+     * @description Register a callback (sync or async) to run after successful commit.
+     * @description Registra un callback (síncrono o asíncrono) que se ejecuta después de un commit exitoso.
+     */
+    onCommit(fn) {
+        this.after_commit.push(fn);
+    }
+    async commit() {
+        if (this.operations.length === 0)
+            return;
+        // DynamoDB limit: 25 per TransactWriteItems. Chunk if needed.
+        for (let i = 0; i < this.operations.length; i += 25) {
+            const chunk = this.operations.slice(i, i + 25);
+            await this.client.send(new TransactWriteItemsCommand({ TransactItems: chunk }));
+        }
+        for (const fn of this.after_commit)
+            await fn();
+    }
+    guard() {
+        if (this.operations.length >= 100) {
+            throw new Error(`Transaction exceeds 100 operations limit (has ${this.operations.length})`);
+        }
+    }
+}
+//# sourceMappingURL=client.js.map