betterddb 0.4.1 → 0.4.3

package/lib/betterddb.d.ts

@@ -1,64 +1,129 @@
-import { z } from 'zod';
-import { DynamoDB } from 'aws-sdk';
+import { ZodSchema } from 'zod';
 import { QueryBuilder } from './builders/query-builder';
 import { ScanBuilder } from './builders/scan-builder';
 import { UpdateBuilder } from './builders/update-builder';
 import { CreateBuilder } from './builders/create-builder';
 import { GetBuilder } from './builders/get-builder';
 import { DeleteBuilder } from './builders/delete-builder';
-export type SchemaType<S extends z.ZodType<any>> = z.infer<S>;
+import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
 export type PrimaryKeyValue = string | number;
-export type KeyDefinition<S extends z.ZodType<any>> = keyof SchemaType<S> | {
-    build: (rawKey: Partial<SchemaType<S>>) => string;
+/**
+ * A key definition can be either a simple key (a property name)
+ * or an object containing a build function that computes the value.
+ * (In this design, the attribute name is provided separately.)
+ */
+export type KeyDefinition<T> = keyof T | {
+    build: (rawKey: Partial<T>) => string;
 };
-export interface PrimaryKeyConfig<S extends z.ZodType<any>> {
+/**
+ * Configuration for a primary (partition) key.
+ */
+export interface PrimaryKeyConfig<T> {
+    /** The attribute name for the primary key in DynamoDB */
     name: string;
-    definition: KeyDefinition<S>;
+    /** How to compute the key value; if a keyof T, then the raw value is used;
+     * if an object, the build function is used.
+     */
+    definition: KeyDefinition<T>;
 }
-export interface SortKeyConfig<S extends z.ZodType<any>> {
+/**
+ * Configuration for a sort key.
+ */
+export interface SortKeyConfig<T> {
+    /** The attribute name for the sort key in DynamoDB */
     name: string;
-    definition: KeyDefinition<S>;
+    /** How to compute the sort key value */
+    definition: KeyDefinition<T>;
 }
-export interface GSIConfig<S extends z.ZodType<any>> {
+/**
+ * Configuration for a Global Secondary Index (GSI).
+ */
+export interface GSIConfig<T> {
+    /** The name of the GSI in DynamoDB */
     name: string;
-    primary: PrimaryKeyConfig<S>;
-    sort?: SortKeyConfig<S>;
+    /** The primary key configuration for the GSI */
+    primary: PrimaryKeyConfig<T>;
+    /** The sort key configuration for the GSI, if any */
+    sort?: SortKeyConfig<T>;
 }
-export interface KeysConfig<S extends z.ZodType<any>> {
-    primary: PrimaryKeyConfig<S>;
-    sort?: SortKeyConfig<S>;
+/**
+ * Keys configuration for the table.
+ */
+export interface KeysConfig<T> {
+    primary: PrimaryKeyConfig<T>;
+    sort?: SortKeyConfig<T>;
     gsis?: {
-        [gsiName: string]: GSIConfig<S>;
+        [gsiName: string]: GSIConfig<T>;
     };
 }
-export interface BetterDDBOptions<S extends z.ZodType<any>> {
-    schema: S;
+/**
+ * Options for initializing BetterDDB.
+ */
+export interface BetterDDBOptions<T> {
+    schema: ZodSchema;
     tableName: string;
     entityName: string;
-    keys: KeysConfig<S>;
-    client: DynamoDB.DocumentClient;
+    keys: KeysConfig<T>;
+    client: DynamoDBDocumentClient;
+    /**
+     * If true, automatically inject timestamp fields:
+     * - On create, sets both `createdAt` and `updatedAt`
+     * - On update, sets `updatedAt`
+     *
+     * (T should include these fields if enabled.)
+     */
     autoTimestamps?: boolean;
 }
-export declare class BetterDDB<S extends z.ZodType<any>> {
-    protected schema: S;
+/**
+ * BetterDDB is a definition-based DynamoDB wrapper library.
+ */
+export declare class BetterDDB<T> {
+    protected schema: ZodSchema;
     protected tableName: string;
     protected entityName: string;
-    protected client: DynamoDB.DocumentClient;
-    protected keys: KeysConfig<S>;
+    protected client: DynamoDBDocumentClient;
+    protected keys: KeysConfig<T>;
     protected autoTimestamps: boolean;
-    constructor(options: BetterDDBOptions<S>);
-    getKeys(): KeysConfig<S>;
+    constructor(options: BetterDDBOptions<T>);
+    getKeys(): KeysConfig<T>;
     getTableName(): string;
-    getClient(): DynamoDB.DocumentClient;
-    getSchema(): S;
+    getClient(): DynamoDBDocumentClient;
+    getSchema(): ZodSchema;
     getAutoTimestamps(): boolean;
-    protected getKeyValue(def: KeyDefinition<S>, rawKey: Partial<SchemaType<S>>): string;
-    buildKey(rawKey: Partial<SchemaType<S>>): Record<string, any>;
-    buildIndexes(rawItem: Partial<SchemaType<S>>): Record<string, any>;
-    create(item: SchemaType<S>): CreateBuilder<SchemaType<S>>;
-    get(rawKey: Partial<SchemaType<S>>): GetBuilder<SchemaType<S>>;
-    update(key: Partial<SchemaType<S>>, expectedVersion?: number): UpdateBuilder<SchemaType<S>>;
-    delete(rawKey: Partial<SchemaType<S>>): DeleteBuilder<SchemaType<S>>;
-    query(key: Partial<SchemaType<S>>): QueryBuilder<SchemaType<S>>;
-    scan(): ScanBuilder<SchemaType<S>>;
+    protected getKeyValue(def: KeyDefinition<T>, rawKey: Partial<T>): string;
+    /**
+     * Build the primary key from a raw key object.
+     */
+    buildKey(rawKey: Partial<T>): Record<string, any>;
+    /**
+     * Build index attributes for each defined GSI.
+     */
+    buildIndexes(rawItem: Partial<T>): Record<string, any>;
+    /**
+     * Create an item:
+     * - Computes primary key and index attributes,
+     * - Optionally injects timestamps,
+     * - Validates the item and writes it to DynamoDB.
+     */
+    create(item: T): CreateBuilder<T>;
+    /**
+     * Get an item by its primary key.
+     */
+    get(rawKey: Partial<T>): GetBuilder<T>;
+    /**
+     * Update an item.
+     */
+    update(key: Partial<T>, expectedVersion?: number): UpdateBuilder<T>;
+    /**
+     * Delete an item.
+     */
+    delete(rawKey: Partial<T>): DeleteBuilder<T>;
+    /**
+     * Query items.
+     */
+    query(key: Partial<T>): QueryBuilder<T>;
+    /**
+     * Scan for items.
+     */
+    scan(): ScanBuilder<T>;
 }

package/lib/betterddb.js

@@ -7,15 +7,18 @@ const update_builder_1 = require("./builders/update-builder");
 const create_builder_1 = require("./builders/create-builder");
 const get_builder_1 = require("./builders/get-builder");
 const delete_builder_1 = require("./builders/delete-builder");
+/**
+ * BetterDDB is a definition-based DynamoDB wrapper library.
+ */
 class BetterDDB {
     constructor(options) {
         var _a;
         this.schema = options.schema;
         this.tableName = options.tableName;
         this.entityName = options.entityName.toUpperCase();
+        this.keys = options.keys;
         this.client = options.client;
         this.autoTimestamps = (_a = options.autoTimestamps) !== null && _a !== void 0 ? _a : false;
-        this.keys = options.keys;
     }
     getKeys() {
         return this.keys;
@@ -32,49 +35,106 @@ class BetterDDB {
     getAutoTimestamps() {
         return this.autoTimestamps;
     }
+    // Helper: Retrieve the key value from a KeyDefinition.
     getKeyValue(def, rawKey) {
         if (typeof def === 'string' || typeof def === 'number' || typeof def === 'symbol') {
             return String(rawKey[def]);
         }
-        return def.build(rawKey);
+        else {
+            return def.build(rawKey);
+        }
     }
+    /**
+     * Build the primary key from a raw key object.
+     */
     buildKey(rawKey) {
         const keyObj = {};
-        const { primary, sort } = this.keys;
-        keyObj[primary.name] = this.getKeyValue(primary.definition, rawKey);
-        if (sort) {
-            keyObj[sort.name] = this.getKeyValue(sort.definition, rawKey);
+        // For primary (partition) key:
+        const pkConfig = this.keys.primary;
+        keyObj[pkConfig.name] =
+            (typeof pkConfig.definition === 'string' ||
+                typeof pkConfig.definition === 'number' ||
+                typeof pkConfig.definition === 'symbol')
+                ? String(rawKey[pkConfig.definition])
+                : pkConfig.definition.build(rawKey);
+        // For sort key, if defined:
+        if (this.keys.sort) {
+            const skConfig = this.keys.sort;
+            keyObj[skConfig.name] =
+                (typeof skConfig.definition === 'string' ||
+                    typeof skConfig.definition === 'number' ||
+                    typeof skConfig.definition === 'symbol')
+                    ? String(rawKey[skConfig.definition])
+                    : skConfig.definition.build(rawKey);
         }
         return keyObj;
     }
+    /**
+     * Build index attributes for each defined GSI.
+     */
     buildIndexes(rawItem) {
         const indexAttributes = {};
         if (this.keys.gsis) {
-            Object.entries(this.keys.gsis).forEach(([_, gsiConfig]) => {
-                const { primary, sort } = gsiConfig;
-                indexAttributes[primary.name] = this.getKeyValue(primary.definition, rawItem);
-                if (sort) {
-                    indexAttributes[sort.name] = this.getKeyValue(sort.definition, rawItem);
+            for (const gsiName in this.keys.gsis) {
+                const gsiConfig = this.keys.gsis[gsiName];
+                // Compute primary index attribute.
+                const primaryConfig = gsiConfig.primary;
+                indexAttributes[primaryConfig.name] =
+                    (typeof primaryConfig.definition === 'string' ||
+                        typeof primaryConfig.definition === 'number' ||
+                        typeof primaryConfig.definition === 'symbol')
+                        ? String(rawItem[primaryConfig.definition])
+                        : primaryConfig.definition.build(rawItem);
+                // Compute sort index attribute if provided.
+                if (gsiConfig.sort) {
+                    const sortConfig = gsiConfig.sort;
+                    indexAttributes[sortConfig.name] =
+                        (typeof sortConfig.definition === 'string' ||
+                            typeof sortConfig.definition === 'number' ||
+                            typeof sortConfig.definition === 'symbol')
+                            ? String(rawItem[sortConfig.definition])
+                            : sortConfig.definition.build(rawItem);
                 }
-            });
+            }
         }
         return indexAttributes;
     }
+    /**
+     * Create an item:
+     * - Computes primary key and index attributes,
+     * - Optionally injects timestamps,
+     * - Validates the item and writes it to DynamoDB.
+     */
     create(item) {
         return new create_builder_1.CreateBuilder(this, item);
     }
+    /**
+     * Get an item by its primary key.
+     */
     get(rawKey) {
         return new get_builder_1.GetBuilder(this, rawKey);
     }
+    /**
+     * Update an item.
+     */
     update(key, expectedVersion) {
         return new update_builder_1.UpdateBuilder(this, key, expectedVersion);
     }
+    /**
+     * Delete an item.
+     */
     delete(rawKey) {
         return new delete_builder_1.DeleteBuilder(this, rawKey);
     }
+    /**
+     * Query items.
+     */
     query(key) {
         return new query_builder_1.QueryBuilder(this, key);
     }
+    /**
+     * Scan for items.
+     */
     scan() {
         return new scan_builder_1.ScanBuilder(this);
     }

package/lib/builders/create-builder.d.ts

@@ -1,15 +1,14 @@
-import { DynamoDB } from 'aws-sdk';
+import { TransactWriteItem } from '@aws-sdk/client-dynamodb';
 import { BetterDDB } from '../betterddb';
-import { z } from 'zod';
-export declare class CreateBuilder<S extends z.ZodType<any>> {
+export declare class CreateBuilder<T> {
     private parent;
     private item;
     private extraTransactItems;
-    constructor(parent: BetterDDB<S>, item: S);
-    execute(): Promise<S>;
-    transactWrite(ops: DynamoDB.DocumentClient.TransactWriteItemList | DynamoDB.DocumentClient.TransactWriteItem): this;
-    toTransactPut(): DynamoDB.DocumentClient.TransactWriteItem;
-    then<TResult1 = S, TResult2 = never>(onfulfilled?: ((value: S) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
-    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<S | TResult>;
-    finally(onfinally?: (() => void) | null): Promise<S>;
+    constructor(parent: BetterDDB<T>, item: T);
+    execute(): Promise<T>;
+    transactWrite(ops: TransactWriteItem[] | TransactWriteItem): this;
+    toTransactPut(): TransactWriteItem;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<T>;
 }

package/lib/builders/create-builder.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateBuilder = void 0;
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
 class CreateBuilder {
     constructor(parent, item) {
         this.parent = parent;
@@ -13,9 +14,9 @@ class CreateBuilder {
             const myTransactItem = this.toTransactPut();
             // Combine with extra transaction items.
             const allItems = [...this.extraTransactItems, myTransactItem];
-            await this.parent.getClient().transactWrite({
+            await this.parent.getClient().send(new lib_dynamodb_1.TransactWriteCommand({
                 TransactItems: allItems
-            }).promise();
+            }));
             // After transaction, retrieve the updated item.
             const result = await this.parent.get(this.item).execute();
             if (result === null) {
@@ -38,10 +39,10 @@ class CreateBuilder {
             // Compute and merge index attributes.
             const indexAttributes = this.parent.buildIndexes(validated);
             finalItem = { ...finalItem, ...indexAttributes };
-            await this.parent.getClient().put({
+            await this.parent.getClient().send(new lib_dynamodb_1.PutCommand({
                 TableName: this.parent.getTableName(),
                 Item: finalItem
-            }).promise();
+            }));
             return validated;
         }
     }

package/lib/builders/delete-builder.d.ts

@@ -1,19 +1,18 @@
-import { DynamoDB } from 'aws-sdk';
 import { BetterDDB } from '../betterddb';
-import { z } from 'zod';
-export declare class DeleteBuilder<S extends z.ZodType<any>> {
+import { TransactWriteItem } from '@aws-sdk/client-dynamodb';
+export declare class DeleteBuilder<T> {
     private parent;
     private key;
     private condition?;
     private extraTransactItems;
-    constructor(parent: BetterDDB<S>, key: Partial<S>);
+    constructor(parent: BetterDDB<T>, key: Partial<T>);
     /**
      * Specify a condition expression for the delete operation.
      */
     withCondition(expression: string, attributeValues: Record<string, any>): this;
     execute(): Promise<void>;
-    transactWrite(ops: DynamoDB.DocumentClient.TransactWriteItemList | DynamoDB.DocumentClient.TransactWriteItem): this;
-    toTransactDelete(): DynamoDB.DocumentClient.TransactWriteItem;
+    transactWrite(ops: TransactWriteItem[] | TransactWriteItem): this;
+    toTransactDelete(): TransactWriteItem;
     then<TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
     catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<void | TResult>;
     finally(onfinally?: (() => void) | null): Promise<void>;

package/lib/builders/delete-builder.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeleteBuilder = void 0;
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
 class DeleteBuilder {
     constructor(parent, key) {
         this.parent = parent;
@@ -26,9 +27,9 @@ class DeleteBuilder {
             const myTransactItem = this.toTransactDelete();
             // Combine with extra transaction items.
             const allItems = [...this.extraTransactItems, myTransactItem];
-            await this.parent.getClient().transactWrite({
+            await this.parent.getClient().send(new lib_dynamodb_1.TransactWriteCommand({
                 TransactItems: allItems
-            }).promise();
+            }));
             // After transaction, retrieve the updated item.
             const result = await this.parent.get(this.key).execute();
             if (result === null) {
@@ -44,7 +45,7 @@ class DeleteBuilder {
                 params.ConditionExpression = this.condition.expression;
                 params.ExpressionAttributeValues = this.condition.attributeValues;
             }
-            await this.parent.getClient().delete(params).promise();
+            await this.parent.getClient().send(new lib_dynamodb_1.DeleteCommand(params));
         }
     }
     transactWrite(ops) {

package/lib/builders/get-builder.d.ts

@@ -1,21 +1,20 @@
-import { DynamoDB } from 'aws-sdk';
 import { BetterDDB } from '../betterddb';
-import { z } from 'zod';
-export declare class GetBuilder<S extends z.ZodType<any>> {
+import { TransactGetItem } from '@aws-sdk/client-dynamodb';
+export declare class GetBuilder<T> {
     private parent;
     private key;
     private projectionExpression?;
     private expressionAttributeNames;
     private extraTransactItems;
-    constructor(parent: BetterDDB<S>, key: Partial<S>);
+    constructor(parent: BetterDDB<T>, key: Partial<T>);
     /**
      * Specify a projection by providing an array of attribute names.
      */
-    withProjection(attributes: (keyof S)[]): this;
-    execute(): Promise<S | null>;
-    transactGet(ops: DynamoDB.DocumentClient.TransactGetItemList | DynamoDB.DocumentClient.TransactGetItem): this;
-    toTransactGet(): DynamoDB.DocumentClient.TransactGetItem;
-    then<TResult1 = S | null, TResult2 = never>(onfulfilled?: ((value: S | null) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
-    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<S | null | TResult>;
-    finally(onfinally?: (() => void) | null): Promise<S | null>;
+    withProjection(attributes: (keyof T)[]): this;
+    execute(): Promise<T | null>;
+    transactGet(ops: TransactGetItem[] | TransactGetItem): this;
+    toTransactGet(): TransactGetItem;
+    then<TResult1 = T | null, TResult2 = never>(onfulfilled?: ((value: T | null) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | null | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<T | null>;
 }

package/lib/builders/get-builder.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetBuilder = void 0;
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
 class GetBuilder {
     constructor(parent, key) {
         this.parent = parent;
@@ -24,9 +25,9 @@ class GetBuilder {
             const myTransactItem = this.toTransactGet();
             // Combine with extra transaction items.
             const allItems = [...this.extraTransactItems, myTransactItem];
-            await this.parent.getClient().transactGet({
+            await this.parent.getClient().send(new lib_dynamodb_1.TransactGetCommand({
                 TransactItems: allItems
-            }).promise();
+            }));
             // After transaction, retrieve the updated item.
             const result = await this.parent.get(this.key).execute();
             return result;
@@ -40,7 +41,7 @@ class GetBuilder {
                 params.ProjectionExpression = this.projectionExpression;
                 params.ExpressionAttributeNames = this.expressionAttributeNames;
             }
-            const result = await this.parent.getClient().get(params).promise();
+            const result = await this.parent.getClient().send(new lib_dynamodb_1.GetCommand(params));
             if (!result.Item)
                 return null;
             return this.parent.getSchema().parse(result.Item);

package/lib/builders/query-builder.d.ts

@@ -1,6 +1,5 @@
 import { BetterDDB } from '../betterddb';
-import { z } from 'zod';
-export declare class QueryBuilder<S extends z.ZodType<any>> {
+export declare class QueryBuilder<T> {
     private parent;
     private key;
     private filters;
@@ -11,18 +10,18 @@ export declare class QueryBuilder<S extends z.ZodType<any>> {
     private limit?;
     private lastKey?;
     private ascending;
-    constructor(parent: BetterDDB<S>, key: Partial<S>);
+    constructor(parent: BetterDDB<T>, key: Partial<T>);
     usingIndex(indexName: string): this;
     sortAscending(): this;
     sortDescending(): this;
-    where(attribute: keyof S, operator: 'eq' | 'begins_with' | 'between', values: any | [any, any]): this;
+    where(attribute: keyof T, operator: 'eq' | 'begins_with' | 'between', values: any | [any, any]): this;
     limitResults(limit: number): this;
     startFrom(lastKey: Record<string, any>): this;
     /**
      * Executes the query and returns a Promise that resolves with an array of items.
      */
-    execute(): Promise<S[]>;
-    then<TResult1 = S[], TResult2 = never>(onfulfilled?: ((value: S[]) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
-    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<S[] | TResult>;
-    finally(onfinally?: (() => void) | null): Promise<S[]>;
+    execute(): Promise<T[]>;
+    then<TResult1 = T[], TResult2 = never>(onfulfilled?: ((value: T[]) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T[] | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<T[]>;
 }

package/lib/builders/query-builder.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryBuilder = void 0;
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
 class QueryBuilder {
     constructor(parent, key) {
         this.parent = parent;
@@ -89,7 +90,7 @@ class QueryBuilder {
         if (this.filters.length > 0) {
             params.FilterExpression = this.filters.join(' AND ');
         }
-        const result = await this.parent.getClient().query(params).promise();
+        const result = await this.parent.getClient().send(new lib_dynamodb_1.QueryCommand(params));
         return this.parent.getSchema().array().parse(result.Items);
     }
     // Thenable implementation.

package/lib/builders/scan-builder.d.ts

@@ -1,21 +1,20 @@
 import { BetterDDB } from '../betterddb';
-import { z } from 'zod';
-export declare class ScanBuilder<S extends z.ZodType<any>> {
+export declare class ScanBuilder<T> {
     private parent;
     private filters;
     private expressionAttributeNames;
     private expressionAttributeValues;
     private limit?;
     private lastKey?;
-    constructor(parent: BetterDDB<S>);
-    where(attribute: keyof S, operator: 'eq' | 'begins_with' | 'between', values: any | [any, any]): this;
+    constructor(parent: BetterDDB<T>);
+    where(attribute: keyof T, operator: 'eq' | 'begins_with' | 'between', values: any | [any, any]): this;
     limitResults(limit: number): this;
     startFrom(lastKey: Record<string, any>): this;
     /**
      * Executes the scan and returns a Promise that resolves with an array of items.
      */
-    execute(): Promise<S[]>;
-    then<TResult1 = S[], TResult2 = never>(onfulfilled?: ((value: S[]) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
-    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<S[] | TResult>;
-    finally(onfinally?: (() => void) | null): Promise<S[]>;
+    execute(): Promise<T[]>;
+    then<TResult1 = T[], TResult2 = never>(onfulfilled?: ((value: T[]) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T[] | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<T[]>;
 }

package/lib/builders/scan-builder.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScanBuilder = void 0;
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
 class ScanBuilder {
     constructor(parent) {
         this.parent = parent;
@@ -59,7 +60,7 @@ class ScanBuilder {
         if (this.filters.length > 0) {
             params.FilterExpression = this.filters.join(' AND ');
         }
-        const result = await this.parent.getClient().scan(params).promise();
+        const result = await this.parent.getClient().send(new lib_dynamodb_1.ScanCommand(params));
         return this.parent.getSchema().array().parse(result.Items);
     }
     // Thenable implementation.

package/lib/builders/update-builder.d.ts

@@ -1,18 +1,17 @@
-import { DynamoDB } from 'aws-sdk';
 import { BetterDDB } from '../betterddb';
-import { z } from 'zod';
-export declare class UpdateBuilder<S extends z.ZodType<any>> {
+import { TransactWriteItem } from '@aws-sdk/client-dynamodb';
+export declare class UpdateBuilder<T> {
     private parent;
     private key;
     private actions;
     private condition?;
     private expectedVersion?;
     private extraTransactItems;
-    constructor(parent: BetterDDB<S>, key: Partial<S>, expectedVersion?: number);
-    set(attrs: Partial<S>): this;
-    remove(attrs: (keyof S)[]): this;
-    add(attrs: Partial<Record<keyof S, number | Set<any>>>): this;
-    delete(attrs: Partial<Record<keyof S, Set<any>>>): this;
+    constructor(parent: BetterDDB<T>, key: Partial<T>, expectedVersion?: number);
+    set(attrs: Partial<T>): this;
+    remove(attrs: (keyof T)[]): this;
+    add(attrs: Partial<Record<keyof T, number | Set<any>>>): this;
+    delete(attrs: Partial<Record<keyof T, Set<any>>>): this;
     /**
      * Adds a condition expression to the update.
      */
@@ -20,7 +19,7 @@ export declare class UpdateBuilder<S extends z.ZodType<any>> {
     /**
      * Specifies additional transaction items to include when executing this update as a transaction.
      */
-    transactWrite(ops: DynamoDB.DocumentClient.TransactWriteItemList | DynamoDB.DocumentClient.TransactWriteItem): this;
+    transactWrite(ops: TransactWriteItem[] | TransactWriteItem): this;
     /**
      * Builds the update expression and associated maps.
      */
@@ -28,9 +27,9 @@ export declare class UpdateBuilder<S extends z.ZodType<any>> {
     /**
      * Returns a transaction update item that can be included in a transactWrite call.
      */
-    toTransactUpdate(): DynamoDB.DocumentClient.TransactWriteItem;
+    toTransactUpdate(): TransactWriteItem;
     /**
      * Commits the update immediately by calling the parent's update method.
      */
-    execute(): Promise<S>;
+    execute(): Promise<T>;
 }