@aurios/mizzle 1.1.1 → 1.1.3

package/src/expressions/builder.ts

@@ -1,13 +1,13 @@
 import {
-    type Expression,
-    BinaryExpression,
-    LogicalExpression,
-    FunctionExpression,
+  type Expression,
+  BinaryExpression,
+  LogicalExpression,
+  FunctionExpression,
 } from "./operators";
 
 /**
  * Recursively builds a DynamoDB expression string from an Expression object.
- * 
+ *
  * @param cond The expression object to build.
  * @param addName A callback to add an attribute name and return its placeholder.
  * @param addValue A callback to add an attribute value and return its placeholder.
@@ -15,63 +15,71 @@ import {
  * @returns A string suitable for use in ConditionExpression or FilterExpression.
  */
 export function buildExpression(
-    cond: Expression,
-    addName: (name: string) => string,
-    addValue: (value: unknown) => string,
-    excludeColumns?: Set<string>,
+  cond: Expression,
+  addName: (name: string) => string,
+  addValue: (value: unknown) => string,
+  excludeColumns?: Set<string>,
 ): string | undefined {
-    if (cond instanceof LogicalExpression) {
-        const parts = cond.conditions
-            .map((c) => buildExpression(c, addName, addValue, excludeColumns))
-            .filter((p): p is string => p !== undefined && p !== "");
-        
-        if (parts.length === 0) return undefined;
-        if (parts.length === 1) return parts[0];
-        return `(${parts.join(` ${cond.operator} `)})`;
-    }
+  if (cond instanceof LogicalExpression) {
+    const parts = cond.conditions
+      .map((c) => buildExpression(c, addName, addValue, excludeColumns))
+      .filter((p): p is string => p !== undefined && p !== "");
 
-    if (cond instanceof BinaryExpression) {
-        if (excludeColumns?.has(cond.column.name)) {
-            return undefined;
-        }
-        const colName = addName(cond.column.name);
-        const mapValue = (v: unknown) => typeof (cond.column as any).mapToDynamoValue === "function" 
-            ? (cond.column as any).mapToDynamoValue(v) 
-            : v;
+    if (parts.length === 0) return undefined;
+    if (parts.length === 1) return parts[0];
+    return `(${parts.join(` ${cond.operator} `)})`;
+  }
 
-        if (cond.operator === "between") {
-            const valArray = cond.value as unknown[];
-            const valKey1 = addValue(mapValue(valArray[0]));
-            const valKey2 = addValue(mapValue(valArray[1]));
-            return `${colName} BETWEEN ${valKey1} AND ${valKey2}`;
-        }
+  if (cond instanceof BinaryExpression) {
+    if (excludeColumns?.has(cond.column.name)) {
+      return undefined;
+    }
+    const colName = addName(cond.column.name);
+    const mapValue = (v: unknown) =>
+      typeof (cond.column as unknown as { mapToDynamoValue: Function }).mapToDynamoValue ===
+      "function"
+        ? (
+            cond.column as unknown as { mapToDynamoValue: (v: unknown) => unknown }
+          ).mapToDynamoValue(v)
+        : v;
 
-        if (cond.operator === "in") {
-            const valArray = cond.value as unknown[];
-            const valKeys = valArray.map((val) => addValue(mapValue(val)));
-            return `${colName} IN (${valKeys.join(", ")})`;
-        }
+    if (cond.operator === "between") {
+      const valArray = cond.value as unknown[];
+      const valKey1 = addValue(mapValue(valArray[0]));
+      const valKey2 = addValue(mapValue(valArray[1]));
+      return `${colName} BETWEEN ${valKey1} AND ${valKey2}`;
+    }
 
-        const valKey = addValue(mapValue(cond.value));
-        return `${colName} ${cond.operator} ${valKey}`;
+    if (cond.operator === "in") {
+      const valArray = cond.value as unknown[];
+      const valKeys = valArray.map((val) => addValue(mapValue(val)));
+      return `${colName} IN (${valKeys.join(", ")})`;
     }
 
-    if (cond instanceof FunctionExpression) {
-        if (excludeColumns?.has(cond.column.name)) {
-            return undefined;
-        }
-        const colName = addName(cond.column.name);
-        const mapValue = (v: unknown) => typeof (cond.column as any).mapToDynamoValue === "function" 
-            ? (cond.column as any).mapToDynamoValue(v) 
-            : v;
+    const valKey = addValue(mapValue(cond.value));
+    return `${colName} ${cond.operator} ${valKey}`;
+  }
 
-        if (cond.operator === "attribute_exists") {
-            return `attribute_exists(${colName})`;
-        }
+  if (cond instanceof FunctionExpression) {
+    if (excludeColumns?.has(cond.column.name)) {
+      return undefined;
+    }
+    const colName = addName(cond.column.name);
+    const mapValue = (v: unknown) =>
+      typeof (cond.column as unknown as { mapToDynamoValue: Function }).mapToDynamoValue ===
+      "function"
+        ? (
+            cond.column as unknown as { mapToDynamoValue: (v: unknown) => unknown }
+          ).mapToDynamoValue(v)
+        : v;
 
-        const valKey = addValue(mapValue(cond.value));
-        return `${cond.operator}(${colName}, ${valKey})`;
+    if (cond.operator === "attribute_exists") {
+      return `attribute_exists(${colName})`;
     }
 
-    return undefined;
-}
+    const valKey = addValue(mapValue(cond.value));
+    return `${cond.operator}(${colName}, ${valKey})`;
+  }
+
+  return undefined;
+}

package/src/expressions/operators.ts

@@ -5,102 +5,102 @@ type LogicalOperators = "AND" | "OR";
 type FunctionOperators = "begins_with" | "contains" | "attribute_exists";
 
 export abstract class Expression {
-    abstract readonly type: "binary" | "logical" | "function";
+  abstract readonly type: "binary" | "logical" | "function";
 }
 
 export class BinaryExpression extends Expression {
-    readonly type = "binary";
-    constructor(
-        readonly column: Column,
-        readonly operator: BinaryOperators,
-        readonly value: unknown,
-    ) {
-        super();
-    }
+  readonly type = "binary";
+  constructor(
+    readonly column: Column,
+    readonly operator: BinaryOperators,
+    readonly value: unknown,
+  ) {
+    super();
+  }
 }
 
 export class LogicalExpression extends Expression {
-    readonly type = "logical";
-    constructor(
-        readonly conditions: Expression[],
-        readonly operator: LogicalOperators,
-    ) {
-        super();
-    }
+  readonly type = "logical";
+  constructor(
+    readonly conditions: Expression[],
+    readonly operator: LogicalOperators,
+  ) {
+    super();
+  }
 }
 
 export class FunctionExpression extends Expression {
-    readonly type = "function";
-    constructor(
-        readonly column: Column,
-        readonly operator: FunctionOperators,
-        readonly value: unknown,
-    ) {
-        super();
-    }
+  readonly type = "function";
+  constructor(
+    readonly column: Column,
+    readonly operator: FunctionOperators,
+    readonly value: unknown,
+  ) {
+    super();
+  }
 }
 
 export function eq(column: Column, value: unknown) {
-    return new BinaryExpression(column, "=", value);
+  return new BinaryExpression(column, "=", value);
 }
 
 export function gt(column: Column, value: unknown) {
-    return new BinaryExpression(column, ">", value);
+  return new BinaryExpression(column, ">", value);
 }
 
 export function gte(column: Column, value: unknown) {
-    return new BinaryExpression(column, ">=", value);
+  return new BinaryExpression(column, ">=", value);
 }
 
 export function lt(column: Column, value: unknown) {
-    return new BinaryExpression(column, "<", value);
+  return new BinaryExpression(column, "<", value);
 }
 
 export function lte(column: Column, value: unknown) {
-    return new BinaryExpression(column, "<=", value);
+  return new BinaryExpression(column, "<=", value);
 }
 
 export function between(column: Column, values: [unknown, unknown]) {
-    return new BinaryExpression(column, "between", values);
+  return new BinaryExpression(column, "between", values);
 }
 
 export function inList(column: Column, values: unknown[]) {
-    return new BinaryExpression(column, "in", values);
+  return new BinaryExpression(column, "in", values);
 }
 
 export function beginsWith(column: Column, value: string) {
-    return new FunctionExpression(column, "begins_with", value);
+  return new FunctionExpression(column, "begins_with", value);
 }
 
 export function contains(column: Column, value: unknown) {
-    return new FunctionExpression(column, "contains", value);
+  return new FunctionExpression(column, "contains", value);
 }
 
 export function attributeExists(column: Column) {
-    return new FunctionExpression(column, "attribute_exists", undefined);
+  return new FunctionExpression(column, "attribute_exists", undefined);
 }
 
 export function or(...conditions: Expression[]) {
-    return new LogicalExpression(conditions, "OR");
+  return new LogicalExpression(conditions, "OR");
 }
 
 export function and(...conditions: Expression[]) {
-    return new LogicalExpression(conditions, "AND");
+  return new LogicalExpression(conditions, "AND");
 }
 
 export const operators = {
-    eq,
-    gt,
-    gte,
-    lt,
-    lte,
-    between,
-    in: inList,
-    and,
-    or,
-    contains,
-    beginsWith,
-    attributeExists,
+  eq,
+  gt,
+  gte,
+  lt,
+  lte,
+  between,
+  in: inList,
+  and,
+  or,
+  contains,
+  beginsWith,
+  attributeExists,
 };
 
 export type Operators = typeof operators;

package/src/expressions/update-builder.ts

@@ -1,98 +1,102 @@
 import { type Column } from "../core/column";
-import { UpdateAction } from "./actions";
+import { UpdateAction, SetAction, AddAction, DeleteAction } from "./actions";
 
 export interface UpdateState {
-    set: Record<string, { value: unknown; functionName?: string; usePathAsFirstArg?: boolean }>;
-    add: Record<string, unknown>;
-    remove: string[];
-    delete: Record<string, unknown>;
+  set: Record<string, { value: unknown; functionName?: string; usePathAsFirstArg?: boolean }>;
+  add: Record<string, unknown>;
+  remove: string[];
+  delete: Record<string, unknown>;
 }
 
 export function createUpdateState(): UpdateState {
-    return {
-        set: {},
-        add: {},
-        remove: [],
-        delete: {},
-    };
+  return {
+    set: {},
+    add: {},
+    remove: [],
+    delete: {},
+  };
 }
 
 export function partitionUpdateValues(
-    values: Record<string, unknown | UpdateAction>,
-    state: UpdateState,
-    columns?: Record<string, Column>
+  values: Record<string, unknown | UpdateAction>,
+  state: UpdateState,
+  columns?: Record<string, Column>,
 ): void {
-    for (const [key, val] of Object.entries(values)) {
-        const col = columns?.[key];
-        const mapValue = (v: unknown) => (col && typeof (col as any).mapToDynamoValue === "function")
-            ? (col as any).mapToDynamoValue(v) 
-            : v;
+  for (const [key, val] of Object.entries(values)) {
+    const col = columns?.[key];
+    const mapValue = (v: unknown) =>
+      col &&
+      typeof (col as unknown as { mapToDynamoValue: Function }).mapToDynamoValue === "function"
+        ? (col as unknown as { mapToDynamoValue: (v: unknown) => unknown }).mapToDynamoValue(v)
+        : v;
 
-        if (val instanceof UpdateAction) {
-            switch (val.action) {
-                case "SET":
-                    state.set[key] = {
-                        value: mapValue((val as any).value),
-                        functionName: (val as any).functionName,
-                        usePathAsFirstArg: (val as any).usePathAsFirstArg,
-                    };
-                    break;
-                case "ADD":
-                    state.add[key] = mapValue((val as any).value);
-                    break;
-                case "REMOVE":
-                    state.remove.push(key);
-                    break;
-                case "DELETE":
-                    state.delete[key] = mapValue((val as any).value);
-                    break;
-            }
-        } else if (val !== undefined) {
-            state.set[key] = { value: mapValue(val) };
+    if (val instanceof UpdateAction) {
+      switch (val.action) {
+        case "SET": {
+          const setVal = val as SetAction;
+          state.set[key] = {
+            value: mapValue(setVal.value),
+            functionName: setVal.functionName,
+            usePathAsFirstArg: setVal.usePathAsFirstArg,
+          };
+          break;
         }
+        case "ADD":
+          state.add[key] = mapValue((val as AddAction).value);
+          break;
+        case "REMOVE":
+          state.remove.push(key);
+          break;
+        case "DELETE":
+          state.delete[key] = mapValue((val as DeleteAction).value);
+          break;
+      }
+    } else if (val !== undefined) {
+      state.set[key] = { value: mapValue(val) };
     }
+  }
 }
 
 export function buildUpdateExpressionString(
-    state: UpdateState,
-    addName: (name: string) => string,
-    addValue: (value: unknown) => string
+  state: UpdateState,
+  addName: (name: string) => string,
+  addValue: (value: unknown) => string,
 ): string {
-    const sections: string[] = [];
+  const sections: string[] = [];
 
-    if (Object.keys(state.set).length > 0) {
-        const parts = Object.entries(state.set).map(([key, config]) => {
-            const name = addName(key);
-            const value = addValue(config.value);
-            if (config.functionName) {
-                if (config.usePathAsFirstArg) {
-                    return `${name} = ${config.functionName}(${name}, ${value})`;
-                }
-                return `${name} = ${config.functionName}(${value})`;
-            }
-            return `${name} = ${value}`;
-        });
-        sections.push(`SET ${parts.join(", ")}`);
-    }
+  if (Object.keys(state.set).length > 0) {
+    const parts = Object.entries(state.set).map(([key, config]) => {
+      const name = addName(key);
+      const value = addValue(config.value);
+      if (config.functionName) {
+        if (config.usePathAsFirstArg) {
+          return `${name} = ${config.functionName}(${name}, ${value})`;
+        }
+        return `${name} = ${config.functionName}(${value})`;
+      }
+      return `${name} = ${value}`;
+    });
+    sections.push(`SET ${parts.join(", ")}`);
+  }
 
-    if (Object.keys(state.add).length > 0) {
-        const parts = Object.entries(state.add).map(([key, val]) => {
-            return `${addName(key)} ${addValue(val)}`;
-        });
-        sections.push(`ADD ${parts.join(", ")}`);
-    }
+  if (Object.keys(state.add).length > 0) {
+    const parts = Object.entries(state.add).map(([key, val]) => {
+      return `${addName(key)} ${addValue(val)}`;
+    });
+    sections.push(`ADD ${parts.join(", ")}`);
+  }
 
-    if (state.remove.length > 0) {
-        const parts = state.remove.map((key) => addName(key));
-        sections.push(`REMOVE ${parts.join(", ")}`);
-    }
+  if (state.remove.length > 0) {
+    const parts = state.remove.map((key) => addName(key));
+    sections.push(`REMOVE ${parts.join(", ")}`);
+  }
 
-    if (Object.keys(state.delete).length > 0) {
-        const parts = Object.entries(state.delete).map(([key, val]) => {
-            return `${addName(key)} ${addValue(val)}`;
-        });
-        sections.push(`DELETE ${parts.join(", ")}`);
-    }
+  if (Object.keys(state.delete).length > 0) {
+    const parts = Object.entries(state.delete).map(([key, val]) => {
+      return `${addName(key)} ${addValue(val)}`;
+    });
+    sections.push(`DELETE ${parts.join(", ")}`);
+  }
 
-    return sections.join(" ");
+  return sections.join(" ");
 }

package/src/index.ts

@@ -1,4 +1,4 @@
-export * from "@mizzle/shared";
+export * from "@repo/shared";
 export * from "./expressions/operators";
 export * from "./expressions/builder";
 export * from "./expressions/actions";
@@ -13,6 +13,7 @@ export * from "./builders/relational-builder";
 export * from "./core/table";
 export * from "./core/strategies";
 export * from "./core/relations";
+export * from "./core/diff";
 export * from "./core/retry";
 export * from "./core/errors";
 export * from "./columns";

package/src/indexes.ts

@@ -1,19 +1,19 @@
 export interface IndexColumnConfig {
-    pk?: string;
-    sk?: string;
+  pk?: string;
+  sk?: string;
 }
 
 export class IndexBuilder {
-    constructor(
-        public type: "gsi" | "lsi",
-        public config: IndexColumnConfig,
-    ) {}
+  constructor(
+    public type: "gsi" | "lsi",
+    public config: IndexColumnConfig,
+  ) {}
 }
 
 export function gsi(pkColumn: string, skColumn?: string) {
-    return new IndexBuilder("gsi", { pk: pkColumn, sk: skColumn });
+  return new IndexBuilder("gsi", { pk: pkColumn, sk: skColumn });
 }
 
 export function lsi(skColumn: string) {
-    return new IndexBuilder("lsi", { sk: skColumn });
+  return new IndexBuilder("lsi", { sk: skColumn });
 }

package/test/batch-resilience.test.ts

@@ -0,0 +1,138 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mizzle } from "@aurios/mizzle";
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
+import { ENTITY_SYMBOLS, TABLE_SYMBOLS } from "@repo/shared";
+
+// Mock send method
+const mockSend = vi.fn();
+const mockDocClient = {
+  send: mockSend,
+  middlewareStack: {
+    add: vi.fn(),
+    remove: vi.fn(),
+  },
+};
+
+describe("Batch Resilience", () => {
+  const mockTable = {
+    [ENTITY_SYMBOLS.PHYSICAL_TABLE]: {
+      [TABLE_SYMBOLS.TABLE_NAME]: "test-table",
+      [TABLE_SYMBOLS.PARTITION_KEY]: { name: "pk" },
+      [TABLE_SYMBOLS.SORT_KEY]: undefined,
+      [TABLE_SYMBOLS.INDEXES]: {},
+    },
+    [ENTITY_SYMBOLS.ENTITY_STRATEGY]: { pk: { type: "static", segments: ["test"] } },
+    [ENTITY_SYMBOLS.COLUMNS]: {
+      pk: { name: "pk" },
+      name: { name: "name" },
+    },
+  } as any;
+
+  beforeEach(() => {
+    vi.spyOn(DynamoDBDocumentClient, "from").mockReturnValue(mockDocClient as any);
+    mockSend.mockReset();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("should retry unprocessed keys in batchGet", async () => {
+    const client = new DynamoDBClient({});
+    const db = mizzle(client);
+
+    // 1st call: returns 1 item and 1 unprocessed key
+    mockSend.mockResolvedValueOnce({
+      Responses: {
+        "test-table": [{ pk: "test1", name: "Item 1" }],
+      },
+      UnprocessedKeys: {
+        "test-table": {
+          Keys: [{ pk: "test2" }],
+        },
+      },
+    });
+
+    // 2nd call: returns the 2nd item
+    mockSend.mockResolvedValueOnce({
+      Responses: {
+        "test-table": [{ pk: "test2", name: "Item 2" }],
+      },
+    });
+
+    const result = await db.batchGet(mockTable, [{ pk: "test1" }, { pk: "test2" }]).execute();
+
+    expect(result.succeeded[0]!.name).toBe("Item 1");
+    expect(result.succeeded[1]!.name).toBe("Item 2");
+  });
+
+  it("should retry unprocessed items in batchWrite", async () => {
+    const client = new DynamoDBClient({});
+    const db = mizzle(client);
+
+    // 1st call: 1 unprocessed item
+    mockSend.mockResolvedValueOnce({
+      UnprocessedItems: {
+        "test-table": [{ PutRequest: { Item: { pk: "test2", name: "Item 2" } } }],
+      },
+    });
+
+    // 2nd call: success
+    mockSend.mockResolvedValueOnce({
+      UnprocessedItems: {},
+    });
+
+    const result = await db
+      .batchWrite(mockTable, [
+        { type: "put", item: { pk: "test1", name: "Item 1" } },
+        { type: "put", item: { pk: "test2", name: "Item 2" } },
+      ])
+      .execute();
+
+    expect(result.succeededCount).toBe(2);
+    expect(mockSend).toHaveBeenCalledTimes(2);
+  });
+
+  it("should return failed keys after max attempts in batchGet", async () => {
+    const client = new DynamoDBClient({});
+    const db = mizzle(client);
+
+    // Always returns unprocessed
+    mockSend.mockResolvedValue({
+      UnprocessedKeys: {
+        "test-table": {
+          Keys: [{ pk: "test1" }],
+        },
+      },
+    });
+
+    const result = await db.batchGet(mockTable, [{ pk: "test1" }]).execute();
+
+    expect(result.succeeded).toHaveLength(0);
+    expect(result.failed).toHaveLength(1);
+    expect(result.failed[0]).toEqual({ pk: "test1" });
+    expect(mockSend).toHaveBeenCalledTimes(5); // Internal limit
+  });
+
+  it("should return failed items after max attempts in batchWrite", async () => {
+    const client = new DynamoDBClient({});
+    const db = mizzle(client);
+
+    mockSend.mockResolvedValue({
+      UnprocessedItems: {
+        "test-table": [{ PutRequest: { Item: { pk: "test1" } } }],
+      },
+    });
+
+    const result = await db
+      .batchWrite(mockTable, [{ type: "put", item: { pk: "test1" } }])
+      .execute();
+    const res = result as any;
+
+    expect(res.succeededCount).toBe(0);
+    expect(res.failed).toHaveLength(1);
+    expect(res.failed[0].PutRequest.Item.pk).toBe("test1");
+    expect(mockSend).toHaveBeenCalledTimes(5);
+  });
+});