@aurios/mizzle 1.1.1 → 1.1.3

package/test/builders/relational.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect, vi } from "vitest";
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { dynamoTable, dynamoEntity } from "@aurios/mizzle/table";
+import { mizzle } from "@aurios/mizzle/db";
+import { string, uuid } from "@aurios/mizzle/columns";
+
+// Mock DynamoDBDocumentClient.from to return a mock doc client
+vi.mock("@aws-sdk/lib-dynamodb", async (importOriginal) => {
+  const original = await importOriginal<Record<string, unknown>>();
+  return {
+    ...original,
+    DynamoDBDocumentClient: {
+      from: vi.fn(() => ({
+        send: vi.fn(async () => ({ Items: [] })),
+      })),
+    },
+  };
+});
+
+const client = {
+  config: { protocol: "https:" },
+  send: vi.fn(),
+} as unknown as DynamoDBClient;
+
+const table = dynamoTable("mizzle-test", {
+  pk: string("pk"),
+});
+
+const users = dynamoEntity(table, "users", {
+  id: uuid("id"),
+  name: string("name"),
+});
+
+const db = mizzle({
+  client,
+  relations: {
+    users,
+  },
+});
+
+describe("RelationalQueryBuilder.findMany()", () => {
+  it("should fetch multiple records without relations", async () => {
+    // Since we don't have a real DB in this unit test without mocking,
+    // we'll at least verify the builder returns a promise and we can call findMany.
+    // Integration tests will verify actual data fetching.
+    const query = db.query.users.findMany();
+    expect(query).toBeInstanceOf(Promise);
+  });
+
+  it("should apply limit", async () => {
+    const query = db.query.users.findMany({ limit: 10 });
+    expect(query).toBeInstanceOf(Promise);
+  });
+
+  it("should apply where condition", async () => {
+    const query = db.query.users.findMany({
+      where: (cols, { eq }) => eq(cols.id, "123"),
+    });
+    expect(query).toBeInstanceOf(Promise);
+  });
+
+  it("should call findFirst", async () => {
+    const query = db.query.users.findFirst();
+    expect(query).toBeInstanceOf(Promise);
+  });
+});

package/test/builders/select.test.ts

@@ -0,0 +1,411 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { dynamoTable, dynamoEntity } from "@aurios/mizzle/table";
+import { string, uuid, number, boolean } from "@aurios/mizzle/columns";
+import { prefixKey, staticKey } from "@aurios/mizzle";
+import { DynamoDBClient, CreateTableCommand, DeleteTableCommand, DescribeTableCommand, DescribeTableCommand } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient, PutCommand } from "@aws-sdk/lib-dynamodb";
+import { mizzle } from "@aurios/mizzle/db";
+import { eq } from "@aurios/mizzle/expressions/operators";
+
+const client = new DynamoDBClient({
+  endpoint: "http://localhost:8000",
+  region: "us-east-1",
+  credentials: {
+    accessKeyId: "local",
+    secretAccessKey: "local",
+  },
+});
+
+const docClient = DynamoDBDocumentClient.from(client);
+
+describe("Select Command", () => {
+  const tableName = "TestTable_Select";
+  const table = dynamoTable(tableName, {
+    pk: string("pk"),
+    sk: string("sk"),
+  });
+
+  const user = dynamoEntity(
+    table,
+    "User",
+    {
+      id: uuid(),
+      name: string(),
+      age: number(),
+      active: boolean(),
+      role: string(),
+    },
+    (cols) => ({
+      pk: prefixKey("USER#", cols.id),
+      sk: staticKey("METADATA"),
+    }),
+  );
+
+  const testUser1 = {
+    pk: "USER#user1",
+    sk: "METADATA",
+    id: "user1",
+    name: "Alice",
+    age: 30,
+    active: true,
+    role: "admin",
+  };
+
+  const testUser2 = {
+    pk: "USER#user2",
+    sk: "METADATA",
+    id: "user2",
+    name: "Bob",
+    age: 25,
+    active: false,
+    role: "user",
+  };
+
+  beforeAll(async () => {
+    try {
+      await client.send(
+        new CreateTableCommand({
+          TableName: tableName,
+          KeySchema: [
+            { AttributeName: "pk", KeyType: "HASH" },
+            { AttributeName: "sk", KeyType: "RANGE" },
+          ],
+          AttributeDefinitions: [
+            { AttributeName: "pk", AttributeType: "S" },
+            { AttributeName: "sk", AttributeType: "S" },
+          ],
+          ProvisionedThroughput: {
+            ReadCapacityUnits: 5,
+            WriteCapacityUnits: 5,
+          },
+        }),
+      );
+
+      await docClient.send(new PutCommand({ TableName: tableName, Item: testUser1 }));
+      await docClient.send(new PutCommand({ TableName: tableName, Item: testUser2 }));
+    } catch {
+      // Table might already exist
+    }
+  });
+
+  afterAll(async () => {
+    try {
+      await client.send(new DeleteTableCommand({ TableName: tableName }));
+    } catch {
+      /* ignore */
+    }
+  });
+
+  it("should query by primary key", async () => {
+    const result = await mizzle(client).select().from(user).where(eq(user.id, "user1"));
+
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({
+      id: "user1",
+      name: "Alice",
+    });
+  });
+
+  it("should return empty array if no match found", async () => {
+    const result = await mizzle(client).select().from(user).where(eq(user.id, "non-existent"));
+
+    expect(result).toHaveLength(0);
+  });
+
+  it("should scan table if no keys provided", async () => {
+    // This should trigger a scan
+    const result = await mizzle(client).select().from(user).execute();
+
+    expect(result).toHaveLength(2);
+    expect(result).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: "user1" }),
+        expect.objectContaining({ id: "user2" }),
+      ]),
+    );
+  });
+
+  // Note: To test Query with partial key, we need a table where SK is relevant for querying multiple items
+  // or use a GSI. Since our current schema uses specific IDs in PK, querying by PK usually yields one result.
+  // Let's create a GSI test case.
+});
+
+import { gsi } from "@aurios/mizzle/indexes";
+
+describe("Select Command with GSI", () => {
+  const tableName = "TestTable_Select_GSI";
+
+  const table = dynamoTable(tableName, {
+    pk: string("pk"),
+    sk: string("sk"),
+    indexes: {
+      gsi1: gsi("gsi1pk", "gsi1sk"),
+    },
+  });
+
+  const user = dynamoEntity(
+    table,
+    "User",
+    {
+      id: uuid(),
+      role: string(),
+      name: string(),
+      createdAt: string(),
+    },
+    (cols) => ({
+      pk: prefixKey("USER#", cols.id),
+      sk: staticKey("METADATA"),
+      gsi1: {
+        pk: staticKey("ROLE"),
+        sk: prefixKey("", cols.role),
+      },
+    }),
+  );
+
+  beforeAll(async () => {
+    try {
+      await client.send(
+        new CreateTableCommand({
+          TableName: tableName,
+          KeySchema: [
+            { AttributeName: "pk", KeyType: "HASH" },
+            { AttributeName: "sk", KeyType: "RANGE" },
+          ],
+          AttributeDefinitions: [
+            { AttributeName: "pk", AttributeType: "S" },
+            { AttributeName: "sk", AttributeType: "S" },
+            { AttributeName: "gsi1pk", AttributeType: "S" },
+            { AttributeName: "gsi1sk", AttributeType: "S" },
+          ],
+          GlobalSecondaryIndexes: [
+            {
+              IndexName: "gsi1",
+              KeySchema: [
+                { AttributeName: "gsi1pk", KeyType: "HASH" },
+                { AttributeName: "gsi1sk", KeyType: "RANGE" },
+              ],
+              Projection: { ProjectionType: "ALL" },
+              ProvisionedThroughput: { ReadCapacityUnits: 5, WriteCapacityUnits: 5 },
+            },
+          ],
+          ProvisionedThroughput: {
+            ReadCapacityUnits: 5,
+            WriteCapacityUnits: 5,
+          },
+        }),
+      );
+
+      // Wait for table to be active
+      let active = false;
+      while (!active) {
+        const { Table } = await client.send(new DescribeTableCommand({ TableName: tableName }));
+        if (Table?.TableStatus === "ACTIVE") active = true;
+        else await new Promise((r) => setTimeout(r, 100));
+      }
+
+      // Insert data
+      await docClient.send(
+        new PutCommand({
+          TableName: tableName,
+          Item: {
+            pk: "USER#1",
+            sk: "METADATA",
+            id: "1",
+            role: "admin",
+            name: "Alice",
+            gsi1pk: "ROLE",
+            gsi1sk: "admin",
+          },
+        }),
+      );
+      await docClient.send(
+        new PutCommand({
+          TableName: tableName,
+          Item: {
+            pk: "USER#2",
+            sk: "METADATA",
+            id: "2",
+            role: "admin",
+            name: "Bob",
+            gsi1pk: "ROLE",
+            gsi1sk: "admin",
+          },
+        }),
+      );
+      await docClient.send(
+        new PutCommand({
+          TableName: tableName,
+          Item: {
+            pk: "USER#3",
+            sk: "METADATA",
+            id: "3",
+            role: "user",
+            name: "Charlie",
+            gsi1pk: "ROLE",
+            gsi1sk: "user",
+          },
+        }),
+      );
+    } catch {
+      // Table might already exist
+    }
+  });
+
+  afterAll(async () => {
+    try {
+      await client.send(new DeleteTableCommand({ TableName: tableName }));
+    } catch {
+      /* ignore */
+    }
+  });
+
+  it("should query using GSI (static PK)", async () => {
+    // Query for all roles (since PK is static "ROLE")
+    // But our strategy says gsi1: { pk: staticKey("ROLE"), sk: cols.role }
+    // If we filter by something that resolves the PK, we can query.
+
+    // However, staticKey("ROLE") means the PK is *always* "ROLE".
+    // So any query on this entity that doesn't target main PK,
+    // if we can resolve "ROLE" (which is static), we should be able to query the index.
+
+    // Currently resolveStrategies logic requires us to 'find' the values in the where clause.
+    // For static key, it resolves immediately.
+
+    // So a query with NO where clause (or where clause that doesn't contradict)
+    // might resolve to this index if main PK is missing?
+
+    // Let's try querying where we filter by role="admin".
+    // This should provide the SK for the GSI, and PK is static.
+
+    const result = await mizzle(client).select().from(user).where(eq(user.role, "admin"));
+
+    expect(result).toHaveLength(2);
+    expect(result).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ name: "Alice" }),
+        expect.objectContaining({ name: "Bob" }),
+      ]),
+    );
+  });
+});
+
+describe("Select Consistency and PageSize", () => {
+  const tableName = "TestTable_Consistency";
+  const table = dynamoTable(tableName, {
+    pk: string("pk"),
+    sk: string("sk"),
+  });
+
+  const user = dynamoEntity(
+    table,
+    "User",
+    {
+      id: uuid(),
+      name: string(),
+    },
+    (cols) => ({
+      pk: prefixKey("USER#", cols.id),
+      sk: staticKey("METADATA"),
+    }),
+  );
+
+  beforeAll(async () => {
+    try {
+      await client.send(
+        new CreateTableCommand({
+          TableName: tableName,
+          KeySchema: [
+            { AttributeName: "pk", KeyType: "HASH" },
+            { AttributeName: "sk", KeyType: "RANGE" },
+          ],
+          AttributeDefinitions: [
+            { AttributeName: "pk", AttributeType: "S" },
+            { AttributeName: "sk", AttributeType: "S" },
+          ],
+          ProvisionedThroughput: { ReadCapacityUnits: 5, WriteCapacityUnits: 5 },
+        }),
+      );
+
+      // Wait for table to be active
+      let active = false;
+      while (!active) {
+        const { Table } = await client.send(new DescribeTableCommand({ TableName: tableName }));
+        if (Table?.TableStatus === "ACTIVE") active = true;
+        else await new Promise((r) => setTimeout(r, 100));
+      }
+
+      await docClient.send(
+        new PutCommand({
+          TableName: tableName,
+          Item: { pk: "USER#1", sk: "METADATA", id: "1", name: "Alice" },
+        }),
+      );
+    } catch {
+      /* ignore */
+    }
+  });
+
+  afterAll(async () => {
+    try {
+      await client.send(new DeleteTableCommand({ TableName: tableName }));
+    } catch {
+      /* ignore */
+    }
+  });
+
+  it("should allow consistentRead on Get", async () => {
+    const result = await mizzle(client)
+      .select()
+      .from(user)
+      .where(eq(user.id, "1"))
+      .consistentRead()
+      .execute();
+    expect(result).toHaveLength(1);
+  });
+
+  it("should allow consistentRead on Query", async () => {
+    const result = await mizzle(client)
+      .select()
+      .from(user)
+      .where(eq(user.id, "1"))
+      .consistentRead()
+      .execute();
+    expect(result).toHaveLength(1);
+  });
+
+  it("should allow consistentRead on Scan", async () => {
+    const result = await mizzle(client).select().from(user).consistentRead().execute();
+    expect(result).toHaveLength(1);
+  });
+
+  it("should respect pageSize hint", async () => {
+    const result = await mizzle(client).select().from(user).pageSize(1).execute();
+    expect(result).toHaveLength(1);
+  });
+
+  it("should yield items via iterator", async () => {
+    const iterator = mizzle(client).select().from(user).iterator();
+    const items = [];
+    for await (const item of iterator) {
+      items.push(item);
+    }
+    expect(items).toHaveLength(1);
+  });
+
+  it("should respect limit in iterator", async () => {
+    // Insert one more item to test limit
+    await docClient.send(
+      new PutCommand({
+        TableName: tableName,
+        Item: { pk: "USER#2", sk: "METADATA", id: "2", name: "Bob" },
+      }),
+    );
+
+    const iterator = mizzle(client).select().from(user).limit(1).iterator();
+    const items = [];
+    for await (const item of iterator) {
+      items.push(item);
+    }
+    expect(items).toHaveLength(1);
+  });
+});

package/test/builders/transaction-errors.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect, vi } from "vitest";
+import { TransactionExecutor } from "@aurios/mizzle/builders/transaction";
+import { TransactionFailedError } from "@aurios/mizzle/core/errors";
+import type { IMizzleClient } from "@aurios/mizzle/core/client";
+
+describe("Transaction Error Parsing", () => {
+  const mockClient = { send: vi.fn() } as unknown as IMizzleClient;
+
+  it("should parse TransactionCanceledException into TransactionFailedError", async () => {
+    const executor = new TransactionExecutor(mockClient);
+
+    const error = new Error("Transaction Canceled") as Error & {
+      name: string;
+      CancellationReasons: { Code: string; Message?: string }[];
+    };
+    error.name = "TransactionCanceledException";
+    error.CancellationReasons = [
+      { Code: "None" },
+      { Code: "ConditionalCheckFailed", Message: "Condition failed" },
+    ];
+
+    vi.mocked(mockClient.send).mockRejectedValueOnce(error);
+
+    try {
+      await executor.execute("token", []);
+      expect.fail("Should have thrown TransactionFailedError");
+    } catch (e) {
+      expect(e).toBeInstanceOf(TransactionFailedError);
+      const txErr = e as TransactionFailedError;
+      expect(txErr.reasons).toHaveLength(1);
+      expect(txErr.reasons[0]).toMatchObject({
+        index: 1,
+        code: "ConditionalCheckFailed",
+        message: "Condition failed",
+      });
+    }
+  });
+
+  it("should rethrow other errors", async () => {
+    const executor = new TransactionExecutor(mockClient);
+    const otherError = new Error("Other error");
+    vi.mocked(mockClient.send).mockRejectedValueOnce(otherError);
+
+    await expect(executor.execute("token", [])).rejects.toThrow("Other error");
+  });
+});

package/test/builders/transaction-execution.test.ts

@@ -0,0 +1,99 @@
+import { describe, it, expect, vi } from "vitest";
+import {
+  TransactionExecutor,
+  ConditionCheckBuilder,
+} from "@aurios/mizzle/builders/transaction";
+import { dynamoTable, dynamoEntity } from "@aurios/mizzle/table";
+import { string, number } from "@aurios/mizzle/columns";
+import type { IMizzleClient } from "@aurios/mizzle/core/client";
+import { mizzle } from "@aurios/mizzle/db";
+import { eq, and } from "@aurios/mizzle/expressions/operators";
+import { add, prefixKey } from "@aurios/mizzle";
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+
+describe("TransactionExecution Mapping", () => {
+  const table = dynamoTable("TestTable", { pk: string("pk"), sk: string("sk") });
+  const user = dynamoEntity(
+    table,
+    "User",
+    { id: string(), name: string(), age: number() },
+    (cols) => ({
+      pk: prefixKey("U#", cols.id),
+      sk: prefixKey("M#", cols.name),
+    }),
+  );
+
+  const rawClient = new DynamoDBClient({ region: "us-east-1" });
+  const mockClient = { send: vi.fn() } as any;
+  const db = mizzle(rawClient);
+  (db as any).docClient = mockClient;
+
+  it("should map InsertBase to Put item", async () => {
+    const executor = new TransactionExecutor(mockClient);
+    const op = db.insert(user).values({ id: "1", name: "Luke", age: 30 });
+
+    const mapped = (executor as any).mapToTransactItem(op);
+
+    expect(mapped).toMatchObject({
+      Put: {
+        TableName: "TestTable",
+        Item: {
+          pk: "U#1",
+          sk: "M#Luke",
+          id: "1",
+          name: "Luke",
+          age: 30,
+        },
+      },
+    });
+  });
+
+  it("should map UpdateBuilder to Update item", async () => {
+    const executor = new TransactionExecutor(mockClient);
+    // Both SET and ADD
+    const op = db
+      .update(user)
+      .set({ name: "Luke Skywalker", age: add(1) })
+      .where(and(eq(user.id, "1"), eq(user.name, "Luke")));
+
+    const mapped = (executor as any).mapToTransactItem(op);
+
+    expect(mapped.Update).toMatchObject({
+      TableName: "TestTable",
+      Key: { pk: "U#1", sk: "M#Luke" },
+    });
+    expect(mapped.Update.UpdateExpression).toContain("SET");
+    expect(mapped.Update.UpdateExpression).toContain("ADD");
+  });
+
+  it("should map DeleteBuilder to Delete item", async () => {
+    const executor = new TransactionExecutor(mockClient);
+    const op = db.delete(user, { id: "1", name: "Luke" });
+
+    const mapped = (executor as any).mapToTransactItem(op);
+
+    expect(mapped).toMatchObject({
+      Delete: {
+        TableName: "TestTable",
+        Key: { pk: "U#1", sk: "M#Luke" },
+      },
+    });
+  });
+
+  it("should map ConditionCheckBuilder to ConditionCheck item", async () => {
+    const executor = new TransactionExecutor(mockClient);
+    const op = new ConditionCheckBuilder(user, mockClient).where(
+      and(eq(user.id, "1"), eq(user.name, "Luke")),
+    );
+
+    const mapped = (executor as any).mapToTransactItem(op);
+
+    expect(mapped).toMatchObject({
+      ConditionCheck: {
+        TableName: "TestTable",
+        Key: { pk: "U#1", sk: "M#Luke" },
+      },
+    });
+    expect(mapped.ConditionCheck.ConditionExpression).toBeDefined();
+  });
+});

package/test/builders/transaction-proxy.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect, vi } from "vitest";
+import {
+  TransactionProxy,
+  ConditionCheckBuilder,
+} from "@aurios/mizzle/builders/transaction";
+import { InsertBuilder } from "@aurios/mizzle/builders/insert";
+import { UpdateBuilder } from "@aurios/mizzle/builders/update";
+import { DeleteBuilder } from "@aurios/mizzle/builders/delete";
+import { dynamoTable, dynamoEntity } from "@aurios/mizzle/table";
+import { string } from "@aurios/mizzle/columns";
+import type { IMizzleClient } from "@aurios/mizzle/core/client";
+
+describe("TransactionProxy", () => {
+  const table = dynamoTable("TestTable", { pk: string("pk") });
+  const user = dynamoEntity(table, "User", { name: string() }, (cols) => ({ pk: cols.name }));
+  const mockClient = { send: vi.fn() } as unknown as IMizzleClient;
+
+  it("should return an InsertBuilder", () => {
+    const tx = new TransactionProxy(mockClient);
+    const builder = tx.insert(user);
+    expect(builder).toBeInstanceOf(InsertBuilder);
+  });
+
+  it("should return an UpdateBuilder", () => {
+    const tx = new TransactionProxy(mockClient);
+    const builder = tx.update(user);
+    expect(builder).toBeInstanceOf(UpdateBuilder);
+  });
+
+  it("should return a DeleteBuilder", () => {
+    const tx = new TransactionProxy(mockClient);
+    const builder = tx.delete(user, { name: "test" });
+    expect(builder).toBeInstanceOf(DeleteBuilder);
+  });
+
+  it("should return a ConditionCheckBuilder", () => {
+    const tx = new TransactionProxy(mockClient);
+    const builder = tx.conditionCheck(user);
+    expect(builder).toBeInstanceOf(ConditionCheckBuilder);
+  });
+});