betterddb 0.2.0 → 0.4.0

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(),
+}).passthrough();
+
+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(),
+}).passthrough();
+
+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(),
+}).passthrough();
+
+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(),
+}).passthrough();
+
+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(),
+}).passthrough();
+
+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,98 +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' }
-  },
-  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);
-    expect(createdUser).toHaveProperty('createdAt');
-    expect(createdUser).toHaveProperty('updatedAt');
-  });
-
-  it('should retrieve an item by ID', async () => {
-    const user = await userDal.get({ id: 'user-123' });
-    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' }, { name: 'Jane Doe' });
-    expect(updatedUser.name).toBe('Jane Doe');
-  });
-
-  it('should delete an item', async () => {
-    await userDal.delete({ id: 'user-123' });
-    const deletedUser = await userDal.get({ id: 'user-123' });
-    expect(deletedUser).toBeNull();
-  });
-});