@aurios/mizzle 1.1.2 → 1.1.4

package/src/builders/transaction.ts

@@ -6,166 +6,184 @@ import { DeleteBuilder } from "./delete";
 import { Expression } from "../expressions/operators";
 import { BaseBuilder } from "./base";
 import type { IMizzleClient } from "../core/client";
-import { ENTITY_SYMBOLS } from "@mizzle/shared";
+import { ENTITY_SYMBOLS } from "@repo/shared";
 import { buildExpression } from "../expressions/builder";
 import { buildUpdateExpressionString } from "../expressions/update-builder";
 import { TransactionFailedError } from "../core/errors";
 
 export class ConditionCheckBuilder<TEntity extends Entity> extends BaseBuilder<TEntity, void> {
-    static readonly [ENTITY_SYMBOLS.ENTITY_KIND]: string = "ConditionCheckBuilder";
-
-    private _whereClause?: Expression;
-
-    constructor(entity: TEntity, client: IMizzleClient) {
-        super(entity, client);
-    }
-
-    where(expression: Expression): this {
-        this._whereClause = expression;
-        return this;
-    }
-
-    public override async execute(): Promise<void> {
-        throw new Error("ConditionCheckBuilder cannot be executed directly. Use it within a transaction.");
-    }
-
-    /** @internal */
-    get whereClause() {
-        return this._whereClause;
-    }
-
-    /** @internal */
-    public override createExpressionContext(prefix = "") {
-        return super.createExpressionContext(prefix);
-    }
-
-    /** @internal */
-    public override resolveKeys(
-        whereClause?: Expression,
-        providedValues?: Record<string, unknown>,
-    ) {
-        return super.resolveKeys(whereClause, providedValues);
-    }
+  static readonly [ENTITY_SYMBOLS.ENTITY_KIND]: string = "ConditionCheckBuilder";
+
+  private _whereClause?: Expression;
+
+  constructor(entity: TEntity, client: IMizzleClient) {
+    super(entity, client);
+  }
+
+  where(expression: Expression): this {
+    this._whereClause = expression;
+    return this;
+  }
+
+  public override async execute(): Promise<void> {
+    throw new Error(
+      "ConditionCheckBuilder cannot be executed directly. Use it within a transaction.",
+    );
+  }
+
+  /** @internal */
+  get whereClause() {
+    return this._whereClause;
+  }
+
+  /** @internal */
+  public override createExpressionContext(prefix = "") {
+    return super.createExpressionContext(prefix);
+  }
+
+  /** @internal */
+  public override resolveKeys(whereClause?: Expression, providedValues?: Record<string, unknown>) {
+    return super.resolveKeys(whereClause, providedValues);
+  }
 }
 
 export class TransactionProxy {
-    constructor(private client: IMizzleClient) {}
-
-    insert<TEntity extends Entity>(entity: TEntity): InsertBuilder<TEntity> {
-        return new InsertBuilder(entity, this.client);
-    }
-
-    update<TEntity extends Entity>(entity: TEntity): UpdateBuilder<TEntity> {
-        return new UpdateBuilder(entity, this.client);
-    }
-
-    delete<TEntity extends Entity>(entity: TEntity, keys: Record<string, unknown>): DeleteBuilder<TEntity> {
-        return new DeleteBuilder(entity, this.client, keys);
-    }
-
-    conditionCheck<TEntity extends Entity>(entity: TEntity): ConditionCheckBuilder<TEntity> {
-        return new ConditionCheckBuilder(entity, this.client);
-    }
+  constructor(private client: IMizzleClient) {}
+
+  insert<TEntity extends Entity>(entity: TEntity): InsertBuilder<TEntity> {
+    return new InsertBuilder(entity, this.client);
+  }
+
+  update<TEntity extends Entity>(entity: TEntity): UpdateBuilder<TEntity> {
+    return new UpdateBuilder(entity, this.client);
+  }
+
+  delete<TEntity extends Entity>(
+    entity: TEntity,
+    keys: Record<string, unknown>,
+  ): DeleteBuilder<TEntity> {
+    return new DeleteBuilder(entity, this.client, keys);
+  }
+
+  conditionCheck<TEntity extends Entity>(entity: TEntity): ConditionCheckBuilder<TEntity> {
+    return new ConditionCheckBuilder(entity, this.client);
+  }
 }
 
 export class TransactionExecutor {
-    constructor(private client: IMizzleClient) {}
-
-    async execute(token: string, operations: BaseBuilder<Entity, unknown>[]): Promise<void> {
-        const transactItems = operations.map(op => this.mapToTransactItem(op));
-
-        const command = new TransactWriteCommand({
-            TransactItems: transactItems,
-            ClientRequestToken: token,
-        });
-
-        try {
-            await this.client.send(command);
-        } catch (error: unknown) {
-            const err = error as Error & { __type?: string; CancellationReasons?: Record<string, unknown>[] };
-            if (err.name === "TransactionCanceledException" || err.__type?.includes("TransactionCanceledException")) {
-                const reasons = (err.CancellationReasons || []).map((reason: Record<string, unknown>, index: number) => ({
-                    index,
-                    code: reason.Code as string,
-                    message: reason.Message as string,
-                    item: reason.Item as Record<string, unknown> | undefined
-                })).filter((reason) => reason.code !== "None");
-                
-                throw new TransactionFailedError("Transaction canceled by server.", reasons);
-            }
-            throw error;
-        }
-    }
-
-    private mapToTransactItem(builder: BaseBuilder<Entity, unknown>): Record<string, unknown> {
-        const kind = (builder.constructor as unknown as { [ENTITY_SYMBOLS.ENTITY_KIND]: string })[ENTITY_SYMBOLS.ENTITY_KIND];
-
-        switch (kind) {
-            case "InsertBase":
-                return { Put: this.mapPut(builder as InsertBase<Entity, unknown>) };
-            case "UpdateBuilder":
-                return { Update: this.mapUpdate(builder as UpdateBuilder<Entity, unknown>) };
-            case "DeleteBuilder":
-                return { Delete: this.mapDelete(builder as DeleteBuilder<Entity, unknown>) };
-            case "ConditionCheckBuilder":
-                return { ConditionCheck: this.mapConditionCheck(builder as ConditionCheckBuilder<Entity>) };
-            default:
-                throw new Error(`Unsupported transaction operation: ${kind}`);
-        }
-    }
-
-    private mapPut(builder: InsertBase<Entity, unknown>): Record<string, unknown> {
-        const finalItem = builder.buildItem();
-
-        return {
-            TableName: builder.tableName,
-            Item: finalItem,
-        };
-    }
-
-    private mapUpdate(builder: UpdateBuilder<Entity, unknown>): Record<string, unknown> {
-        const { expressionAttributeNames, expressionAttributeValues, addName, addValue } = builder.createExpressionContext("up_");
-        const updateExpression = buildUpdateExpressionString(builder.state, addName, addValue);
-        
-        let conditionExpression: string | undefined;
-        if (builder.whereClause) {
-            conditionExpression = buildExpression(builder.whereClause, addName, addValue);
-        }
-
-        return {
-            TableName: builder.tableName,
-            Key: builder.resolveUpdateKeys(),
-            UpdateExpression: updateExpression,
-            ConditionExpression: conditionExpression,
-            ExpressionAttributeNames: Object.keys(expressionAttributeNames).length > 0 ? expressionAttributeNames : undefined,
-            ExpressionAttributeValues: Object.keys(expressionAttributeValues).length > 0 ? expressionAttributeValues : undefined,
-        };
-    }
-
-    private mapDelete(builder: DeleteBuilder<Entity, unknown>): Record<string, unknown> {
-        const resolution = builder.resolveKeys(undefined, builder.keys);
-        return {
-            TableName: builder.tableName,
-            Key: resolution.keys,
-        };
-    }
-
-    private mapConditionCheck(builder: ConditionCheckBuilder<Entity>): Record<string, unknown> {
-        const { expressionAttributeNames, expressionAttributeValues, addName, addValue } = builder.createExpressionContext("cc_");
-        
-        const resolution = builder.resolveKeys(builder.whereClause);
-        
-        let conditionExpression: string | undefined;
-        if (builder.whereClause) {
-            conditionExpression = buildExpression(builder.whereClause, addName, addValue);
-        }
-
-        return {
-            TableName: builder.tableName,
-            Key: resolution.keys,
-            ConditionExpression: conditionExpression,
-            ExpressionAttributeNames: Object.keys(expressionAttributeNames).length > 0 ? expressionAttributeNames : undefined,
-            ExpressionAttributeValues: Object.keys(expressionAttributeValues).length > 0 ? expressionAttributeValues : undefined,
-        };
-    }
-}
+  constructor(private client: IMizzleClient) {}
+
+  async execute(token: string, operations: BaseBuilder<Entity, unknown>[]): Promise<void> {
+    const transactItems = operations.map((op) => this.mapToTransactItem(op));
+
+    const command = new TransactWriteCommand({
+      TransactItems: transactItems,
+      ClientRequestToken: token,
+    });
+
+    try {
+      await this.client.send(command);
+    } catch (error: unknown) {
+      const err = error as Error & {
+        __type?: string;
+        CancellationReasons?: Record<string, unknown>[];
+      };
+      if (
+        err.name === "TransactionCanceledException" ||
+        err.__type?.includes("TransactionCanceledException")
+      ) {
+        const reasons = (err.CancellationReasons || [])
+          .map((reason: Record<string, unknown>, index: number) => ({
+            index,
+            code: reason.Code as string,
+            message: reason.Message as string,
+            item: reason.Item as Record<string, unknown> | undefined,
+          }))
+          .filter((reason) => reason.code !== "None");
+
+        throw new TransactionFailedError("Transaction canceled by server.", reasons);
+      }
+      throw error;
+    }
+  }
+
+  private mapToTransactItem(builder: BaseBuilder<Entity, unknown>): Record<string, unknown> {
+    const kind = (builder.constructor as unknown as { [ENTITY_SYMBOLS.ENTITY_KIND]: string })[
+      ENTITY_SYMBOLS.ENTITY_KIND
+    ];
+
+    switch (kind) {
+      case "InsertBase":
+        return { Put: this.mapPut(builder as InsertBase<Entity, unknown>) };
+      case "UpdateBuilder":
+        return { Update: this.mapUpdate(builder as UpdateBuilder<Entity, unknown>) };
+      case "DeleteBuilder":
+        return { Delete: this.mapDelete(builder as DeleteBuilder<Entity, unknown>) };
+      case "ConditionCheckBuilder":
+        return { ConditionCheck: this.mapConditionCheck(builder as ConditionCheckBuilder<Entity>) };
+      default:
+        throw new Error(`Unsupported transaction operation: ${kind}`);
+    }
+  }
+
+  private mapPut(builder: InsertBase<Entity, unknown>): Record<string, unknown> {
+    const finalItem = builder.buildItem();
+
+    return {
+      TableName: builder.tableName,
+      Item: finalItem,
+    };
+  }
+
+  private mapUpdate(builder: UpdateBuilder<Entity, unknown>): Record<string, unknown> {
+    const { expressionAttributeNames, expressionAttributeValues, addName, addValue } =
+      builder.createExpressionContext("up_");
+    const updateExpression = buildUpdateExpressionString(builder.state, addName, addValue);
+
+    let conditionExpression: string | undefined;
+    if (builder.whereClause) {
+      conditionExpression = buildExpression(builder.whereClause, addName, addValue);
+    }
+
+    return {
+      TableName: builder.tableName,
+      Key: builder.resolveUpdateKeys(),
+      UpdateExpression: updateExpression,
+      ConditionExpression: conditionExpression,
+      ExpressionAttributeNames:
+        Object.keys(expressionAttributeNames).length > 0 ? expressionAttributeNames : undefined,
+      ExpressionAttributeValues:
+        Object.keys(expressionAttributeValues).length > 0 ? expressionAttributeValues : undefined,
+    };
+  }
+
+  private mapDelete(builder: DeleteBuilder<Entity, unknown>): Record<string, unknown> {
+    const resolution = builder.resolveKeys(undefined, builder.keys);
+    return {
+      TableName: builder.tableName,
+      Key: resolution.keys,
+    };
+  }
+
+  private mapConditionCheck(builder: ConditionCheckBuilder<Entity>): Record<string, unknown> {
+    const { expressionAttributeNames, expressionAttributeValues, addName, addValue } =
+      builder.createExpressionContext("cc_");
+
+    const resolution = builder.resolveKeys(builder.whereClause);
+
+    let conditionExpression: string | undefined;
+    if (builder.whereClause) {
+      conditionExpression = buildExpression(builder.whereClause, addName, addValue);
+    }
+
+    return {
+      TableName: builder.tableName,
+      Key: resolution.keys,
+      ConditionExpression: conditionExpression,
+      ExpressionAttributeNames:
+        Object.keys(expressionAttributeNames).length > 0 ? expressionAttributeNames : undefined,
+      ExpressionAttributeValues:
+        Object.keys(expressionAttributeValues).length > 0 ? expressionAttributeValues : undefined,
+    };
+  }
+}