@ftschopp/dynatable-core 1.4.1 → 1.4.3

package/src/builders/batch-write/create-batch-write-builder.ts

@@ -1,49 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
-import {
-  BatchWriteCommand,
-  BatchWriteCommandInput,
-  BatchWriteCommandOutput,
-} from '@aws-sdk/lib-dynamodb';
-import { BatchWriteBuilder, WriteRequest } from './types';
-import { DynamoDBLogger } from '../../utils/dynamodb-logger';
-
-/**
- * Creates a BatchWriteBuilder to put or delete multiple items.
- *
- * @param requestItems - An object where keys are table names and values are arrays of WriteRequest
- * @param client - DynamoDB client instance
- * @param logger - Optional logger instance
- */
-export function createBatchWriteBuilder(
-  requestItems: Record<string, WriteRequest[]>,
-  client: DynamoDBClient,
-  logger?: DynamoDBLogger
-): BatchWriteBuilder {
-  return {
-    /**
-     * Build the underlying DynamoDB input parameters.
-     */
-    dbParams(): BatchWriteCommandInput {
-      return {
-        RequestItems: requestItems,
-      };
-    },
-
-    /**
-     * Execute the BatchWriteItem command.
-     */
-    async execute(): Promise<{
-      unprocessedItems?: Record<string, WriteRequest[]>;
-    }> {
-      const params = this.dbParams();
-      const result: BatchWriteCommandOutput = await client.send(new BatchWriteCommand(params));
-      logger?.log('BatchWriteCommand', params, result);
-
-      // Return unprocessed items if any
-      return {
-        unprocessedItems: result.UnprocessedItems as Record<string, WriteRequest[]> | undefined,
-      };
-    },
-  };
-}

package/src/builders/batch-write/index.ts

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

package/src/builders/batch-write/types.ts

@@ -1,33 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { BatchWriteItemCommandInput } from '@aws-sdk/client-dynamodb';
-
-/**
- * A single write request that can be either a PutRequest or DeleteRequest
- */
-export type WriteRequest = {
-  PutRequest?: {
-    Item: any;
-  };
-  DeleteRequest?: {
-    Key: any;
-  };
-};
-
-/**
- * BatchWriteBuilder allows you to put or delete multiple items from one or more tables
- * in a single request.
- */
-export type BatchWriteBuilder = {
-  /**
-   * Build the underlying DynamoDB BatchWriteItem input parameters.
-   */
-  dbParams(): BatchWriteItemCommandInput;
-
-  /**
-   * Execute the BatchWriteItem command.
-   * Returns unprocessed items if any requests failed.
-   */
-  execute(): Promise<{
-    unprocessedItems?: Record<string, WriteRequest[]>;
-  }>;
-};

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

@@ -1,294 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
-import { createDeleteBuilder } from './create-delete-builder';
-
-describe('DeleteBuilder', () => {
-  const client = new DynamoDBClient({});
-  const tableName = 'TestTable';
-
-  interface TestModel {
-    pk: string;
-    sk: string;
-    name?: string;
-    age?: number;
-    score?: number;
-    followerCount?: number;
-    status?: string;
-  }
-
-  describe('Basic delete operations', () => {
-    test('should build params with just key', () => {
-      const key: Partial<TestModel> = { pk: 'USER#1', sk: 'USER#1' };
-      const params = createDeleteBuilder<TestModel>(tableName, key, client).dbParams();
-
-      expect(params.TableName).toBe(tableName);
-      expect(params.Key).toEqual(key);
-      expect(params.ConditionExpression).toBeUndefined();
-      expect(params.ExpressionAttributeNames).toBeUndefined();
-      expect(params.ExpressionAttributeValues).toBeUndefined();
-      expect(params.ReturnValues).toBeUndefined();
-    });
-
-    test('should build params with partial key', () => {
-      const key: Partial<TestModel> = { pk: 'USER#1' };
-      const params = createDeleteBuilder<TestModel>(tableName, key, client).dbParams();
-
-      expect(params.Key).toEqual({ pk: 'USER#1' });
-    });
-  });
-
-  describe('Condition expressions', () => {
-    test('should build params with single where condition', () => {
-      const key: Partial<TestModel> = { pk: 'USER#1', sk: 'USER#1' };
-      const params = createDeleteBuilder<TestModel>(tableName, key, client)
-        .where((attr, op) => op.eq(attr.status, 'inactive'))
-        .dbParams();
-
-      expect(params.TableName).toBe(tableName);
-      expect(params.Key).toEqual(key);
-      expect(params.ConditionExpression).toMatch(/#status = :status_\d+/);
-      expect(params.ExpressionAttributeNames).toEqual({
-        '#status': 'status',
-      });
-      expect(Object.values(params.ExpressionAttributeValues || {})).toContain('inactive');
-    });
-
-    test('should build params with AND condition', () => {
-      const key: Partial<TestModel> = { pk: 'USER#1', sk: 'USER#1' };
-      const params = createDeleteBuilder<TestModel>(tableName, key, client)
-        .where((attr, op) => op.and(op.eq(attr.status, 'inactive'), op.lt(attr.followerCount, 10)))
-        .dbParams();
-
-      expect(params.ConditionExpression).toMatch(
-        /\(#status = :status_\d+\) AND \(#followerCount < :followerCount_\d+\)/
-      );
-      expect(params.ExpressionAttributeNames).toEqual({
-        '#status': 'status',
-        '#followerCount': 'followerCount',
-      });
-      expect(Object.values(params.ExpressionAttributeValues || {})).toContain('inactive');
-      expect(Object.values(params.ExpressionAttributeValues || {})).toContain(10);
-    });
-
-    test('should build params with OR condition', () => {
-      const key: Partial<TestModel> = { pk: 'USER#1', sk: 'USER#1' };
-      const params = createDeleteBuilder<TestModel>(tableName, key, client)
-        .where((attr, op) => op.or(op.eq(attr.status, 'inactive'), op.eq(attr.status, 'deleted')))
-        .dbParams();
-
-      expect(params.ConditionExpression).toMatch(
-        /\(#status = :status_\d+\) OR \(#status = :status_\d+\)/
-      );
-      expect(params.ExpressionAttributeNames).toEqual({
-        '#status': 'status',
-      });
-      expect(Object.values(params.ExpressionAttributeValues || {})).toContain('inactive');
-      expect(Object.values(params.ExpressionAttributeValues || {})).toContain('deleted');
-    });
-
-    test('should build params with multiple where conditions', () => {
-      const key: Partial<TestModel> = { pk: 'USER#1', sk: 'USER#1' };
-      const params = createDeleteBuilder<TestModel>(tableName, key, client)
-        .where((attr, op) => op.eq(attr.status, 'inactive'))
-        .where((attr, op) => op.lt(attr.followerCount, 10))
-        .dbParams();
-
-      expect(params.ConditionExpression).toMatch(
-        /\(#status = :status_\d+\) AND \(#followerCount < :followerCount_\d+\)/
-      );
-      expect(params.ExpressionAttributeNames).toEqual({
-        '#status': 'status',
-        '#followerCount': 'followerCount',
-      });
-    });
-
-    test('should build params with complex nested conditions', () => {
-      const key: Partial<TestModel> = { pk: 'USER#1', sk: 'USER#1' };
-      const params = createDeleteBuilder<TestModel>(tableName, key, client)
-        .where((attr, op) =>
-          op.and(
-            op.or(op.eq(attr.status, 'inactive'), op.eq(attr.status, 'banned')),
-            op.lt(attr.followerCount, 5)
-          )
-        )
-        .dbParams();
-
-      expect(params.ConditionExpression).toMatch(/\(/);
-      expect(params.ConditionExpression).toMatch(/AND/);
-      expect(params.ConditionExpression).toMatch(/OR/);
-      expect(params.ExpressionAttributeNames).toEqual({
-        '#status': 'status',
-        '#followerCount': 'followerCount',
-      });
-      expect(Object.values(params.ExpressionAttributeValues || {})).toContain('inactive');
-      expect(Object.values(params.ExpressionAttributeValues || {})).toContain('banned');
-      expect(Object.values(params.ExpressionAttributeValues || {})).toContain(5);
-    });
-
-    test('should support comparison operators', () => {
-      const key: Partial<TestModel> = { pk: 'USER#1', sk: 'USER#1' };
-
-      // Greater than
-      const gtParams = createDeleteBuilder<TestModel>(tableName, key, client)
-        .where((attr, op) => op.gt(attr.age, 18))
-        .dbParams();
-      expect(gtParams.ConditionExpression).toMatch(/#age > :age_\d+/);
-
-      // Greater than or equal
-      const gteParams = createDeleteBuilder<TestModel>(tableName, key, client)
-        .where((attr, op) => op.gte(attr.age, 18))
-        .dbParams();
-      expect(gteParams.ConditionExpression).toMatch(/#age >= :age_\d+/);
-
-      // Less than
-      const ltParams = createDeleteBuilder<TestModel>(tableName, key, client)
-        .where((attr, op) => op.lt(attr.age, 65))
-        .dbParams();
-      expect(ltParams.ConditionExpression).toMatch(/#age < :age_\d+/);
-
-      // Less than or equal
-      const lteParams = createDeleteBuilder<TestModel>(tableName, key, client)
-        .where((attr, op) => op.lte(attr.age, 65))
-        .dbParams();
-      expect(lteParams.ConditionExpression).toMatch(/#age <= :age_\d+/);
-
-      // Not equal
-      const neParams = createDeleteBuilder<TestModel>(tableName, key, client)
-        .where((attr, op) => op.ne(attr.status, 'active'))
-        .dbParams();
-      expect(neParams.ConditionExpression).toMatch(/#status <> :status_\d+/);
-    });
-
-    test('should support BETWEEN operator', () => {
-      const key: Partial<TestModel> = { pk: 'USER#1', sk: 'USER#1' };
-      const params = createDeleteBuilder<TestModel>(tableName, key, client)
-        .where((attr, op) => op.between(attr.age, 18, 65))
-        .dbParams();
-
-      expect(params.ConditionExpression).toMatch(/#age BETWEEN :age_low_\d+ AND :age_high_\d+/);
-      expect(Object.values(params.ExpressionAttributeValues || {})).toContain(18);
-      expect(Object.values(params.ExpressionAttributeValues || {})).toContain(65);
-    });
-
-    test('should support beginsWith operator', () => {
-      const key: Partial<TestModel> = { pk: 'USER#1', sk: 'USER#1' };
-      const params = createDeleteBuilder<TestModel>(tableName, key, client)
-        .where((attr, op) => op.beginsWith(attr.name, 'John'))
-        .dbParams();
-
-      expect(params.ConditionExpression).toMatch(/begins_with\(#name, :name_\d+\)/);
-      expect(Object.values(params.ExpressionAttributeValues || {})).toContain('John');
-    });
-  });
-
-  describe('ReturnValues', () => {
-    test('should default to NONE', () => {
-      const key: Partial<TestModel> = { pk: 'USER#1', sk: 'USER#1' };
-      const params = createDeleteBuilder<TestModel>(tableName, key, client).dbParams();
-
-      expect(params.ReturnValues).toBeUndefined();
-    });
-
-    test('should support ALL_OLD', () => {
-      const key: Partial<TestModel> = { pk: 'USER#1', sk: 'USER#1' };
-      const params = createDeleteBuilder<TestModel>(tableName, key, client)
-        .returning('ALL_OLD')
-        .dbParams();
-
-      expect(params.ReturnValues).toBe('ALL_OLD');
-    });
-
-    test('should support NONE explicitly', () => {
-      const key: Partial<TestModel> = { pk: 'USER#1', sk: 'USER#1' };
-      const params = createDeleteBuilder<TestModel>(tableName, key, client)
-        .returning('NONE')
-        .dbParams();
-
-      expect(params.ReturnValues).toBeUndefined();
-    });
-  });
-
-  describe('Immutability', () => {
-    test('should create new builder instance on each method call', () => {
-      const key: Partial<TestModel> = { pk: 'USER#1', sk: 'USER#1' };
-      const builder1 = createDeleteBuilder<TestModel>(tableName, key, client);
-      const builder2 = builder1.where((attr, op) => op.eq(attr.status, 'inactive'));
-      const builder3 = builder2.returning('ALL_OLD');
-
-      expect(builder1.dbParams().ConditionExpression).toBeUndefined();
-      expect(builder1.dbParams().ReturnValues).toBeUndefined();
-
-      expect(builder2.dbParams().ConditionExpression).toMatch(/#status = :status_\d+/);
-      expect(builder2.dbParams().ReturnValues).toBeUndefined();
-
-      expect(builder3.dbParams().ConditionExpression).toMatch(/#status = :status_\d+/);
-      expect(builder3.dbParams().ReturnValues).toBe('ALL_OLD');
-    });
-  });
-
-  describe('Complex scenarios', () => {
-    test('should handle delete with all features', () => {
-      const key: Partial<TestModel> = { pk: 'USER#1', sk: 'USER#1' };
-      const params = createDeleteBuilder<TestModel>(tableName, key, client)
-        .where((attr, op) =>
-          op.and(
-            op.eq(attr.status, 'inactive'),
-            op.or(op.lt(attr.followerCount, 5), op.gt(attr.age, 365))
-          )
-        )
-        .returning('ALL_OLD')
-        .dbParams();
-
-      expect(params.TableName).toBe(tableName);
-      expect(params.Key).toEqual(key);
-      expect(params.ConditionExpression).toBeTruthy();
-      expect(params.ConditionExpression).toMatch(/AND/);
-      expect(params.ConditionExpression).toMatch(/OR/);
-      expect(params.ReturnValues).toBe('ALL_OLD');
-      expect(params.ExpressionAttributeNames).toEqual({
-        '#status': 'status',
-        '#followerCount': 'followerCount',
-        '#age': 'age',
-      });
-      expect(Object.values(params.ExpressionAttributeValues || {})).toContain('inactive');
-      expect(Object.values(params.ExpressionAttributeValues || {})).toContain(5);
-      expect(Object.values(params.ExpressionAttributeValues || {})).toContain(365);
-    });
-
-    test('should handle conditional delete based on multiple attributes', () => {
-      const key: Partial<TestModel> = { pk: 'USER#1', sk: 'USER#1' };
-      const params = createDeleteBuilder<TestModel>(tableName, key, client)
-        .where((attr, op) => op.eq(attr.status, 'inactive'))
-        .where((attr, op) => op.lt(attr.followerCount, 10))
-        .where((attr, op) => op.between(attr.age, 0, 30))
-        .returning('ALL_OLD')
-        .dbParams();
-
-      expect(params.ConditionExpression).toBeTruthy();
-      expect(params.ConditionExpression).toMatch(/AND/);
-      expect(params.ExpressionAttributeNames).toEqual({
-        '#status': 'status',
-        '#followerCount': 'followerCount',
-        '#age': 'age',
-      });
-    });
-  });
-
-  describe('Edge cases', () => {
-    test('should handle empty conditions gracefully', () => {
-      const key: Partial<TestModel> = { pk: 'USER#1', sk: 'USER#1' };
-      const params = createDeleteBuilder<TestModel>(tableName, key, client).dbParams();
-
-      expect(params.ConditionExpression).toBeUndefined();
-      expect(params.ExpressionAttributeNames).toBeUndefined();
-      expect(params.ExpressionAttributeValues).toBeUndefined();
-    });
-
-    test('should handle key with only pk', () => {
-      const key: Partial<TestModel> = { pk: 'USER#1' };
-      const params = createDeleteBuilder<TestModel>(tableName, key, client).dbParams();
-
-      expect(params.Key).toEqual({ pk: 'USER#1' });
-    });
-  });
-});

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

@@ -1,100 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
-import { DeleteCommand } from '@aws-sdk/lib-dynamodb';
-import { buildExpression, AttrBuilder, Condition, createOpBuilder } from '../shared';
-import { DeleteBuilder } from './types';
-import { DynamoDBLogger } from '../../utils/dynamodb-logger';
-
-/**
- * Creates a DeleteBuilder for an item key and table.
- */
-export function createDeleteBuilder<Model>(
-  tableName: string,
-  key: Partial<Model>,
-  client: DynamoDBClient,
-  prevConditions: Condition[] = [],
-  returnMode: 'NONE' | 'ALL_OLD' = 'NONE',
-  logger?: DynamoDBLogger
-): DeleteBuilder<Model> {
-  const conditions = [...prevConditions];
-
-  const build = (): DeleteBuilder<Model> => ({
-    where(fn) {
-      const attrs = new Proxy({} as AttrBuilder<Model>, {
-        get(_, prop: string) {
-          return { name: prop };
-        },
-      });
-      const opBuilder = createOpBuilder();
-      const condition = fn(attrs, opBuilder);
-      return createDeleteBuilder(
-        tableName,
-        key,
-        client,
-        [...conditions, condition],
-        returnMode,
-        logger
-      );
-    },
-
-    returning(mode) {
-      return createDeleteBuilder(tableName, key, client, conditions, mode, logger);
-    },
-
-    dbParams() {
-      // Build ConditionExpression from condition tree
-      let conditionExpression = '';
-      let expressionAttributeNames = {};
-      let expressionAttributeValues = {};
-
-      if (conditions.length > 0) {
-        const combinedCondition =
-          conditions.length === 1 && conditions[0]
-            ? conditions[0]
-            : {
-                expression: '',
-                operator: 'AND' as const,
-                children: conditions,
-              };
-
-        const result = buildExpression(combinedCondition);
-        conditionExpression = result.expression;
-        expressionAttributeNames = result.names;
-        expressionAttributeValues = result.values;
-      }
-
-      const extra: any = returnMode !== 'NONE' ? { ReturnValues: returnMode } : {};
-
-      return {
-        TableName: tableName,
-        Key: key,
-        ...(conditionExpression && {
-          ConditionExpression: conditionExpression,
-        }),
-        ...(Object.keys(expressionAttributeNames).length && {
-          ExpressionAttributeNames: expressionAttributeNames,
-        }),
-        ...(Object.keys(expressionAttributeValues).length && {
-          ExpressionAttributeValues: expressionAttributeValues,
-        }),
-        ...extra,
-      };
-    },
-
-    async execute() {
-      const params = build().dbParams();
-      const response = await client.send(new DeleteCommand(params));
-      logger?.log('DeleteCommand', params, response);
-
-      // Return the deleted item if returnMode is ALL_OLD
-      if (returnMode === 'ALL_OLD' && response.Attributes) {
-        return response.Attributes as Model;
-      }
-
-      // For NONE mode, return the key as a fallback
-      return key as Model;
-    },
-  });
-
-  return build();
-}

package/src/builders/delete/index.ts

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

package/src/builders/delete/types.ts

@@ -1,17 +0,0 @@
-import type { DeleteCommandInput } from '@aws-sdk/lib-dynamodb';
-import { OperationBuilder } from '../shared';
-
-/**
- * Builder interface for DynamoDB DeleteItem operations
- */
-export interface DeleteBuilder<Model> extends Omit<OperationBuilder<Model>, 'dbParams'> {
-  /**
-   * Configures what values should be returned after the delete operation
-   */
-  returning(mode: 'NONE' | 'ALL_OLD'): DeleteBuilder<Model>;
-
-  /**
-   * Converts the builder state to DynamoDB DeleteItem parameters
-   */
-  dbParams(): DeleteCommandInput;
-}