betterddb 0.3.0 → 0.4.1

package/src/builders/scan-builder.ts

@@ -1,17 +1,18 @@
 import { DynamoDB } from 'aws-sdk';
 import { BetterDDB } from '../betterddb';
+import { z } from 'zod';
 
-export class ScanBuilder<T> {
+export class ScanBuilder<S extends z.ZodType<any>> {
   private filters: string[] = [];
   private expressionAttributeNames: Record<string, string> = {};
   private expressionAttributeValues: Record<string, any> = {};
   private limit?: number;
   private lastKey?: Record<string, any>;
 
-  constructor(private parent: BetterDDB<T>) {}
+  constructor(private parent: BetterDDB<S>) {}
 
   public where(
-    attribute: keyof T,
+    attribute: keyof S,
     operator: 'eq' | 'begins_with' | 'between',
     values: any | [any, any]
   ): this {
@@ -55,7 +56,7 @@ export class ScanBuilder<T> {
   /**
    * Executes the scan and returns a Promise that resolves with an array of items.
    */
-  public async execute(): Promise<T[]> {
+  public async execute(): Promise<S[]> {
     const params: DynamoDB.DocumentClient.ScanInput = {
       TableName: this.parent.getTableName(),
       ExpressionAttributeNames: this.expressionAttributeNames,
@@ -69,22 +70,22 @@ export class ScanBuilder<T> {
     }
 
     const result = await this.parent.getClient().scan(params).promise();
-    return (result.Items || []).map(item => this.parent.getSchema().parse(item));
+    return this.parent.getSchema().array().parse(result.Items);
   }
 
   // Thenable implementation.
-  public then<TResult1 = T[], TResult2 = never>(
-    onfulfilled?: ((value: T[]) => TResult1 | PromiseLike<TResult1>) | null,
+  public then<TResult1 = S[], TResult2 = never>(
+    onfulfilled?: ((value: S[]) => TResult1 | PromiseLike<TResult1>) | null,
     onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
   ): Promise<TResult1 | TResult2> {
     return this.execute().then(onfulfilled, onrejected);
   }
   public catch<TResult = never>(
     onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null
-  ): Promise<T[] | TResult> {
+  ): Promise<S[] | TResult> {
     return this.execute().catch(onrejected);
   }
-  public finally(onfinally?: (() => void) | null): Promise<T[]> {
+  public finally(onfinally?: (() => void) | null): Promise<S[]> {
     return this.execute().finally(onfinally);
   }
 }

package/src/builders/update-builder.ts

@@ -1,43 +1,44 @@
 
 import { DynamoDB } from 'aws-sdk';
 import { BetterDDB } from '../betterddb';
+import { z } from 'zod';
 
-interface UpdateActions<T> {
-  set?: Partial<T>;
-  remove?: (keyof T)[];
-  add?: Partial<Record<keyof T, number | Set<any>>>;
-  delete?: Partial<Record<keyof T, Set<any>>>;
+interface UpdateActions<S extends z.ZodType<any>> {
+  set?: Partial<S>;
+  remove?: (keyof S)[];
+  add?: Partial<Record<keyof S, number | Set<any>>>;
+  delete?: Partial<Record<keyof S, Set<any>>>;
 }
 
-export class UpdateBuilder<T> {
-  private actions: UpdateActions<T> = {};
+export class UpdateBuilder<S extends z.ZodType<any>> {
+  private actions: UpdateActions<S> = {};
   private condition?: { expression: string; attributeValues: Record<string, any> };
   private expectedVersion?: number;
   // When using transaction mode, we store extra transaction items.
   private extraTransactItems: DynamoDB.DocumentClient.TransactWriteItemList = [];
 
   // Reference to the parent BetterDDB instance and key.
-  constructor(private parent: BetterDDB<T>, private key: Partial<T>, expectedVersion?: number) {
+  constructor(private parent: BetterDDB<S>, private key: Partial<S>, expectedVersion?: number) {
     this.expectedVersion = expectedVersion;
   }
 
   // Chainable methods:
-  public set(attrs: Partial<T>): this {
+  public set(attrs: Partial<S>): this {
     this.actions.set = { ...this.actions.set, ...attrs };
     return this;
   }
 
-  public remove(attrs: (keyof T)[]): this {
+  public remove(attrs: (keyof S)[]): this {
     this.actions.remove = [...(this.actions.remove || []), ...attrs];
     return this;
   }
 
-  public add(attrs: Partial<Record<keyof T, number | Set<any>>>): this {
+  public add(attrs: Partial<Record<keyof S, number | Set<any>>>): this {
     this.actions.add = { ...this.actions.add, ...attrs };
     return this;
   }
 
-  public delete(attrs: Partial<Record<keyof T, Set<any>>>): this {
+  public delete(attrs: Partial<Record<keyof S, Set<any>>>): this {
     this.actions.delete = { ...this.actions.delete, ...attrs };
     return this;
   }
@@ -191,7 +192,7 @@ export class UpdateBuilder<T> {
   /**
    * Commits the update immediately by calling the parent's update method.
    */
-  public async execute(): Promise<T> {
+  public async execute(): Promise<S> {
     if (this.extraTransactItems.length > 0) {
       // Build our update transaction item.
       const myTransactItem = this.toTransactUpdate();

package/test/create.test.ts

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import { BetterDDB } from '../src/betterddb';
+import { DynamoDB } from 'aws-sdk';
+import { createTestTable, deleteTestTable } from './utils/table-setup';
+
+const TEST_TABLE = "create-test-table";
+const ENDPOINT = 'http://localhost:4566';
+const REGION = 'us-east-1';
+const ENTITY_NAME = 'USER';
+const PRIMARY_KEY = 'id';
+const PRIMARY_KEY_TYPE = 'S';
+const SORT_KEY = 'email';
+const SORT_KEY_TYPE = 'S';
+const KEY_SCHEMA = [{ AttributeName: PRIMARY_KEY, KeyType: 'HASH' }, { AttributeName: SORT_KEY, KeyType: 'RANGE' }];
+const ATTRIBUTE_DEFINITIONS = [{ AttributeName: PRIMARY_KEY, AttributeType: PRIMARY_KEY_TYPE }, { AttributeName: SORT_KEY, AttributeType: SORT_KEY_TYPE }];
+const client = new DynamoDB.DocumentClient({
+  region: REGION,
+  endpoint: ENDPOINT,
+});
+
+const UserSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  email: z.string().email(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+
+const userDdb = new BetterDDB({
+  schema: UserSchema,
+  tableName: TEST_TABLE,
+  entityName: ENTITY_NAME,
+  keys: {
+    primary: { name: "pk", definition: { build: (raw) => `USER#${raw.id}` } },
+    sort: { name: "sk", definition: { build: (raw) => `EMAIL#${raw.email}` } },
+    gsis: { gsi1: { name: 'gsi1', primary: { name: "gsi1pk", definition: { build: (raw) => "NAME" } }, sort: { name: "gsi1sk", definition: { build: (raw) => `NAME#${raw.name}` } } } },
+  },
+  client,
+  autoTimestamps: true,
+});
+
+beforeAll(async () => {
+  await createTestTable(TEST_TABLE, KEY_SCHEMA, ATTRIBUTE_DEFINITIONS);
+});
+
+afterAll(async () => {
+  await deleteTestTable(TEST_TABLE);
+});
+
+describe('BetterDDB - Create Operation', () => {
+  it('should insert an item using CreateBuilder', async () => {
+    const user = { id: 'user-123', name: 'John Doe', email: 'john@example.com' };
+
+    await userDdb.create(user as any).execute();
+
+    const result = await client.get({ TableName: TEST_TABLE, Key: { id: 'user-123', email: 'john@example.com' } }).promise();
+
+    expect(result).not.toBeNull();
+    expect(result.Item).not.toBeNull();
+    expect(result.Item?.pk).toBe('USER#user-123');
+    expect(result.Item?.sk).toBe('EMAIL#john@example.com');
+    expect(result.Item?.gsi1pk).toBe('NAME');
+    expect(result.Item?.gsi1sk).toBe('NAME#John Doe');
+    expect(result.Item?.id).toBe('user-123');
+    expect(result.Item?.createdAt).not.toBeNull();
+    expect(result.Item?.updatedAt).not.toBeNull();
+  });
+
+  it('should fails to validate and not insert an item', async () => {
+    const user = { id: 'user-123', email: 'john@example.com' };
+    await expect(userDdb.create(user as any).execute()).rejects.toThrow();
+  });
+});

package/test/delete.test.ts

@@ -0,0 +1,58 @@
+// __tests__/delete.test.ts
+import { z } from 'zod';
+import { BetterDDB } from '../src/betterddb';
+import { DynamoDB } from 'aws-sdk';
+import { createTestTable, deleteTestTable } from './utils/table-setup';
+
+const TEST_TABLE = "delete-test-table";
+const ENDPOINT = 'http://localhost:4566';
+const REGION = 'us-east-1';
+const ENTITY_NAME = 'USER';
+const PRIMARY_KEY = 'id';
+const PRIMARY_KEY_TYPE = 'S';
+const SORT_KEY = 'email';
+const SORT_KEY_TYPE = 'S';
+const KEY_SCHEMA = [{ AttributeName: PRIMARY_KEY, KeyType: 'HASH' }, { AttributeName: SORT_KEY, KeyType: 'RANGE' }];
+const ATTRIBUTE_DEFINITIONS = [{ AttributeName: PRIMARY_KEY, AttributeType: PRIMARY_KEY_TYPE }, { AttributeName: SORT_KEY, AttributeType: SORT_KEY_TYPE }];
+const client = new DynamoDB.DocumentClient({
+  region: REGION,
+  endpoint: ENDPOINT,
+});
+
+const UserSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  email: z.string().email(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+
+const userDdb = new BetterDDB({
+  schema: UserSchema,
+  tableName: TEST_TABLE,
+  entityName: ENTITY_NAME,
+  keys: {
+    primary: { name: PRIMARY_KEY, definition: { build: (raw) => raw.id! } },
+    sort: { name: SORT_KEY, definition: { build: (raw) => raw.email! } },
+  },
+  client,
+  autoTimestamps: true,
+});
+
+beforeAll(async () => {
+  await createTestTable(TEST_TABLE, KEY_SCHEMA, ATTRIBUTE_DEFINITIONS);
+  await userDdb.create({ id: 'user-123', name: 'John Doe', email: 'john@example.com' } as any).execute();
+});
+
+afterAll(async () => {
+  await deleteTestTable(TEST_TABLE);
+});
+
+describe('BetterDDB - Delete Operation', () => {
+  it('should delete an item using DeleteBuilder', async () => {
+    await userDdb.delete({ id: 'user-123', email: 'john@example.com' })
+      .execute();
+    const deletedUser = await userDdb.get({ id: 'user-123', email: 'john@example.com' }).execute();
+    expect(deletedUser).toBeNull();
+  });
+});

package/test/get.test.ts

@@ -0,0 +1,58 @@
+// __tests__/get.test.ts
+import { z } from 'zod';
+import { BetterDDB } from '../src/betterddb';
+import { DynamoDB } from 'aws-sdk';
+import { createTestTable, deleteTestTable } from './utils/table-setup';
+
+const TEST_TABLE = "get-test-table";
+const ENDPOINT = 'http://localhost:4566';
+const REGION = 'us-east-1';
+const ENTITY_NAME = 'USER';
+const PRIMARY_KEY = 'id';
+const PRIMARY_KEY_TYPE = 'S';
+const SORT_KEY = 'email';
+const SORT_KEY_TYPE = 'S';
+const KEY_SCHEMA = [{ AttributeName: PRIMARY_KEY, KeyType: 'HASH' }, { AttributeName: SORT_KEY, KeyType: 'RANGE' }];
+const ATTRIBUTE_DEFINITIONS = [{ AttributeName: PRIMARY_KEY, AttributeType: PRIMARY_KEY_TYPE }, { AttributeName: SORT_KEY, AttributeType: SORT_KEY_TYPE }];
+const client = new DynamoDB.DocumentClient({
+  region: REGION,
+  endpoint: ENDPOINT,
+});
+
+
+const UserSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  email: z.string().email(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+
+const userDdb = new BetterDDB({
+  schema: UserSchema,
+  tableName: TEST_TABLE,
+  entityName: ENTITY_NAME,
+  keys: {
+    primary: { name: PRIMARY_KEY, definition: { build: (raw) => raw.id! } },
+    sort: { name: SORT_KEY, definition: { build: (raw) => raw.email! } },
+  },
+  client,
+  autoTimestamps: true,
+});
+
+beforeAll(async () => {
+  await createTestTable(TEST_TABLE, KEY_SCHEMA, ATTRIBUTE_DEFINITIONS);
+  await userDdb.create({ id: 'user-123', name: 'John Doe', email: 'john@example.com' } as any).execute();
+});
+
+afterAll(async () => {
+  await deleteTestTable(TEST_TABLE);
+});
+
+describe('BetterDDB - Get Operation', () => {
+  it('should retrieve an item using GetBuilder', async () => {
+    const user = await userDdb.get({ id: 'user-123', email: 'john@example.com' }).execute();
+    expect(user).not.toBeNull();
+    expect(user?.id).toBe('user-123');
+  });
+});

package/test/query.test.ts

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import { BetterDDB } from '../src/betterddb';
+import { DynamoDB } from 'aws-sdk';
+import { createTestTable, deleteTestTable } from './utils/table-setup';
+
+const TEST_TABLE = "query-test-table";
+const ENDPOINT = 'http://localhost:4566';
+const REGION = 'us-east-1';
+const ENTITY_NAME = 'USER';
+const PRIMARY_KEY = 'id';
+const PRIMARY_KEY_TYPE = 'S';
+const SORT_KEY = 'email';
+const SORT_KEY_TYPE = 'S';
+const KEY_SCHEMA = [{ AttributeName: PRIMARY_KEY, KeyType: 'HASH' }, { AttributeName: SORT_KEY, KeyType: 'RANGE' }];
+const ATTRIBUTE_DEFINITIONS = [{ AttributeName: PRIMARY_KEY, AttributeType: PRIMARY_KEY_TYPE }, { AttributeName: SORT_KEY, AttributeType: SORT_KEY_TYPE }];
+const client = new DynamoDB.DocumentClient({
+  region: REGION,
+  endpoint: ENDPOINT,
+});
+
+const UserSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  email: z.string().email(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+
+const userDdb = new BetterDDB({
+  schema: UserSchema,
+  tableName: TEST_TABLE,
+  entityName: ENTITY_NAME,
+  keys: {
+    primary: { name: PRIMARY_KEY, definition: PRIMARY_KEY },
+    gsis: {
+      EmailIndex: {
+        name: 'EmailIndex',
+        primary: { name: 'email', definition: 'email' }
+      }
+    }
+  },
+  client,
+  autoTimestamps: true,
+});
+
+beforeAll(async () => {
+  await createTestTable(TEST_TABLE, KEY_SCHEMA, ATTRIBUTE_DEFINITIONS);
+  // Insert multiple items.
+  const items = [
+    { id: 'user-1', name: 'Alice', email: 'alice@example.com' },
+    { id: 'user-2', name: 'Alice B', email: 'alice@example.com' },
+    { id: 'user-3', name: 'Bob', email: 'bob@example.com' }
+  ];
+  for (const item of items) {
+    await userDdb.create(item as any).execute();
+  }
+});
+
+afterAll(async () => {
+  await deleteTestTable(TEST_TABLE);
+});
+
+describe('BetterDDB - Query Operation', () => {
+  it('should query items using QueryBuilder', async () => {
+    const results = await userDdb.query({ id: 'user-1' })
+      .where('name', 'begins_with', 'Alice')
+      .limitResults(5);
+    expect(results.length).toBeGreaterThanOrEqual(1);
+    results.forEach(result => {
+      expect(result.name).toMatch(/^Alice/);
+    });
+  });
+});

package/test/scan.test.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { BetterDDB } from '../src/betterddb';
+import { DynamoDB } from 'aws-sdk';
+import { createTestTable, deleteTestTable } from './utils/table-setup';
+
+const TEST_TABLE = "scan-test-table";
+const ENDPOINT = 'http://localhost:4566';
+const REGION = 'us-east-1';
+const ENTITY_NAME = 'USER';
+const PRIMARY_KEY = 'id';
+const PRIMARY_KEY_TYPE = 'S';
+const SORT_KEY = 'email';
+const SORT_KEY_TYPE = 'S';
+const KEY_SCHEMA = [{ AttributeName: PRIMARY_KEY, KeyType: 'HASH' }, { AttributeName: SORT_KEY, KeyType: 'RANGE' }];
+const ATTRIBUTE_DEFINITIONS = [{ AttributeName: PRIMARY_KEY, AttributeType: PRIMARY_KEY_TYPE }, { AttributeName: SORT_KEY, AttributeType: SORT_KEY_TYPE }];
+const client = new DynamoDB.DocumentClient({
+  region: REGION,
+  endpoint: ENDPOINT,
+});
+
+const UserSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  email: z.string().email(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+
+const userDdb = new BetterDDB({
+  schema: UserSchema,
+  tableName: TEST_TABLE,
+  entityName: ENTITY_NAME,
+  keys: {
+    primary: { name: PRIMARY_KEY, definition: PRIMARY_KEY },
+  },
+  client,
+  autoTimestamps: true,
+});
+
+beforeAll(async () => {
+  await createTestTable(TEST_TABLE, KEY_SCHEMA, ATTRIBUTE_DEFINITIONS);
+  // Insert multiple items.
+  const items = [
+    { id: 'user-4', name: 'Charlie', email: 'charlie@example.com' },
+    { id: 'user-5', name: 'Dave', email: 'dave@example.com' }
+  ];
+  for (const item of items) {
+    await userDdb.create(item as any).execute();
+  }
+});
+
+afterAll(async () => {
+  await deleteTestTable(TEST_TABLE);
+});
+
+describe('BetterDDB - Scan Operation', () => {
+  it('should scan items using ScanBuilder', async () => {
+    const results = await userDdb.scan()
+      .where('email', 'begins_with', 'char')
+      .limitResults(10);
+    expect(results.length).toBeGreaterThanOrEqual(1);
+    results.forEach(result => {
+      expect(result.email).toMatch(/^char/i);
+    });
+  });
+});

package/test/update.test.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { BetterDDB } from '../src/betterddb';
+import { DynamoDB } from 'aws-sdk';
+import { createTestTable, deleteTestTable } from './utils/table-setup';
+
+const TEST_TABLE = "update-test-table";
+const ENDPOINT = 'http://localhost:4566';
+const REGION = 'us-east-1';
+const ENTITY_NAME = 'USER';
+const PRIMARY_KEY = 'id';
+const PRIMARY_KEY_TYPE = 'S';
+const SORT_KEY = 'email';
+const SORT_KEY_TYPE = 'S';
+const KEY_SCHEMA = [{ AttributeName: PRIMARY_KEY, KeyType: 'HASH' }, { AttributeName: SORT_KEY, KeyType: 'RANGE' }];
+const ATTRIBUTE_DEFINITIONS = [{ AttributeName: PRIMARY_KEY, AttributeType: PRIMARY_KEY_TYPE }, { AttributeName: SORT_KEY, AttributeType: SORT_KEY_TYPE }];
+const client = new DynamoDB.DocumentClient({
+  region: REGION,
+  endpoint: ENDPOINT,
+});
+
+
+const UserSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  email: z.string().email(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  version: z.number().optional(),
+});
+
+const userDdb = new BetterDDB({
+  schema: UserSchema,
+  tableName: TEST_TABLE,
+  entityName: ENTITY_NAME,
+  keys: {
+    primary: { name: PRIMARY_KEY, definition: { build: (raw) => raw.id! } },
+    sort: { name: SORT_KEY, definition: { build: (raw) => raw.email! } },
+  },
+  client,
+  autoTimestamps: true,
+});
+
+beforeAll(async () => {
+  await createTestTable(TEST_TABLE, KEY_SCHEMA, ATTRIBUTE_DEFINITIONS);
+  await userDdb.create({ id: 'user-123', name: 'John Doe', email: 'john@example.com' } as any).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');
+  });
+});

package/test/utils/table-setup.ts

@@ -0,0 +1,55 @@
+import { DynamoDB } from 'aws-sdk';
+
+export const createTestTable = async (tableName: string, keySchema: DynamoDB.CreateTableInput['KeySchema'], attributeDefinitions: DynamoDB.CreateTableInput['AttributeDefinitions']) => {
+  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',
+    }).promise();
+  } catch (error: any) {
+    if (error.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 60 seconds
+    const { Table } = await dynamoDB.describeTable({ TableName: tableName }).promise();
+    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, 1000));
+    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 }).promise();
+  } catch (error: any) {
+    if (error.code === 'ResourceNotFoundException') {
+      console.log('Table not found during deletion.');
+    } else {
+      throw error;
+    }
+  }
+};

package/test/placeholder.test.ts

@@ -1,99 +0,0 @@
-import { z } from 'zod';
-import { BetterDDB } from '../src/betterddb';
-import { DynamoDB } from 'aws-sdk';
-
-const TEST_TABLE = 'TestTable';
-
-// LocalStack Configuration
-const client = new DynamoDB.DocumentClient({
-  region: 'us-east-1',
-  endpoint: 'http://localhost:4566'
-});
-
-// Table Schema
-const UserSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  email: z.string().email(),
-  createdAt: z.string(),
-  updatedAt: z.string()
-});
-
-const userDal = new BetterDDB({
-  schema: UserSchema,
-  tableName: TEST_TABLE,
-  keys: {
-    primary: { name: 'pk', definition: 'id' }
-  },
-  entityName: 'USER',
-  client,
-  autoTimestamps: true
-});
-
-beforeAll(async () => {
-  const dynamoDB = new DynamoDB({
-    region: 'us-east-1',
-    endpoint: 'http://localhost:4566'
-  });
-
-  console.log('Creating DynamoDB table in LocalStack...');
-
-  await dynamoDB.createTable({
-    TableName: TEST_TABLE,
-    KeySchema: [{ AttributeName: 'pk', KeyType: 'HASH' }],
-    AttributeDefinitions: [{ AttributeName: 'pk', AttributeType: 'S' }],
-    BillingMode: 'PAY_PER_REQUEST'
-  }).promise();
-
-  // Wait for the table to become active
-  while (true) {
-    const { Table } = await dynamoDB.describeTable({ TableName: TEST_TABLE }).promise();
-    if (Table?.TableStatus === 'ACTIVE') {
-      console.log('DynamoDB table is ready.');
-      break;
-    }
-    console.log('Waiting for table to become ACTIVE...');
-    await new Promise(res => setTimeout(res, 1000)); // Wait 1 sec before retrying
-  }
-});
-
-afterAll(async () => {
-  // Cleanup: delete the table
-  const dynamoDB = new DynamoDB({
-    region: 'us-east-1',
-    endpoint: 'http://localhost:4566'
-  });
-
-  await dynamoDB.deleteTable({ TableName: TEST_TABLE }).promise();
-});
-
-describe('BetterDDB - Integration Tests', () => {
-  it('should insert an item into DynamoDB', async () => {
-    const user = {
-      id: 'user-123',
-      name: 'John Doe',
-      email: 'john@example.com'
-    };
-
-    const createdUser = await userDal.create(user as any).execute();
-    expect(createdUser).toHaveProperty('createdAt');
-    expect(createdUser).toHaveProperty('updatedAt');
-  });
-
-  it('should retrieve an item by ID', async () => {
-    const user = await userDal.get({ id: 'user-123' }).execute();
-    expect(user).not.toBeNull();
-    expect(user?.id).toBe('user-123');
-  });
-
-  it('should update an existing item', async () => {
-    const updatedUser = await userDal.update({ id: 'user-123' }).set({ name: 'Jane Doe' }).execute();
-    expect(updatedUser.name).toBe('Jane Doe');
-  });
-
-  it('should delete an item', async () => {
-    await userDal.delete({ id: 'user-123' }).execute();
-    const deletedUser = await userDal.get({ id: 'user-123' }).execute();
-    expect(deletedUser).toBeNull();
-  });
-});