betterddb 0.6.1 → 0.6.4

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,
+    };
   }
 }

package/src/builders/update-builder.ts

@@ -1,9 +1,11 @@
-
-
-import { TransactWriteCommand, UpdateCommand } from '@aws-sdk/lib-dynamodb';
-import { BetterDDB } from '../betterddb';
-import { TransactWriteItem, Update, UpdateItemInput } from '@aws-sdk/client-dynamodb';
-import { z } from 'zod';
+import { TransactWriteCommand, UpdateCommand } from "@aws-sdk/lib-dynamodb";
+import { BetterDDB } from "../betterddb";
+import {
+  TransactWriteItem,
+  Update,
+  UpdateItemInput,
+} from "@aws-sdk/client-dynamodb";
+import { z } from "zod";
 interface UpdateActions<T> {
   set?: Partial<T>;
   remove?: (keyof T)[];
@@ -13,16 +15,24 @@ interface UpdateActions<T> {
 
 export class UpdateBuilder<T> {
   private actions: UpdateActions<T> = {};
-  private condition?: { expression: string; attributeValues: Record<string, any> };
+  private condition?: {
+    expression: string;
+    attributeValues: Record<string, any>;
+  };
   // When using transaction mode, we store extra transaction items.
   private extraTransactItems: TransactWriteItem[] = [];
 
   // Reference to the parent BetterDDB instance and key.
-  constructor(private parent: BetterDDB<T>, private key: Partial<T>) {}
+  constructor(
+    private parent: BetterDDB<T>,
+    private key: Partial<T>,
+  ) {}
 
   // Chainable methods:
   public set(attrs: Partial<T>): this {
-    const partialSchema = (this.parent.getSchema() as unknown as z.ZodObject<any>).partial();
+    const partialSchema = (
+      this.parent.getSchema() as unknown as z.ZodObject<any>
+    ).partial();
     const validated = partialSchema.parse(attrs);
     this.actions.set = { ...this.actions.set, ...validated };
     return this;
@@ -34,7 +44,9 @@ export class UpdateBuilder<T> {
   }
 
   public add(attrs: Partial<Record<keyof T, number | Set<any>>>): this {
-    const partialSchema = (this.parent.getSchema() as unknown as z.ZodObject<any>).partial();
+    const partialSchema = (
+      this.parent.getSchema() as unknown as z.ZodObject<any>
+    ).partial();
     const validated = partialSchema.parse(attrs);
     this.actions.add = { ...this.actions.add, ...validated };
     return this;
@@ -48,7 +60,10 @@ export class UpdateBuilder<T> {
   /**
    * Adds a condition expression to the update.
    */
-  public setCondition(expression: string, attributeValues: Record<string, any>): this {
+  public setCondition(
+    expression: string,
+    attributeValues: Record<string, any>,
+  ): this {
     if (this.condition) {
       // Merge conditions with AND.
       this.condition.expression += ` AND ${expression}`;
@@ -94,18 +109,18 @@ export class UpdateBuilder<T> {
         setParts.push(`${nameKey} = ${valueKey}`);
       }
       if (setParts.length > 0) {
-        clauses.push(`SET ${setParts.join(', ')}`);
+        clauses.push(`SET ${setParts.join(", ")}`);
       }
     }
 
     // Build REMOVE clause.
     if (this.actions.remove && this.actions.remove.length > 0) {
-      const removeParts = this.actions.remove.map(attr => {
+      const removeParts = this.actions.remove.map((attr) => {
         const nameKey = `#remove_${String(attr)}`;
         ExpressionAttributeNames[nameKey] = String(attr);
         return nameKey;
       });
-      clauses.push(`REMOVE ${removeParts.join(', ')}`);
+      clauses.push(`REMOVE ${removeParts.join(", ")}`);
     }
 
     // Build ADD clause.
@@ -119,7 +134,7 @@ export class UpdateBuilder<T> {
         addParts.push(`${nameKey} ${valueKey}`);
       }
       if (addParts.length > 0) {
-        clauses.push(`ADD ${addParts.join(', ')}`);
+        clauses.push(`ADD ${addParts.join(", ")}`);
       }
     }
 
@@ -134,7 +149,7 @@ export class UpdateBuilder<T> {
         deleteParts.push(`${nameKey} ${valueKey}`);
       }
       if (deleteParts.length > 0) {
-        clauses.push(`DELETE ${deleteParts.join(', ')}`);
+        clauses.push(`DELETE ${deleteParts.join(", ")}`);
       }
     }
 
@@ -144,9 +159,9 @@ export class UpdateBuilder<T> {
     }
 
     return {
-      updateExpression: clauses.join(' '),
+      updateExpression: clauses.join(" "),
       attributeNames: ExpressionAttributeNames,
-      attributeValues: ExpressionAttributeValues
+      attributeValues: ExpressionAttributeValues,
     };
   }
 
@@ -154,13 +169,14 @@ export class UpdateBuilder<T> {
    * Returns a transaction update item that can be included in a transactWrite call.
    */
   public toTransactUpdate(): TransactWriteItem {
-    const { updateExpression, attributeNames, attributeValues } = this.buildExpression();
+    const { updateExpression, attributeNames, attributeValues } =
+      this.buildExpression();
     const updateItem: Update = {
       TableName: this.parent.getTableName(),
       Key: this.parent.buildKey(this.key),
       UpdateExpression: updateExpression,
       ExpressionAttributeNames: attributeNames,
-      ExpressionAttributeValues: attributeValues
+      ExpressionAttributeValues: attributeValues,
     };
     if (this.condition && this.condition.expression) {
       updateItem.ConditionExpression = this.condition.expression;
@@ -177,32 +193,37 @@ export class UpdateBuilder<T> {
       const myTransactItem = this.toTransactUpdate();
       // 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 update');
+        throw new Error("Item not found after transaction update");
       }
       return result;
     } else {
       // Normal update flow.
-      const { updateExpression, attributeNames, attributeValues } = this.buildExpression();
+      const { updateExpression, attributeNames, attributeValues } =
+        this.buildExpression();
       const params: UpdateItemInput = {
         TableName: this.parent.getTableName(),
         Key: this.parent.buildKey(this.key),
         UpdateExpression: updateExpression,
         ExpressionAttributeNames: attributeNames,
         ExpressionAttributeValues: attributeValues,
-        ReturnValues: 'ALL_NEW'
+        ReturnValues: "ALL_NEW",
       };
       if (this.condition && this.condition.expression) {
         params.ConditionExpression = this.condition.expression;
       }
-      const result = await this.parent.getClient().send(new UpdateCommand(params));
+      const result = await this.parent
+        .getClient()
+        .send(new UpdateCommand(params));
       if (!result.Attributes) {
-        throw new Error('No attributes returned after update');
+        throw new Error("No attributes returned after update");
       }
       return this.parent.getSchema().parse(result.Attributes) as T;
     }

package/src/index.ts

@@ -1 +1 @@
-export * from './betterddb';
+export * from "./betterddb";