betterddb 0.6.0 → 0.6.4

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

@@ -1,13 +1,16 @@
-import { BetterDDB } from '../betterddb';
-import { BatchGetCommand } from '@aws-sdk/lib-dynamodb';
-import { BatchGetItemInput } from '@aws-sdk/client-dynamodb';
+import { BetterDDB } from "../betterddb";
+import { BatchGetCommand } from "@aws-sdk/lib-dynamodb";
+import { BatchGetItemInput } from "@aws-sdk/client-dynamodb";
 
 export class BatchGetBuilder<T> {
   /**
    * @param parent - The BetterDDB instance for the table.
    * @param keys - An array of partial keys for the items you wish to retrieve.
    */
-  constructor(private parent: BetterDDB<T>, private keys: Partial<T>[]) {}
+  constructor(
+    private parent: BetterDDB<T>,
+    private keys: Partial<T>[],
+  ) {}
 
   /**
    * Executes the batch get operation.
@@ -29,7 +32,7 @@ export class BatchGetBuilder<T> {
     });
     const tableName = this.parent.getTableName();
     // Build an array of keys using the parent's key builder.
-    const keysArray = deduplicatedKeys.map(key => this.parent.buildKey(key));
+    const keysArray = deduplicatedKeys.map((key) => this.parent.buildKey(key));
 
     // Construct the BatchGet parameters.
     const params: BatchGetItemInput = {
@@ -40,7 +43,9 @@ export class BatchGetBuilder<T> {
       },
     };
 
-    const result = await this.parent.getClient().send(new BatchGetCommand(params));
+    const result = await this.parent
+      .getClient()
+      .send(new BatchGetCommand(params));
     const responses = result.Responses ? result.Responses[tableName] : [];
     if (!responses) {
       return [];

package/src/builders/create-builder.ts

@@ -1,12 +1,18 @@
-
-import { AttributeValue, Put, TransactWriteItem } from '@aws-sdk/client-dynamodb';
-import { BetterDDB } from '../betterddb';
-import { PutCommand, TransactWriteCommand } from '@aws-sdk/lib-dynamodb';
+import {
+  AttributeValue,
+  Put,
+  TransactWriteItem,
+} from "@aws-sdk/client-dynamodb";
+import { BetterDDB } from "../betterddb";
+import { PutCommand, TransactWriteCommand } from "@aws-sdk/lib-dynamodb";
 
 export class CreateBuilder<T> {
   private extraTransactItems: TransactWriteItem[] = [];
 
-  constructor(private parent: BetterDDB<T>, private item: T) {}
+  constructor(
+    private parent: BetterDDB<T>,
+    private item: T,
+  ) {}
 
   public async execute(): Promise<T> {
     const validated = this.parent.getSchema().parse(this.item);
@@ -15,35 +21,41 @@ export class CreateBuilder<T> {
       const myTransactItem = this.toTransactPut();
       // Combine with extra transaction items.
       const allItems = [...this.extraTransactItems, myTransactItem];
-      await this.parent.getClient().send(new TransactWriteCommand({
-        TransactItems: allItems
-      }));
+      await this.parent.getClient().send(
+        new TransactWriteCommand({
+          TransactItems: allItems,
+        }),
+      );
       // After transaction, retrieve the updated item.
       const result = await this.parent.get(this.item).execute();
       if (result === null) {
-        throw new Error('Item not found after transaction create');
+        throw new Error("Item not found after transaction create");
       }
       return result;
     } else {
+      let finalItem: T = {
+        ...this.item,
+        entityType: this.parent.getEntityType(),
+      };
+      if (this.parent.getTimestamps()) {
+        const now = new Date().toISOString();
+        finalItem = { ...finalItem, createdAt: now, updatedAt: now } as T;
+      }
 
-    let finalItem: T = { ...this.item , entityType: this.parent.getEntityType() };
-    if (this.parent.getTimestamps()) {
-      const now = new Date().toISOString();
-      finalItem = { ...finalItem, createdAt: now, updatedAt: now } as T;
-    }
+      // Compute and merge primary key.
+      const computedKeys = this.parent.buildKey(validated as Partial<T>);
+      finalItem = { ...finalItem, ...computedKeys };
 
-    // Compute and merge primary key.
-    const computedKeys = this.parent.buildKey(validated as Partial<T>);
-    finalItem = { ...finalItem, ...computedKeys };
+      // Compute and merge index attributes.
+      const indexAttributes = this.parent.buildIndexes(validated as Partial<T>);
+      finalItem = { ...finalItem, ...indexAttributes };
 
-    // Compute and merge index attributes.
-    const indexAttributes = this.parent.buildIndexes(validated as Partial<T>);
-    finalItem = { ...finalItem, ...indexAttributes };
-
-    await this.parent.getClient().send(new PutCommand({
-      TableName: this.parent.getTableName(),
-      Item: finalItem as Record<string, AttributeValue>
-    }));
+      await this.parent.getClient().send(
+        new PutCommand({
+          TableName: this.parent.getTableName(),
+          Item: finalItem as Record<string, AttributeValue>,
+        }),
+      );
 
       return validated as T;
     }
@@ -58,9 +70,12 @@ export class CreateBuilder<T> {
     return this;
   }
 
-  public toTransactPut(): TransactWriteItem{
+  public toTransactPut(): TransactWriteItem {
     const validated = this.parent.getSchema().parse(this.item);
-    let finalItem: T = { ...this.item , entityType: this.parent.getEntityType() };
+    let finalItem: T = {
+      ...this.item,
+      entityType: this.parent.getEntityType(),
+    };
     if (this.parent.getTimestamps()) {
       const now = new Date().toISOString();
       finalItem = { ...finalItem, createdAt: now, updatedAt: now } as T;

package/src/builders/delete-builder.ts

@@ -1,15 +1,24 @@
-import { BetterDDB } from '../betterddb';
-import { TransactWriteItem, DeleteItemInput } from '@aws-sdk/client-dynamodb';
-import { TransactWriteCommand, DeleteCommand } from '@aws-sdk/lib-dynamodb';
+import { BetterDDB } from "../betterddb";
+import { TransactWriteItem, DeleteItemInput } from "@aws-sdk/client-dynamodb";
+import { TransactWriteCommand, DeleteCommand } from "@aws-sdk/lib-dynamodb";
 export class DeleteBuilder<T> {
-  private condition?: { expression: string; attributeValues: Record<string, any> };
+  private condition?: {
+    expression: string;
+    attributeValues: Record<string, any>;
+  };
   private extraTransactItems: TransactWriteItem[] = [];
-  constructor(private parent: BetterDDB<T>, private key: Partial<T>) {}
+  constructor(
+    private parent: BetterDDB<T>,
+    private key: Partial<T>,
+  ) {}
 
   /**
    * Specify a condition expression for the delete operation.
    */
-  public withCondition(expression: string, attributeValues: Record<string, any>): this {
+  public withCondition(
+    expression: string,
+    attributeValues: Record<string, any>,
+  ): this {
     if (this.condition) {
       this.condition.expression += ` AND ${expression}`;
       Object.assign(this.condition.attributeValues, attributeValues);
@@ -25,21 +34,23 @@ export class DeleteBuilder<T> {
       const myTransactItem = this.toTransactDelete();
       // Combine with extra transaction items.
       const allItems = [...this.extraTransactItems, myTransactItem];
-      await this.parent.getClient().send(new TransactWriteCommand({
-        TransactItems: allItems
-      }));
+      await this.parent.getClient().send(
+        new TransactWriteCommand({
+          TransactItems: allItems,
+        }),
+      );
       // After transaction, retrieve the updated item.
       const result = await this.parent.get(this.key).execute();
       if (result === null) {
-        throw new Error('Item not found after transaction delete');
+        throw new Error("Item not found after transaction delete");
       }
     } else {
-    const params: DeleteItemInput = {
-      TableName: this.parent.getTableName(),
-      Key: this.parent.buildKey(this.key)
-    };
-    if (this.condition) {
-      params.ConditionExpression = this.condition.expression;
+      const params: DeleteItemInput = {
+        TableName: this.parent.getTableName(),
+        Key: this.parent.buildKey(this.key),
+      };
+      if (this.condition) {
+        params.ConditionExpression = this.condition.expression;
         params.ExpressionAttributeValues = this.condition.attributeValues;
       }
       await this.parent.getClient().send(new DeleteCommand(params));
@@ -58,7 +69,7 @@ export class DeleteBuilder<T> {
   public toTransactDelete(): TransactWriteItem {
     const deleteItem: DeleteItemInput = {
       TableName: this.parent.getTableName(),
-      Key: this.parent.buildKey(this.key)
+      Key: this.parent.buildKey(this.key),
     };
     if (this.condition) {
       deleteItem.ConditionExpression = this.condition.expression;

package/src/builders/get-builder.ts

@@ -1,17 +1,22 @@
-import { BetterDDB } from '../betterddb';
-import { TransactGetCommand, GetCommand } from '@aws-sdk/lib-dynamodb';
-import { GetItemInput, TransactGetItem } from '@aws-sdk/client-dynamodb';
+import { BetterDDB } from "../betterddb";
+import { TransactGetCommand, GetCommand } from "@aws-sdk/lib-dynamodb";
+import { GetItemInput, TransactGetItem } from "@aws-sdk/client-dynamodb";
 export class GetBuilder<T> {
   private projectionExpression?: string;
   private expressionAttributeNames: Record<string, string> = {};
   private extraTransactItems: TransactGetItem[] = [];
-  constructor(private parent: BetterDDB<T>, private key: Partial<T>) {}
+  constructor(
+    private parent: BetterDDB<T>,
+    private key: Partial<T>,
+  ) {}
 
   /**
    * Specify a projection by providing an array of attribute names.
    */
   public withProjection(attributes: (keyof T)[]): this {
-    this.projectionExpression = attributes.map(attr => `#${String(attr)}`).join(', ');
+    this.projectionExpression = attributes
+      .map((attr) => `#${String(attr)}`)
+      .join(", ");
     for (const attr of attributes) {
       this.expressionAttributeNames[`#${String(attr)}`] = String(attr);
     }
@@ -24,23 +29,25 @@ export class GetBuilder<T> {
       const myTransactItem = this.toTransactGet();
       // Combine with extra transaction items.
       const allItems = [...this.extraTransactItems, myTransactItem];
-      await this.parent.getClient().send(new TransactGetCommand({
-        TransactItems: allItems
-      }));
+      await this.parent.getClient().send(
+        new TransactGetCommand({
+          TransactItems: allItems,
+        }),
+      );
       // After transaction, retrieve the updated item.
       const result = await this.parent.get(this.key).execute();
       return result;
     } else {
-    const params: GetItemInput = {
-      TableName: this.parent.getTableName(),
-      Key: this.parent.buildKey(this.key)
-    };
-    if (this.projectionExpression) {
-      params.ProjectionExpression = this.projectionExpression;
-      params.ExpressionAttributeNames = this.expressionAttributeNames;
-    }
-    const result = await this.parent.getClient().send(new GetCommand(params));
-    if (!result.Item) return null;
+      const params: GetItemInput = {
+        TableName: this.parent.getTableName(),
+        Key: this.parent.buildKey(this.key),
+      };
+      if (this.projectionExpression) {
+        params.ProjectionExpression = this.projectionExpression;
+        params.ExpressionAttributeNames = this.expressionAttributeNames;
+      }
+      const result = await this.parent.getClient().send(new GetCommand(params));
+      if (!result.Item) return null;
       return this.parent.getSchema().parse(result.Item) as T;
     }
   }
@@ -57,7 +64,7 @@ export class GetBuilder<T> {
   public toTransactGet(): TransactGetItem {
     const getItem: GetItemInput = {
       TableName: this.parent.getTableName(),
-      Key: this.parent.buildKey(this.key)
+      Key: this.parent.buildKey(this.key),
     };
     if (this.projectionExpression) {
       getItem.ProjectionExpression = this.projectionExpression;

package/src/builders/query-builder.ts

@@ -1,7 +1,7 @@
-import { QueryCommand, QueryCommandInput } from '@aws-sdk/lib-dynamodb';
-import { BetterDDB, GSIConfig } from '../betterddb';
-import { getOperatorExpression, Operator } from '../operator';
-import { PaginatedResult } from '../types/paginated-result';
+import { QueryCommand, QueryCommandInput } from "@aws-sdk/lib-dynamodb";
+import { BetterDDB, GSIConfig } from "../betterddb";
+import { getOperatorExpression, Operator } from "../operator";
+import { PaginatedResult } from "../types/paginated-result";
 
 export class QueryBuilder<T> {
   private keyConditions: string[] = [];
@@ -13,29 +13,32 @@ export class QueryBuilder<T> {
   private lastKey?: Record<string, any>;
   private ascending: boolean = true;
 
-  constructor(private parent: BetterDDB<T>, private key: Partial<T>, ) {
+  constructor(
+    private parent: BetterDDB<T>,
+    private key: Partial<T>,
+  ) {
     const keys = this.parent.getKeys();
     let pkName = keys.primary.name;
     let builtKey = this.parent.buildKey(this.key) as Record<string, any>;
-  
-    this.expressionAttributeNames['#pk'] = pkName;
-    this.expressionAttributeValues[':pk_value'] = builtKey[pkName];
+
+    this.expressionAttributeNames["#pk"] = pkName;
+    this.expressionAttributeValues[":pk_value"] = builtKey[pkName];
   }
 
   public usingIndex(indexName: string): this {
     if (!this.parent.getKeys().gsis) {
-      throw new Error('No global secondary indexes defined for this table');
+      throw new Error("No global secondary indexes defined for this table");
     }
     if (!(indexName in this.parent.getKeys().gsis!)) {
-      throw new Error('index does not exist')
+      throw new Error("index does not exist");
     }
-    
+
     this.index = this.parent.getKeys().gsis![indexName];
 
-    const pkName = this.index.primary.name;
+    const pkName = this.index!.primary.name;
     const builtKey = this.parent.buildIndexes(this.key);
-    this.expressionAttributeNames['#pk'] = pkName;
-    this.expressionAttributeValues[':pk_value'] = builtKey[pkName];
+    this.expressionAttributeNames["#pk"] = pkName;
+    this.expressionAttributeValues[":pk_value"] = builtKey[pkName];
 
     return this;
   }
@@ -52,28 +55,32 @@ export class QueryBuilder<T> {
 
   public where(
     operator: Operator,
-    values: Partial<T> | [Partial<T>, Partial<T>]
+    values: Partial<T> | [Partial<T>, Partial<T>],
   ): this {
     const keys = this.parent.getKeys();
     // Determine the sort key name from either the index or the primary keys.
     const sortKeyName = this.index ? this.index.sort?.name : keys.sort?.name;
     if (!sortKeyName) {
-      throw new Error('Sort key is not defined for this table/index.');
+      throw new Error("Sort key is not defined for this table/index.");
     }
-    const nameKey = '#sk';
+    const nameKey = "#sk";
     this.expressionAttributeNames[nameKey] = sortKeyName;
-    
+
     // Enforce that a complex sort key requires an object input.
-    if (typeof values !== 'object' || values === null) {
-      throw new Error(`For complex sort keys, please provide an object with all necessary properties.`);
+    if (typeof values !== "object" || values === null) {
+      throw new Error(
+        `For complex sort keys, please provide an object with all necessary properties.`,
+      );
     }
-    
-    if (operator === 'between') {
+
+    if (operator === "between") {
       if (!Array.isArray(values) || values.length !== 2) {
-        throw new Error(`For 'between' operator, values must be a tuple of two objects`);
+        throw new Error(
+          `For 'between' operator, values must be a tuple of two objects`,
+        );
       }
-      const valueKeyStart = ':sk_start';
-      const valueKeyEnd = ':sk_end';
+      const valueKeyStart = ":sk_start";
+      const valueKeyEnd = ":sk_end";
       // Use the key definition's build function to build the key from the full object.
       this.expressionAttributeValues[valueKeyStart] = this.index
         ? this.parent.buildIndexes(values[0])[sortKeyName]
@@ -81,16 +88,18 @@ export class QueryBuilder<T> {
       this.expressionAttributeValues[valueKeyEnd] = this.index
         ? this.parent.buildIndexes(values[1])[sortKeyName]
         : this.parent.buildKey(values[1])[sortKeyName];
-      this.keyConditions.push(`${nameKey} BETWEEN ${valueKeyStart} AND ${valueKeyEnd}`);
-    } else if (operator === 'begins_with') {
-      const valueKey = ':sk_value';
+      this.keyConditions.push(
+        `${nameKey} BETWEEN ${valueKeyStart} AND ${valueKeyEnd}`,
+      );
+    } else if (operator === "begins_with") {
+      const valueKey = ":sk_value";
       this.expressionAttributeValues[valueKey] = this.index
         ? this.parent.buildIndexes(values as Partial<T>)[sortKeyName]
         : this.parent.buildKey(values as Partial<T>)[sortKeyName];
       this.keyConditions.push(`begins_with(${nameKey}, ${valueKey})`);
     } else {
       // For eq, lt, lte, gt, gte:
-      const valueKey = ':sk_value';
+      const valueKey = ":sk_value";
       this.expressionAttributeValues[valueKey] = this.index
         ? this.parent.buildIndexes(values as Partial<T>)[sortKeyName]
         : this.parent.buildKey(values as Partial<T>)[sortKeyName];
@@ -99,36 +108,43 @@ export class QueryBuilder<T> {
     }
     return this;
   }
-  
-
-
 
   public filter(
     attribute: keyof T,
     operator: Operator,
-    values: any | [any, any]
+    values: any | [any, any],
   ): this {
     const attrStr = String(attribute);
     const randomString = Math.random().toString(36).substring(2, 15);
     const placeholderName = `#attr_${attrStr}_${randomString}`;
     this.expressionAttributeNames[placeholderName] = attrStr;
-    if (operator === 'between') {
+    if (operator === "between") {
       if (!Array.isArray(values) || values.length !== 2) {
-        throw new Error("For 'between' operator, values must be a tuple of two items");
+        throw new Error(
+          "For 'between' operator, values must be a tuple of two items",
+        );
       }
       const placeholderValueStart = `:val_start_${attrStr}_${randomString}`;
       const placeholderValueEnd = `:val_end_${attrStr}_${randomString}`;
       this.expressionAttributeValues[placeholderValueStart] = values[0];
       this.expressionAttributeValues[placeholderValueEnd] = values[1];
-      this.filterConditions.push(`${placeholderName} BETWEEN ${placeholderValueStart} AND ${placeholderValueEnd}`);
-    } else if (operator === 'begins_with' || operator === 'contains') {
+      this.filterConditions.push(
+        `${placeholderName} BETWEEN ${placeholderValueStart} AND ${placeholderValueEnd}`,
+      );
+    } else if (operator === "begins_with" || operator === "contains") {
       const placeholderValue = `:val_${attrStr}_${randomString}`;
       this.expressionAttributeValues[placeholderValue] = values;
-      this.filterConditions.push(`${operator}(${placeholderName}, ${placeholderValue})`);
+      this.filterConditions.push(
+        `${operator}(${placeholderName}, ${placeholderValue})`,
+      );
     } else {
       const placeholderValue = `:val_${attrStr}_${randomString}`;
       this.expressionAttributeValues[placeholderValue] = values;
-      const condition = getOperatorExpression(operator, placeholderName, placeholderValue);
+      const condition = getOperatorExpression(
+        operator,
+        placeholderName,
+        placeholderValue,
+      );
       this.filterConditions.push(condition);
     }
 
@@ -150,7 +166,7 @@ export class QueryBuilder<T> {
    */
   public async execute(): Promise<PaginatedResult<T>> {
     this.keyConditions.unshift(`#pk = :pk_value`);
-    const keyConditionExpression = this.keyConditions.join(' AND ');
+    const keyConditionExpression = this.keyConditions.join(" AND ");
 
     const params: QueryCommandInput = {
       TableName: this.parent.getTableName(),
@@ -165,12 +181,16 @@ export class QueryBuilder<T> {
 
     if (this.parent.getEntityType()) {
       this.filterConditions.push(`#entity = :entity_value`);
-      this.expressionAttributeNames['#entity'] = 'entityType';
-      this.expressionAttributeValues[':entity_value'] = this.parent.getEntityType();
+      this.expressionAttributeNames["#entity"] = "entityType";
+      this.expressionAttributeValues[":entity_value"] =
+        this.parent.getEntityType();
     }
-    params.FilterExpression = this.filterConditions.join(' AND ');
+    params.FilterExpression = this.filterConditions.join(" AND ");
 
     const result = await this.parent.getClient().send(new QueryCommand(params));
-    return {items: this.parent.getSchema().array().parse(result.Items) as T[], lastKey: result.LastEvaluatedKey ?? undefined};
+    return {
+      items: this.parent.getSchema().array().parse(result.Items) as T[],
+      lastKey: result.LastEvaluatedKey ?? undefined,
+    };
   }
 }

package/src/builders/scan-builder.ts

@@ -1,7 +1,7 @@
-import { ScanCommand, ScanCommandInput } from '@aws-sdk/lib-dynamodb';
-import { BetterDDB } from '../betterddb';
-import { getOperatorExpression, Operator } from '../operator';
-import { PaginatedResult } from '../types/paginated-result';
+import { ScanCommand, ScanCommandInput } from "@aws-sdk/lib-dynamodb";
+import { BetterDDB } from "../betterddb";
+import { getOperatorExpression, Operator } from "../operator";
+import { PaginatedResult } from "../types/paginated-result";
 
 export class ScanBuilder<T> {
   private filters: string[] = [];
@@ -15,16 +15,16 @@ export class ScanBuilder<T> {
   public where(
     attribute: keyof T,
     operator: Operator,
-    values: any | [any, any]
+    values: any | [any, any],
   ): this {
     const attrStr = String(attribute);
     const nameKey = `#attr_${attrStr}`;
     this.expressionAttributeNames[nameKey] = attrStr;
 
-    if (operator === 'between') {
+    if (operator === "between") {
       if (!Array.isArray(values) || values.length !== 2) {
         throw new Error(
-          `For 'between' operator, values must be a tuple of two items`
+          `For 'between' operator, values must be a tuple of two items`,
         );
       }
       const valueKeyStart = `:val_start_${attrStr}`;
@@ -32,9 +32,9 @@ export class ScanBuilder<T> {
       this.expressionAttributeValues[valueKeyStart] = values[0];
       this.expressionAttributeValues[valueKeyEnd] = values[1];
       this.filters.push(
-        `${nameKey} BETWEEN ${valueKeyStart} AND ${valueKeyEnd}`
+        `${nameKey} BETWEEN ${valueKeyStart} AND ${valueKeyEnd}`,
       );
-    } else if (operator === 'begins_with' || operator === 'contains') {
+    } else if (operator === "begins_with" || operator === "contains") {
       const valueKey = `:val_${attrStr}`;
       this.expressionAttributeValues[valueKey] = values;
       this.filters.push(`${operator}(${nameKey}, ${valueKey})`);
@@ -66,18 +66,22 @@ export class ScanBuilder<T> {
       ExpressionAttributeNames: this.expressionAttributeNames,
       ExpressionAttributeValues: this.expressionAttributeValues,
       Limit: this.limit,
-      ExclusiveStartKey: this.lastKey
+      ExclusiveStartKey: this.lastKey,
     };
 
     if (this.parent.getEntityType()) {
       this.filters.push(`#entity = :entity_value`);
-      this.expressionAttributeNames['#entity'] = 'entityType';
-      this.expressionAttributeValues[':entity_value'] = this.parent.getEntityType();
+      this.expressionAttributeNames["#entity"] = "entityType";
+      this.expressionAttributeValues[":entity_value"] =
+        this.parent.getEntityType();
     }
-    params.FilterExpression = this.filters.join(' AND ');
+    params.FilterExpression = this.filters.join(" AND ");
 
     const result = await this.parent.getClient().send(new ScanCommand(params));
 
-    return {items: this.parent.getSchema().array().parse(result.Items) as T[], lastKey: result.LastEvaluatedKey ?? undefined};
+    return {
+      items: this.parent.getSchema().array().parse(result.Items) as T[],
+      lastKey: result.LastEvaluatedKey ?? undefined,
+    };
   }
 }