@ftschopp/dynatable-core 1.4.2 → 1.4.3

package/src/builders/get/create-get-builder.test.ts

@@ -1,272 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
-import { GetCommand } from '@aws-sdk/lib-dynamodb';
-import { createGetBuilder } from './create-get-builder';
-import { mockClient } from 'aws-sdk-client-mock';
-
-const ddbMock = mockClient(DynamoDBClient);
-
-type TestUser = {
-  username: string;
-  email: string;
-  name: string;
-  status: string;
-  age: number;
-};
-
-describe('GetBuilder', () => {
-  let client: DynamoDBClient;
-
-  beforeEach(() => {
-    ddbMock.reset();
-    client = new DynamoDBClient({});
-  });
-
-  describe('ProjectionExpression with ExpressionAttributeNames', () => {
-    it('should use ExpressionAttributeNames for simple attributes', () => {
-      const builder = createGetBuilder<any, TestUser>(
-        'TestTable',
-        { PK: 'USER#alice', SK: 'USER#alice' },
-        client
-      );
-
-      const params = builder.select(['username', 'email']).dbParams();
-
-      expect(params.ProjectionExpression).toBe('#username, #email');
-      expect(params.ExpressionAttributeNames).toEqual({
-        '#username': 'username',
-        '#email': 'email',
-      });
-    });
-
-    it('should handle reserved words correctly', () => {
-      const builder = createGetBuilder<any, TestUser>(
-        'TestTable',
-        { PK: 'USER#alice', SK: 'USER#alice' },
-        client
-      );
-
-      // 'name' and 'status' are DynamoDB reserved words
-      const params = builder.select(['name', 'status']).dbParams();
-
-      expect(params.ProjectionExpression).toBe('#name, #status');
-      expect(params.ExpressionAttributeNames).toEqual({
-        '#name': 'name',
-        '#status': 'status',
-      });
-    });
-
-    it('should work with mixed reserved and non-reserved words', () => {
-      const builder = createGetBuilder<any, TestUser>(
-        'TestTable',
-        { PK: 'USER#alice', SK: 'USER#alice' },
-        client
-      );
-
-      const params = builder.select(['username', 'name', 'status', 'email']).dbParams();
-
-      expect(params.ProjectionExpression).toBe('#username, #name, #status, #email');
-      expect(params.ExpressionAttributeNames).toEqual({
-        '#username': 'username',
-        '#name': 'name',
-        '#status': 'status',
-        '#email': 'email',
-      });
-    });
-
-    it('should not add ExpressionAttributeNames when no projection', () => {
-      const builder = createGetBuilder<any, TestUser>(
-        'TestTable',
-        { PK: 'USER#alice', SK: 'USER#alice' },
-        client
-      );
-
-      const params = builder.dbParams();
-
-      expect(params.ProjectionExpression).toBeUndefined();
-      expect(params.ExpressionAttributeNames).toBeUndefined();
-    });
-  });
-
-  describe('returnConsumedCapacity()', () => {
-    it('should add ReturnConsumedCapacity with TOTAL', () => {
-      const builder = createGetBuilder<any, TestUser>(
-        'TestTable',
-        { PK: 'USER#alice', SK: 'USER#alice' },
-        client
-      );
-
-      const params = builder.returnConsumedCapacity('TOTAL').dbParams();
-
-      expect(params.ReturnConsumedCapacity).toBe('TOTAL');
-    });
-
-    it('should add ReturnConsumedCapacity with INDEXES', () => {
-      const builder = createGetBuilder<any, TestUser>(
-        'TestTable',
-        { PK: 'USER#alice', SK: 'USER#alice' },
-        client
-      );
-
-      const params = builder.returnConsumedCapacity('INDEXES').dbParams();
-
-      expect(params.ReturnConsumedCapacity).toBe('INDEXES');
-    });
-
-    it('should add ReturnConsumedCapacity with NONE', () => {
-      const builder = createGetBuilder<any, TestUser>(
-        'TestTable',
-        { PK: 'USER#alice', SK: 'USER#alice' },
-        client
-      );
-
-      const params = builder.returnConsumedCapacity('NONE').dbParams();
-
-      expect(params.ReturnConsumedCapacity).toBe('NONE');
-    });
-
-    it('should not add ReturnConsumedCapacity when not specified', () => {
-      const builder = createGetBuilder<any, TestUser>(
-        'TestTable',
-        { PK: 'USER#alice', SK: 'USER#alice' },
-        client
-      );
-
-      const params = builder.dbParams();
-
-      expect(params.ReturnConsumedCapacity).toBeUndefined();
-    });
-  });
-
-  describe('Method chaining with immutability', () => {
-    it('should chain select() and returnConsumedCapacity()', () => {
-      const builder = createGetBuilder<any, TestUser>(
-        'TestTable',
-        { PK: 'USER#alice', SK: 'USER#alice' },
-        client
-      );
-
-      const params = builder
-        .select(['username', 'email'])
-        .returnConsumedCapacity('TOTAL')
-        .dbParams();
-
-      expect(params.ProjectionExpression).toBe('#username, #email');
-      expect(params.ExpressionAttributeNames).toEqual({
-        '#username': 'username',
-        '#email': 'email',
-      });
-      expect(params.ReturnConsumedCapacity).toBe('TOTAL');
-    });
-
-    it('should chain consistentRead() and returnConsumedCapacity()', () => {
-      const builder = createGetBuilder<any, TestUser>(
-        'TestTable',
-        { PK: 'USER#alice', SK: 'USER#alice' },
-        client
-      );
-
-      const params = builder.consistentRead().returnConsumedCapacity('INDEXES').dbParams();
-
-      expect(params.ConsistentRead).toBe(true);
-      expect(params.ReturnConsumedCapacity).toBe('INDEXES');
-    });
-
-    it('should chain all methods together', () => {
-      const builder = createGetBuilder<any, TestUser>(
-        'TestTable',
-        { PK: 'USER#alice', SK: 'USER#alice' },
-        client
-      );
-
-      const params = builder
-        .select(['name', 'status'])
-        .consistentRead()
-        .returnConsumedCapacity('TOTAL')
-        .dbParams();
-
-      expect(params.ProjectionExpression).toBe('#name, #status');
-      expect(params.ExpressionAttributeNames).toEqual({
-        '#name': 'name',
-        '#status': 'status',
-      });
-      expect(params.ConsistentRead).toBe(true);
-      expect(params.ReturnConsumedCapacity).toBe('TOTAL');
-    });
-
-    it('should maintain immutability - original builder unchanged', () => {
-      const builder = createGetBuilder<any, TestUser>(
-        'TestTable',
-        { PK: 'USER#alice', SK: 'USER#alice' },
-        client
-      );
-
-      const builder2 = builder.select(['username']);
-      const builder3 = builder2.returnConsumedCapacity('TOTAL');
-
-      // Original builder should not have projection
-      const params1 = builder.dbParams();
-      expect(params1.ProjectionExpression).toBeUndefined();
-      expect(params1.ReturnConsumedCapacity).toBeUndefined();
-
-      // Builder2 should have projection but not returnConsumedCapacity
-      const params2 = builder2.dbParams();
-      expect(params2.ProjectionExpression).toBe('#username');
-      expect(params2.ReturnConsumedCapacity).toBeUndefined();
-
-      // Builder3 should have both
-      const params3 = builder3.dbParams();
-      expect(params3.ProjectionExpression).toBe('#username');
-      expect(params3.ReturnConsumedCapacity).toBe('TOTAL');
-    });
-  });
-
-  describe('execute()', () => {
-    it('should send GetCommand with correct parameters', async () => {
-      ddbMock.on(GetCommand).resolves({
-        Item: { username: 'alice', email: 'alice@example.com' },
-      });
-
-      const builder = createGetBuilder<any, TestUser>(
-        'TestTable',
-        { PK: 'USER#alice', SK: 'USER#alice' },
-        client
-      );
-
-      const result = await builder
-        .select(['username', 'email'])
-        .returnConsumedCapacity('TOTAL')
-        .execute();
-
-      expect(result).toEqual({ username: 'alice', email: 'alice@example.com' });
-
-      // Verify the command was called with correct params
-      const calls = ddbMock.commandCalls(GetCommand);
-      expect(calls).toHaveLength(1);
-      expect(calls[0]?.args[0]?.input).toMatchObject({
-        TableName: 'TestTable',
-        Key: { PK: 'USER#alice', SK: 'USER#alice' },
-        ProjectionExpression: '#username, #email',
-        ExpressionAttributeNames: {
-          '#username': 'username',
-          '#email': 'email',
-        },
-        ReturnConsumedCapacity: 'TOTAL',
-      });
-    });
-
-    it('should return undefined when item not found', async () => {
-      ddbMock.on(GetCommand).resolves({});
-
-      const builder = createGetBuilder<any, TestUser>(
-        'TestTable',
-        { PK: 'USER#notfound', SK: 'USER#notfound' },
-        client
-      );
-
-      const result = await builder.execute();
-
-      expect(result).toBeUndefined();
-    });
-  });
-});

package/src/builders/get/create-get-builder.ts

@@ -1,117 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
-import { GetCommand, GetCommandInput, GetCommandOutput } from '@aws-sdk/lib-dynamodb';
-import { buildProjectionExpression } from '../shared';
-import { GetBuilder } from './types';
-import { DynamoDBLogger } from '../../utils/dynamodb-logger';
-
-/**
- * Creates a GetBuilder to retrieve an item by its key.
- */
-export function createGetBuilder<KeyInput, Model>(
-  tableName: string,
-  key: Record<string, any>,
-  client: DynamoDBClient,
-  options?: {
-    projection?: (keyof Model)[];
-    consistentRead?: boolean;
-    returnConsumedCapacity?: 'INDEXES' | 'TOTAL' | 'NONE';
-  },
-  logger?: DynamoDBLogger
-): GetBuilder<KeyInput, Model> {
-  const projection = options?.projection ?? [];
-  const isConsistent = options?.consistentRead ?? false;
-  const consumedCapacity = options?.returnConsumedCapacity;
-
-  return {
-    /**
-     * Select only specific attributes to retrieve.
-     */
-    select(attrs) {
-      return createGetBuilder(
-        tableName,
-        key,
-        client,
-        {
-          projection: attrs,
-          consistentRead: isConsistent,
-          returnConsumedCapacity: consumedCapacity,
-        },
-        logger
-      );
-    },
-
-    /**
-     * Enable strongly consistent read.
-     */
-    consistentRead() {
-      return createGetBuilder(
-        tableName,
-        key,
-        client,
-        {
-          projection,
-          consistentRead: true,
-          returnConsumedCapacity: consumedCapacity,
-        },
-        logger
-      );
-    },
-
-    /**
-     * Configure ReturnConsumedCapacity parameter.
-     */
-    returnConsumedCapacity(mode) {
-      return createGetBuilder(
-        tableName,
-        key,
-        client,
-        {
-          projection,
-          consistentRead: isConsistent,
-          returnConsumedCapacity: mode,
-        },
-        logger
-      );
-    },
-
-    /**
-     * Build the underlying DynamoDB input parameters.
-     */
-    dbParams(): GetCommandInput {
-      const params: GetCommandInput = {
-        TableName: tableName,
-        Key: key,
-      };
-
-      // Add projection with proper ExpressionAttributeNames
-      if (projection.length > 0) {
-        const projectionExpr = buildProjectionExpression(projection as string[]);
-        params.ProjectionExpression = projectionExpr.ProjectionExpression;
-        params.ExpressionAttributeNames = projectionExpr.ExpressionAttributeNames;
-      }
-
-      // Add consistent read if enabled
-      if (isConsistent) {
-        params.ConsistentRead = true;
-      }
-
-      // Add ReturnConsumedCapacity if specified
-      if (consumedCapacity) {
-        params.ReturnConsumedCapacity = consumedCapacity;
-      }
-
-      return params;
-    },
-
-    /**
-     * Execute the GetItem command and return the item if found.
-     */
-    async execute(): Promise<Model | undefined> {
-      const params = this.dbParams();
-      const result: GetCommandOutput = await client.send(new GetCommand(params));
-      logger?.log('GetCommand', params, result);
-      return result.Item as unknown as Model | undefined;
-    },
-  };
-}

package/src/builders/get/index.ts

@@ -1,2 +0,0 @@
-export * from './types';
-export * from './create-get-builder';

package/src/builders/get/types.ts

@@ -1,39 +0,0 @@
-import type { GetCommandInput } from '@aws-sdk/lib-dynamodb';
-import { ExecutableBuilder } from '../shared';
-
-/**
- * Builder for DynamoDB GetItem operations.
- * Supports projection, consistent read, and inspection of the final parameters.
- */
-export interface GetBuilder<KeyInput, Model> extends Omit<
-  ExecutableBuilder<Model | undefined>,
-  'dbParams'
-> {
-  /**
-   * Adds a projection expression to only return specific attributes.
-   * Returns a new immutable builder.
-   */
-  select(attrs: (keyof Model)[]): GetBuilder<KeyInput, Model>;
-
-  /**
-   * Enables strongly consistent read (eventual consistency is default).
-   * Returns a new immutable builder.
-   */
-  consistentRead(): GetBuilder<KeyInput, Model>;
-
-  /**
-   * Configures the ReturnConsumedCapacity parameter.
-   * Returns a new immutable builder.
-   *
-   * @param mode - 'INDEXES' | 'TOTAL' | 'NONE'
-   * - INDEXES: Returns consumed capacity for table and indexes
-   * - TOTAL: Returns total consumed capacity
-   * - NONE: No consumed capacity data returned (default)
-   */
-  returnConsumedCapacity(mode: 'INDEXES' | 'TOTAL' | 'NONE'): GetBuilder<KeyInput, Model>;
-
-  /**
-   * Converts the builder state to DynamoDB GetItem parameters
-   */
-  dbParams(): GetCommandInput;
-}

package/src/builders/index.ts

@@ -1,14 +0,0 @@
-// Shared utilities and types
-export * from './shared';
-
-// Operation builders
-export * from './get';
-export * from './put';
-export * from './query';
-export * from './scan';
-export * from './update';
-export * from './delete';
-export * from './batch-get';
-export * from './batch-write';
-export * from './transact-write';
-export * from './transact-get';

package/src/builders/put/create-put-builder.test.ts

@@ -1,213 +0,0 @@
-import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
-import { mockClient } from 'aws-sdk-client-mock';
-import { PutCommand } from '@aws-sdk/lib-dynamodb';
-import { createPutBuilder } from './create-put-builder';
-
-const ddbMock = mockClient(DynamoDBClient);
-
-describe('createPutBuilder', () => {
-  const tableName = 'test-table';
-  const client = new DynamoDBClient({});
-
-  beforeEach(() => {
-    ddbMock.reset();
-  });
-
-  describe('Basic functionality', () => {
-    it('should create a put builder with minimal config', () => {
-      const item = { id: '123', name: 'Test' };
-      const builder = createPutBuilder(tableName, item, client);
-
-      const params = builder.dbParams();
-
-      expect(params).toEqual({
-        TableName: tableName,
-        Item: item,
-      });
-    });
-
-    it('should build params with conditions', () => {
-      const item = { id: '123', name: 'Test' };
-      const builder = createPutBuilder(tableName, item, client).where((attrs, ops) =>
-        ops.eq(attrs.id, '123')
-      );
-
-      const params = builder.dbParams();
-
-      expect(params.ConditionExpression).toBe('#id = :id_0');
-      expect(params.ExpressionAttributeNames).toEqual({ '#id': 'id' });
-      expect(params.ExpressionAttributeValues).toEqual({ ':id_0': '123' });
-    });
-  });
-
-  describe('Timestamps support', () => {
-    it('should add createdAt and updatedAt when enableTimestamps is true', () => {
-      const item = { id: '123', name: 'Test' };
-      const builder = createPutBuilder(tableName, item, client, [], false, 'NONE', true);
-
-      const params = builder.dbParams();
-
-      expect(params.Item).toHaveProperty('createdAt');
-      expect(params.Item).toHaveProperty('updatedAt');
-      expect(typeof params.Item.createdAt).toBe('string');
-      expect(typeof params.Item.updatedAt).toBe('string');
-      expect(params.Item.createdAt).toBe(params.Item.updatedAt);
-    });
-
-    it('should not add timestamps when enableTimestamps is false', () => {
-      const item = { id: '123', name: 'Test' };
-      const builder = createPutBuilder(tableName, item, client, [], false, 'NONE', false);
-
-      const params = builder.dbParams();
-
-      expect(params.Item).not.toHaveProperty('createdAt');
-      expect(params.Item).not.toHaveProperty('updatedAt');
-    });
-
-    it('should preserve original item data with timestamps', () => {
-      const item = { id: '123', name: 'Test', value: 42 };
-      const builder = createPutBuilder(tableName, item, client, [], false, 'NONE', true);
-
-      const params = builder.dbParams();
-
-      expect(params.Item.id).toBe('123');
-      expect(params.Item.name).toBe('Test');
-      expect(params.Item.value).toBe(42);
-    });
-  });
-
-  describe('ifNotExists functionality', () => {
-    it('should add attribute_not_exists conditions for PK and SK', () => {
-      const item = { PK: 'user#123', SK: 'profile', name: 'Test' };
-      const builder = createPutBuilder(tableName, item, client).ifNotExists();
-
-      const params = builder.dbParams();
-
-      expect(params.ConditionExpression).toContain('attribute_not_exists(#PK)');
-      expect(params.ConditionExpression).toContain('attribute_not_exists(#SK)');
-      expect(params.ExpressionAttributeNames).toHaveProperty('#PK');
-      expect(params.ExpressionAttributeNames).toHaveProperty('#SK');
-    });
-
-    it('should handle lowercase pk and sk', () => {
-      const item = { pk: 'user#123', sk: 'profile', name: 'Test' };
-      const builder = createPutBuilder(tableName, item, client).ifNotExists();
-
-      const params = builder.dbParams();
-
-      expect(params.ConditionExpression).toContain('attribute_not_exists(#pk)');
-      expect(params.ConditionExpression).toContain('attribute_not_exists(#sk)');
-    });
-
-    it('should combine ifNotExists with other conditions', () => {
-      const item = { PK: 'user#123', SK: 'profile', name: 'Test' };
-      const builder = createPutBuilder(tableName, item, client)
-        .where((attrs, ops) => ops.eq(attrs.name, 'Test'))
-        .ifNotExists();
-
-      const params = builder.dbParams();
-
-      expect(params.ConditionExpression).toContain('attribute_not_exists(#PK)');
-      expect(params.ConditionExpression).toContain('#name = :name_0');
-    });
-  });
-
-  describe('returning functionality', () => {
-    it('should set ReturnValues to NONE by default', () => {
-      const item = { id: '123', name: 'Test' };
-      const builder = createPutBuilder(tableName, item, client);
-
-      const params = builder.dbParams();
-
-      expect(params.ReturnValues).toBeUndefined();
-    });
-
-    it('should set ReturnValues to ALL_OLD when specified', () => {
-      const item = { id: '123', name: 'Test' };
-      const builder = createPutBuilder(tableName, item, client).returning('ALL_OLD');
-
-      const params = builder.dbParams();
-
-      expect(params.ReturnValues).toBe('ALL_OLD');
-    });
-  });
-
-  describe('execute functionality', () => {
-    it('should return the new item when returnMode is NONE', async () => {
-      const item = { id: '123', name: 'Test' };
-
-      ddbMock.on(PutCommand).resolves({});
-
-      const builder = createPutBuilder(tableName, item, client);
-      const result = await builder.execute();
-
-      expect(result).toEqual(item);
-    });
-
-    it('should return the old item when returnMode is ALL_OLD and item was replaced', async () => {
-      const item = { id: '123', name: 'New Name' };
-      const oldItem = { id: '123', name: 'Old Name' };
-
-      ddbMock.on(PutCommand).resolves({
-        Attributes: oldItem,
-      });
-
-      const builder = createPutBuilder(tableName, item, client).returning('ALL_OLD');
-      const result = await builder.execute();
-
-      expect(result).toEqual(oldItem);
-    });
-
-    it('should return the new item when returnMode is ALL_OLD but no old item existed', async () => {
-      const item = { id: '123', name: 'Test' };
-
-      ddbMock.on(PutCommand).resolves({});
-
-      const builder = createPutBuilder(tableName, item, client).returning('ALL_OLD');
-      const result = await builder.execute();
-
-      expect(result).toEqual(item);
-    });
-
-    it('should return item with timestamps when timestamps are enabled', async () => {
-      const item = { id: '123', name: 'Test' };
-
-      ddbMock.on(PutCommand).resolves({});
-
-      const builder = createPutBuilder(tableName, item, client, [], false, 'NONE', true);
-      const result = await builder.execute();
-
-      expect(result).toHaveProperty('createdAt');
-      expect(result).toHaveProperty('updatedAt');
-      expect(result.id).toBe('123');
-      expect(result.name).toBe('Test');
-    });
-  });
-
-  describe('Method chaining', () => {
-    it('should allow chaining multiple methods', () => {
-      const item = { PK: 'user#123', SK: 'profile', name: 'Test' };
-      const builder = createPutBuilder(tableName, item, client)
-        .where((attrs, ops) => ops.eq(attrs.name, 'Test'))
-        .ifNotExists()
-        .returning('ALL_OLD');
-
-      const params = builder.dbParams();
-
-      expect(params.ConditionExpression).toBeTruthy();
-      expect(params.ReturnValues).toBe('ALL_OLD');
-    });
-
-    it('should preserve timestamps through chaining', () => {
-      const item = { id: '123', name: 'Test' };
-      const builder = createPutBuilder(tableName, item, client, [], false, 'NONE', true)
-        .where((attrs, ops) => ops.eq(attrs.id, '123'))
-        .returning('ALL_OLD');
-
-      const params = builder.dbParams();
-
-      expect(params.Item).toHaveProperty('createdAt');
-      expect(params.Item).toHaveProperty('updatedAt');
-    });
-  });
-});