betterddb 0.8.0 → 0.8.2

package/test/update.test.ts

@@ -1,355 +0,0 @@
-import { z } from "zod";
-import { BetterDDB } from "../src/betterddb";
-import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
-import { createTestTable, deleteTestTable } from "./utils/table-setup";
-import {
-  DynamoDB,
-  GlobalSecondaryIndex,
-  AttributeValue,
-} from "@aws-sdk/client-dynamodb";
-import {
-  KeySchemaElement,
-  AttributeDefinition,
-} from "@aws-sdk/client-dynamodb";
-const TEST_TABLE = "update-test-table";
-const ENDPOINT = "http://localhost:4566";
-const REGION = "us-east-1";
-const ENTITY_TYPE = "USER";
-const PRIMARY_KEY = "pk";
-const PRIMARY_KEY_TYPE = "S";
-const SORT_KEY = "sk";
-const SORT_KEY_TYPE = "S";
-const GSI_NAME = "EmailIndex";
-const GSI_PRIMARY_KEY = "gsi1pk";
-const GSI_SORT_KEY = "gsi1sk";
-const KEY_SCHEMA = [
-  { AttributeName: PRIMARY_KEY, KeyType: "HASH" },
-  { AttributeName: SORT_KEY, KeyType: "RANGE" },
-] as KeySchemaElement[];
-const ATTRIBUTE_DEFINITIONS = [
-  { AttributeName: PRIMARY_KEY, AttributeType: PRIMARY_KEY_TYPE },
-  { AttributeName: SORT_KEY, AttributeType: SORT_KEY_TYPE },
-  { AttributeName: GSI_PRIMARY_KEY, AttributeType: PRIMARY_KEY_TYPE },
-  { AttributeName: GSI_SORT_KEY, AttributeType: SORT_KEY_TYPE },
-] as AttributeDefinition[];
-const GSIS = [
-  {
-    IndexName: GSI_NAME,
-    KeySchema: [
-      { AttributeName: GSI_PRIMARY_KEY, KeyType: "HASH" },
-      { AttributeName: GSI_SORT_KEY, KeyType: "RANGE" },
-    ],
-    Projection: {
-      ProjectionType: "ALL",
-    },
-  },
-] as GlobalSecondaryIndex[];
-const client = DynamoDBDocumentClient.from(
-  new DynamoDB({
-    region: REGION,
-    endpoint: ENDPOINT,
-  }),
-);
-
-const UserSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  email: z.string().email(),
-  nickname: z.string().optional(),
-  points: z.number().optional(),
-  tags: z.set(z.string()).optional(),
-});
-
-type User = z.infer<typeof UserSchema>;
-
-const userDdb = new BetterDDB<User>({
-  schema: UserSchema,
-  tableName: TEST_TABLE,
-  entityType: ENTITY_TYPE,
-  keys: {
-    primary: { name: PRIMARY_KEY, definition: { build: (raw) => raw.id! } },
-    sort: { name: SORT_KEY, definition: { build: (raw) => raw.email! } },
-    gsis: {
-      EmailIndex: {
-        name: GSI_NAME,
-        primary: {
-          name: GSI_PRIMARY_KEY,
-          definition: { build: (raw) => "EMAIL" },
-        },
-        sort: {
-          name: GSI_SORT_KEY,
-          definition: { build: (raw) => `EMAIL#${raw.email}` },
-        },
-      },
-    },
-  },
-  client,
-  timestamps: true,
-});
-
-beforeAll(async () => {
-  await createTestTable(TEST_TABLE, KEY_SCHEMA, ATTRIBUTE_DEFINITIONS, GSIS);
-});
-
-beforeEach(async () => {
-  const initialUser: User = {
-    id: "user-123",
-    name: "John Doe",
-    email: "john@example.com",
-  };
-  await userDdb.create(initialUser).execute();
-});
-
-afterEach(async () => {
-  await userDdb.delete({ id: "user-123", email: "john@example.com" }).execute();
-});
-
-afterAll(async () => {
-  await deleteTestTable(TEST_TABLE);
-});
-
-describe("BetterDDB - Update Operation", () => {
-  it("should update an existing item using UpdateBuilder", async () => {
-    const updatedUser = await userDdb
-      .update({ id: "user-123", email: "john@example.com" })
-      .set({ name: "Jane Doe" })
-      .execute();
-    expect(updatedUser.name).toBe("Jane Doe");
-    expect(updatedUser.email).toBe("john@example.com");
-  });
-
-  it("should add optional attributes and remove them", async () => {
-    // First add the optional attribute
-    await userDdb
-      .update({ id: "user-123", email: "john@example.com" })
-      .set({ points: 10, name: "John Doe" }) // Maintain required field
-      .execute();
-
-    // Then remove it
-    const updatedUser = await userDdb
-      .update({ id: "user-123", email: "john@example.com" })
-      .remove(["points"])
-      .execute();
-
-    expect(updatedUser.points).toBeUndefined();
-    expect(updatedUser.name).toBe("John Doe"); // Required field remains
-    expect(updatedUser.email).toBe("john@example.com"); // Required field remains
-  });
-
-  it("should add to a number attribute", async () => {
-    // First set initial value with all required fields
-    await userDdb
-      .update({ id: "user-123", email: "john@example.com" })
-      .set({ points: 10, name: "John Doe" })
-      .execute();
-
-    // Then add to it
-    const updatedUser = await userDdb
-      .update({ id: "user-123", email: "john@example.com" })
-      .add({ points: 5 })
-      .execute();
-
-    expect(updatedUser.points).toBe(15);
-    expect(updatedUser.name).toBe("John Doe"); // Required field remains
-    expect(updatedUser.email).toBe("john@example.com"); // Required field remains
-  });
-
-  it("should add and remove from a set attribute", async () => {
-    // First set initial value with all required fields
-    await userDdb
-      .update({ id: "user-123", email: "john@example.com" })
-      .set({ tags: new Set(["tag1"]), name: "John Doe" })
-      .execute();
-
-    // Add to set
-    let updatedUser = await userDdb
-      .update({ id: "user-123", email: "john@example.com" })
-      .add({ tags: new Set(["tag2"]) })
-      .execute();
-
-    expect(updatedUser.tags).toEqual(new Set(["tag1", "tag2"]));
-    expect(updatedUser.name).toBe("John Doe"); // Required field remains
-    expect(updatedUser.email).toBe("john@example.com"); // Required field remains
-
-    // Delete from set
-    updatedUser = await userDdb
-      .update({ id: "user-123", email: "john@example.com" })
-      .delete({ tags: new Set(["tag1"]) })
-      .execute();
-
-    expect(updatedUser.tags).toEqual(new Set(["tag2"]));
-    expect(updatedUser.name).toBe("John Doe"); // Required field remains
-    expect(updatedUser.email).toBe("john@example.com"); // Required field remains
-  });
-
-  it("should perform conditional updates", async () => {
-    // Update only if name matches
-    const updatedUser = await userDdb
-      .update({ id: "user-123", email: "john@example.com" })
-      .set({ name: "John Smith" })
-      .setCondition(
-        "#n = :n",
-        {
-          ":n": "John Doe",
-        },
-        {
-          "#n": "name",
-        },
-      )
-      .execute();
-
-    expect(updatedUser.name).toBe("John Smith");
-    expect(updatedUser.email).toBe("john@example.com"); // Required field remains
-  });
-
-  it("should fail conditional updates when condition is not met", async () => {
-    await expect(
-      userDdb
-        .update({ id: "user-123", email: "john@example.com" })
-        .set({ name: "John Smith" })
-        .setCondition(
-          "#n = :n",
-          {
-            ":n": "Wrong Name",
-          },
-          {
-            "#n": "name",
-          },
-        )
-        .execute(),
-    ).rejects.toThrow();
-  });
-
-  it("should perform transaction updates", async () => {
-    // Create another user for the transaction
-    const newUser: User = {
-      id: "user-456",
-      name: "Alice",
-      email: "alice@example.com",
-    };
-    await userDdb.create(newUser).execute();
-
-    // Create a second update builder for the transaction
-    const secondUpdate = await userDdb
-      .update({ id: "user-456", email: "alice@example.com" })
-      .set({ name: "Alice Updated" })
-      .toTransactUpdate();
-
-    // Update both users in a transaction
-    const updatedUser = await userDdb
-      .update({ id: "user-123", email: "john@example.com" })
-      .set({ name: "John Updated" })
-      .transactWrite(secondUpdate)
-      .execute();
-
-    expect(updatedUser.name).toBe("John Updated");
-    expect(updatedUser.email).toBe("john@example.com"); // Required field remains
-
-    // Verify the other user was updated
-    const otherUser = await userDdb
-      .get({ id: "user-456", email: "alice@example.com" })
-      .execute();
-    expect(otherUser?.name).toBe("Alice Updated");
-    expect(otherUser?.email).toBe("alice@example.com"); // Required field remains
-  });
-
-  it("should fail validation when setting invalid values", async () => {
-    // This should fail at schema validation level
-    const builder = userDdb.update({
-      id: "user-123",
-      email: "john@example.com",
-    });
-
-    // The validation should happen immediately when setting invalid values
-    expect(() => builder.set({ email: "invalid-email" })).toThrow(z.ZodError);
-
-    // Verify the error message
-    try {
-      builder.set({ email: "invalid-email" });
-      fail("Should have thrown a validation error");
-    } catch (error) {
-      if (error instanceof z.ZodError) {
-        expect(error.errors[0].message).toBe("Invalid email");
-      } else {
-        fail("Expected ZodError");
-      }
-    }
-  });
-
-  it("should fail when updating non-existent item", async () => {
-    await expect(
-      userDdb
-        .update({ id: "non-existent", email: "none@example.com" })
-        .set({ name: "New Name" })
-        .execute(),
-    ).rejects.toThrow();
-  });
-
-  it("should update index attributes when modifying indexed fields", async () => {
-    // First verify the initial state
-    const initialUser = await userDdb
-      .get({ id: "user-123", email: "john@example.com" })
-      .execute();
-    expect(initialUser).toBeTruthy();
-
-    // Update the email which should trigger index updates
-    const updatedUser = await userDdb
-      .update({ id: "user-123", email: "john@example.com" })
-      .set({ email: "john.updated@example.com" })
-      .execute();
-
-    // Verify the main attributes were updated
-    expect(updatedUser.email).toBe("john.updated@example.com");
-    expect(updatedUser.name).toBe("John Doe"); // Required field remains
-
-    // Verify the index attributes were updated
-    expect(updatedUser.email).toBe("john.updated@example.com");
-
-    // Verify we can query using the new index values
-    const queriedUser = await userDdb
-      .query({ email: "john.updated@example.com" })
-      .usingIndex(GSI_NAME)
-      .where("==", { email: "john.updated@example.com" })
-      .execute();
-    expect(queriedUser.items).toHaveLength(1);
-    expect(queriedUser.items[0].id).toBe("user-123");
-  });
-
-  it("should automatically convert empty strings and undefined to remove operations", async () => {
-    // First set initial values
-    await userDdb
-      .update({ id: "user-123", email: "john@example.com" })
-      .set({ name: "John Doe", points: 10, nickname: "John" })
-      .execute();
-
-    // Update with a mix of values - some to set, some to remove
-    const updatedUser = await userDdb
-      .update({ id: "user-123", email: "john@example.com" })
-      .set({
-        name: "", // Should trigger remove
-        points: undefined, // Should trigger remove
-        nickname: "", // Should trigger remove
-        email: "john@example.com", // Should remain (required field)
-      })
-      .execute();
-
-    // Fields should be removed, not null or undefined
-    expect(updatedUser.name).toBe(""); // Removed due to empty string
-    expect(updatedUser.points).toBeUndefined(); // Removed due to undefined
-    expect(updatedUser.nickname).toBeUndefined(); // Removed due to empty string
-    expect(updatedUser.email).toBe("john@example.com"); // Required field remains
-
-    // Now let's verify we can still set values normally
-    const finalUser = await userDdb
-      .update({ id: "user-123", email: "john@example.com" })
-      .set({
-        name: "New Name", // Should be set
-        points: 20, // Should be set
-      })
-      .execute();
-
-    expect(finalUser.name).toBe("New Name");
-    expect(finalUser.points).toBe(20);
-    expect(finalUser.email).toBe("john@example.com");
-  });
-});

package/test/utils/table-setup.ts

@@ -1,62 +0,0 @@
-import { CreateTableCommandInput, DynamoDB } from "@aws-sdk/client-dynamodb";
-
-export const createTestTable = async (
-  tableName: string,
-  keySchema: CreateTableCommandInput["KeySchema"],
-  attributeDefinitions: CreateTableCommandInput["AttributeDefinitions"],
-  gsis: CreateTableCommandInput["GlobalSecondaryIndexes"],
-) => {
-  const dynamoDB = new DynamoDB({
-    region: "us-east-1",
-    endpoint: "http://localhost:4566",
-  });
-
-  console.log("Creating DynamoDB table in LocalStack...");
-
-  try {
-    await dynamoDB.createTable({
-      TableName: tableName,
-      KeySchema: keySchema,
-      AttributeDefinitions: attributeDefinitions,
-      BillingMode: "PAY_PER_REQUEST",
-      GlobalSecondaryIndexes: gsis,
-    });
-  } catch (error: unknown) {
-    if ((error as { code?: string }).code === "ResourceInUseException") {
-      console.log("Table already exists, skipping creation.");
-    } else {
-      throw error;
-    }
-  }
-
-  // Wait for the table to become active.
-  let attempts = 0;
-  while (attempts < 60) {
-    // wait up to 15 seconds
-    const { Table } = await dynamoDB.describeTable({ TableName: tableName });
-    if (Table?.TableStatus === "ACTIVE") {
-      console.log("DynamoDB table is ready.");
-      return;
-    }
-    console.log("Waiting for table to become ACTIVE...");
-    await new Promise((res) => setTimeout(res, 250));
-    attempts++;
-  }
-  throw new Error("Table did not become active in time.");
-};
-
-export const deleteTestTable = async (tableName: string) => {
-  const dynamoDB = new DynamoDB({
-    region: "us-east-1",
-    endpoint: "http://localhost:4566",
-  });
-  try {
-    await dynamoDB.deleteTable({ TableName: tableName });
-  } catch (error: unknown) {
-    if ((error as { code?: string }).code === "ResourceNotFoundException") {
-      console.log("Table not found during deletion.");
-    } else {
-      throw error;
-    }
-  }
-};

package/tsconfig.json

@@ -1,23 +0,0 @@
-{
-  "compilerOptions": {
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "target": "es2022",
-    "allowJs": true,
-    "resolveJsonModule": true,
-    "moduleDetection": "force",
-    "isolatedModules": true,
-    "verbatimModuleSyntax": true,
-    "strict": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-    "module": "NodeNext",
-    "outDir": "dist",
-    "sourceMap": true,
-    "composite": true,
-    "declarationMap": true,
-    "rootDir": "."
-  },
-  "include": ["src/**/*", "test/**/*"],
-  "exclude": ["node_modules", "dist"]
-}