betterddb 0.3.0 → 0.4.1

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,33 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm ci
+      - run: npm test
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/README.md

@@ -1,6 +1,8 @@
-# betterddb
+# betterddb [IN DEVELOPMENT - NOT READY FOR PRODUCTION - BREAKING CHANGES - PLEASE FOR THE LOVE OF GOD DO NOT USE]
 
-**betterddb** is a definition-based DynamoDB wrapper library written in TypeScript. It provides a generic, schema-driven Data Access Layer (DAL) using [Zod](https://github.com/colinhacks/zod) for runtime validation and the AWS SDK for DynamoDB operations. With built-in support for compound keys, computed indexes, automatic timestamp injection, transactional and batch operations, and pagination for queries, **betterddb** lets you work with DynamoDB using definitions instead of ad hoc query code.
+**betterddb** is a definition-based DynamoDB wrapper library written in TypeScript. It provides a generic, schema-driven Data Access Layer (DAL) using [Zod](https://github.com/colinhacks/zod) for runtime validation and the AWS SDK for DynamoDB operations. With built-in support for compound keys, computed indexes, automatic timestamp injection, transactional and batch operations, and a fluent builder API for all CRUD operations (create, get, update, delete) as well as queries and scans, **betterddb** lets you work with DynamoDB using definitions instead of ad hoc query code.
+
+---
 
 ## Installation
 
@@ -8,15 +10,18 @@
 npm install betterddb
 ```
 
+---
+
 ## Usage Example
-Below is an example of using betterddb for a User entity with a compound key.
+
+Below is an example of using **betterddb** for a User entity with a compound key, and using the new fluent builder APIs for create, get, update, and delete, as well as for query and scan operations.
 
 ```ts
 import { BetterDDB } from 'betterddb';
 import { z } from 'zod';
 import { DynamoDB } from 'aws-sdk';
 
-// Define the User schema. Use .passthrough() if you want to allow extra keys (e.g. computed keys).
+// Define the User schema. Use .passthrough() to allow computed keys.
 const UserSchema = z.object({
   tenantId: z.string(),
   userId: z.string(),
@@ -25,9 +30,9 @@ const UserSchema = z.object({
   createdAt: z.string(),
   updatedAt: z.string(),
   version: z.number().optional()
-});
+}).passthrough();
 
-// Configure the DynamoDB DocumentClient (for example, using LocalStack)
+// Configure the DynamoDB DocumentClient (example using LocalStack)
 const client = new DynamoDB.DocumentClient({
   region: 'us-east-1',
   endpoint: 'http://localhost:4566'
@@ -40,72 +45,173 @@ const userDdb = new BetterDDB({
   keys: {
     primary: {
       name: 'pk',
-      // Compute the partition key from tenantId
+      // Compute the partition key from tenantId.
       definition: { build: (raw) => `TENANT#${raw.tenantId}` }
     },
     sort: {
       name: 'sk',
-      // Compute the sort key from userId
+      // Compute the sort key from userId.
       definition: { build: (raw) => `USER#${raw.userId}` }
     },
     gsis: {
       // Example: a Global Secondary Index on email.
       EmailIndex: {
-        primary: {
-          name: 'email',
-          definition: 'email'
-        }
+        primary: { name: 'email', definition: 'email' }
       }
     }
   },
   client,
-  autoTimestamps: true
+  autoTimestamps: true,
+  entityName: 'USER'
 });
 
-// Use the BetterDDB instance to create and query items.
 (async () => {
-  // Create a new user.
-  const newUser = await userDdb.create({
+  // ### Create Operation ###
+  // Use the CreateBuilder to build and execute a create operation.
+  const newUser = await userDdb.createBuilder({
     tenantId: 'tenant1',
     userId: 'user123',
     email: 'user@example.com',
     name: 'Alice'
-  });
+  }).execute();
   console.log('Created User:', newUser);
 
-  // Query by primary key with an optional sort key condition.
-  const { items, lastKey } = await userDdb.queryByPrimaryKey(
-    { tenantId: 'tenant1' },
-    { operator: 'begins_with', values: 'USER#user' },
-    { limit: 10 }
-  );
-  console.log('Queried Items:', items);
-  if (lastKey) {
-    console.log('More items available. Use lastKey for pagination:', lastKey);
-  }
+  // ### Get Operation ###
+  // Use the GetBuilder to retrieve an item. Optionally, use a projection.
+  const user = await userDdb.getBuilder({ id: 'user123' })
+    .withProjection(['name', 'email'])
+    .execute();
+  console.log('Retrieved User:', user);
+
+  // ### Update Operation ###
+  // Use the UpdateBuilder to perform a fluent update.
+  const updatedUser = await userDdb.update({ tenantId: 'tenant1', userId: 'user123' }, 1)
+    .set({ name: 'Jane Doe' })
+    .remove(['obsoleteAttribute'])
+    .execute();
+  console.log('Updated User (immediate):', updatedUser);
+
+  // Or build a transaction update item and include it in a transaction:
+  const transactionUpdateItem = userDdb.update({ tenantId: 'tenant1', userId: 'user123' }, 1)
+    .set({ name: 'Jane Doe' })
+    .remove(['obsoleteAttribute'])
+    .toTransactUpdate();
+  // Assume transactWrite is available on BetterDDB for executing a transaction.
+  await userDdb.transactWrite([transactionUpdateItem]);
+  console.log('Updated User (transaction) executed.');
+
+  // ### Delete Operation ###
+  // Use the DeleteBuilder to delete an item with an optional condition.
+  await userDdb.deleteBuilder({ id: 'user123' })
+    .withCondition('#status = :expected', { ':expected': 'inactive' })
+    .execute();
+  console.log('User deleted');
+
+  // ### Query Operation ###
+  // Use the fluent QueryBuilder to query items.
+  const queryResults = await userDdb.query({ tenantId: 'tenant1' })
+    .where('name', 'begins_with', 'John')
+    .limitResults(10);
+  console.log('Query Results:', queryResults);
+
+  // ### Scan Operation ###
+  // Use the fluent ScanBuilder to scan the table with a filter.
+  const scanResults = await userDdb.scan()
+    .where('tenantId', 'eq', 'tenant1')
+    .limitResults(50);
+  console.log('Scan Results:', scanResults);
 })();
 ```
 
-## API
-betterddb exposes a generic class BetterDDB<T> with methods for:
+---
+
+## API Overview
+
+**betterddb** exposes a generic class `BetterDDB<T>` with the following methods:
+
+### Fluent CRUD Builders
+
+- **CreateBuilder**  
+  - `createBuilder(item: T): CreateBuilder<T>`  
+  - Builds a put request with automatic timestamp and key computation.
+  - Usage:  
+    ```ts
+    await betterDdb.createBuilder(item).execute();
+    ```
+
+- **GetBuilder**  
+  - `getBuilder(key: Partial<T>): GetBuilder<T>`  
+  - Builds a get request. Supports projections via `.withProjection()`.
+  - Usage:  
+    ```ts
+    const result = await betterDdb.getBuilder({ id: 'user123' })
+      .withProjection(['name', 'email'])
+      .execute();
+    ```
+
+- **DeleteBuilder**  
+  - `deleteBuilder(key: Partial<T>): DeleteBuilder<T>`  
+  - Builds a delete request. Supports condition expressions via `.withCondition()`.
+  - Usage:  
+    ```ts
+    await betterDdb.deleteBuilder({ id: 'user123' })
+      .withCondition('#status = :expected', { ':expected': 'inactive' })
+      .execute();
+    ```
+
+### Fluent Update Builder
+
+- `update(key: Partial<T>, expectedVersion?: number): UpdateBuilder<T>`  
+  - Provides chainable methods such as `.set()`, `.remove()`, `.add()`, and `.delete()`.
+  - Also supports transaction mode:
+    - `.toTransactUpdate()` returns a transaction item.
+    - `.transactWrite([...])` allows you to combine update items in a transaction.
+  - Usage:
+    ```ts
+    await betterDdb.update({ id: 'user123' }, 1)
+      .set({ name: 'Jane Doe' })
+      .remove(['obsoleteAttribute'])
+      .execute();
+    ```
+
+### Fluent Query & Scan Builders
+
+- **QueryBuilder**  
+  - `query(key: Partial<T>): QueryBuilder<T>`  
+  - Allows you to chain conditions (via `.where()`), sort direction, limits, and pagination.
+  - Usage:
+    ```ts
+    const results = await betterDdb.query({ tenantId: 'tenant1' })
+      .where('name', 'begins_with', 'John')
+      .limitResults(10);
+    ```
+
+- **ScanBuilder**  
+  - `scan(): ScanBuilder<T>`  
+  - Provides a fluent API to filter and paginate scan operations.
+  - Usage:
+    ```ts
+    const results = await betterDdb.scan()
+      .where('tenantId', 'eq', 'tenant1')
+      .limitResults(50);
+    ```
+
+### Batch and Transaction Operations
+
+- **Batch Operations:**
+  - `batchWrite(ops: { puts?: T[]; deletes?: Partial<T>[] }): Promise<void>`
+  - `batchGet(rawKeys: Partial<T>[]): Promise<T[]>`
+
+- **Transaction Helpers:**
+  - `buildTransactPut(item: T)`
+  - `buildTransactUpdate(rawKey: Partial<T>, update: Partial<T>, options?: { expectedVersion?: number })`
+  - `buildTransactDelete(rawKey: Partial<T>)`
+  - `transactWrite(...)` and `transactGetByKeys(...)`
 
-```ts
-create(item: T): Promise<T>
-get(rawKey: Partial<T>): Promise<T | null>
-update(rawKey: Partial<T>, update: Partial<T>, options?: { expectedVersion?: number }): Promise<T>
-delete(rawKey: Partial<T>): Promise<void>
-queryByGsi(gsiName: string, key: Partial<T>, sortKeyCondition?: { operator: "eq" | "begins_with" | "between"; values: any | [any, any] }): Promise<T[]>
-queryByPrimaryKey(rawKey: Partial<T>, sortKeyCondition?: { operator: "eq" | "begins_with" | "between"; values: any | [any, any] }, options?: { limit?: number; lastKey?: Record<string, any> }): Promise<{ items: T[]; lastKey?: Record<string, any> }>
-Batch operations:
-batchWrite(ops: { puts?: T[]; deletes?: Partial<T>[] }): Promise<void>
-batchGet(rawKeys: Partial<T>[]): Promise<T[]>
-Transaction helper methods:
-buildTransactPut(item: T)
-buildTransactUpdate(rawKey: Partial<T>, update: Partial<T>, options?: { expectedVersion?: number })
-buildTransactDelete(rawKey: Partial<T>)
-transactWrite(...) and transactGetByKeys(...)
 For complete details, please refer to the API documentation.
-```
 
-License
+---
+
+## License
+
 MIT

package/lib/betterddb.d.ts

@@ -1,4 +1,4 @@
-import { ZodSchema } from 'zod';
+import { z } from 'zod';
 import { DynamoDB } from 'aws-sdk';
 import { QueryBuilder } from './builders/query-builder';
 import { ScanBuilder } from './builders/scan-builder';
@@ -6,124 +6,59 @@ 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>;
 export type PrimaryKeyValue = string | number;
-/**
- * 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 type KeyDefinition<S extends z.ZodType<any>> = keyof SchemaType<S> | {
+    build: (rawKey: Partial<SchemaType<S>>) => string;
 };
-/**
- * Configuration for a primary (partition) key.
- */
-export interface PrimaryKeyConfig<T> {
-    /** The attribute name for the primary key in DynamoDB */
+export interface PrimaryKeyConfig<S extends z.ZodType<any>> {
     name: string;
-    /** 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>;
+    definition: KeyDefinition<S>;
 }
-/**
- * Configuration for a sort key.
- */
-export interface SortKeyConfig<T> {
-    /** The attribute name for the sort key in DynamoDB */
+export interface SortKeyConfig<S extends z.ZodType<any>> {
     name: string;
-    /** How to compute the sort key value */
-    definition: KeyDefinition<T>;
+    definition: KeyDefinition<S>;
 }
-/**
- * Configuration for a Global Secondary Index (GSI).
- */
-export interface GSIConfig<T> {
-    /** The name of the GSI in DynamoDB */
+export interface GSIConfig<S extends z.ZodType<any>> {
     name: string;
-    /** The primary key configuration for the GSI */
-    primary: PrimaryKeyConfig<T>;
-    /** The sort key configuration for the GSI, if any */
-    sort?: SortKeyConfig<T>;
+    primary: PrimaryKeyConfig<S>;
+    sort?: SortKeyConfig<S>;
 }
-/**
- * Keys configuration for the table.
- */
-export interface KeysConfig<T> {
-    primary: PrimaryKeyConfig<T>;
-    sort?: SortKeyConfig<T>;
+export interface KeysConfig<S extends z.ZodType<any>> {
+    primary: PrimaryKeyConfig<S>;
+    sort?: SortKeyConfig<S>;
     gsis?: {
-        [gsiName: string]: GSIConfig<T>;
+        [gsiName: string]: GSIConfig<S>;
     };
 }
-/**
- * Options for initializing BetterDDB.
- */
-export interface BetterDDBOptions<T> {
-    schema: ZodSchema<T>;
+export interface BetterDDBOptions<S extends z.ZodType<any>> {
+    schema: S;
     tableName: string;
     entityName: string;
-    keys: KeysConfig<T>;
+    keys: KeysConfig<S>;
     client: DynamoDB.DocumentClient;
-    /**
-     * 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;
 }
-/**
- * BetterDDB is a definition-based DynamoDB wrapper library.
- */
-export declare class BetterDDB<T> {
-    protected schema: ZodSchema<T>;
+export declare class BetterDDB<S extends z.ZodType<any>> {
+    protected schema: S;
     protected tableName: string;
     protected entityName: string;
     protected client: DynamoDB.DocumentClient;
-    protected keys: KeysConfig<T>;
+    protected keys: KeysConfig<S>;
     protected autoTimestamps: boolean;
-    constructor(options: BetterDDBOptions<T>);
-    getKeys(): KeysConfig<T>;
+    constructor(options: BetterDDBOptions<S>);
+    getKeys(): KeysConfig<S>;
     getTableName(): string;
     getClient(): DynamoDB.DocumentClient;
-    getSchema(): ZodSchema<T>;
+    getSchema(): S;
     getAutoTimestamps(): boolean;
-    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>;
+    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>>;
 }

package/lib/betterddb.js

@@ -7,18 +7,15 @@ 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;
@@ -35,106 +32,49 @@ 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]);
         }
-        else {
-            return def.build(rawKey);
-        }
+        return def.build(rawKey);
     }
-    /**
-     * Build the primary key from a raw key object.
-     */
     buildKey(rawKey) {
         const keyObj = {};
-        // 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);
+        const { primary, sort } = this.keys;
+        keyObj[primary.name] = this.getKeyValue(primary.definition, rawKey);
+        if (sort) {
+            keyObj[sort.name] = this.getKeyValue(sort.definition, rawKey);
         }
         return keyObj;
     }
-    /**
-     * Build index attributes for each defined GSI.
-     */
     buildIndexes(rawItem) {
         const indexAttributes = {};
         if (this.keys.gsis) {
-            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);
+            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);
                 }
-            }
+            });
         }
         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,14 +1,15 @@
 import { DynamoDB } from 'aws-sdk';
 import { BetterDDB } from '../betterddb';
-export declare class CreateBuilder<T> {
+import { z } from 'zod';
+export declare class CreateBuilder<S extends z.ZodType<any>> {
     private parent;
     private item;
     private extraTransactItems;
-    constructor(parent: BetterDDB<T>, item: T);
-    execute(): Promise<T>;
+    constructor(parent: BetterDDB<S>, item: S);
+    execute(): Promise<S>;
     transactWrite(ops: DynamoDB.DocumentClient.TransactWriteItemList | DynamoDB.DocumentClient.TransactWriteItem): this;
     toTransactPut(): DynamoDB.DocumentClient.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>;
+    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>;
 }

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

@@ -1,11 +1,12 @@
 import { DynamoDB } from 'aws-sdk';
 import { BetterDDB } from '../betterddb';
-export declare class DeleteBuilder<T> {
+import { z } from 'zod';
+export declare class DeleteBuilder<S extends z.ZodType<any>> {
     private parent;
     private key;
     private condition?;
     private extraTransactItems;
-    constructor(parent: BetterDDB<T>, key: Partial<T>);
+    constructor(parent: BetterDDB<S>, key: Partial<S>);
     /**
      * Specify a condition expression for the delete operation.
      */

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

@@ -1,20 +1,21 @@
 import { DynamoDB } from 'aws-sdk';
 import { BetterDDB } from '../betterddb';
-export declare class GetBuilder<T> {
+import { z } from 'zod';
+export declare class GetBuilder<S extends z.ZodType<any>> {
     private parent;
     private key;
     private projectionExpression?;
     private expressionAttributeNames;
     private extraTransactItems;
-    constructor(parent: BetterDDB<T>, key: Partial<T>);
+    constructor(parent: BetterDDB<S>, key: Partial<S>);
     /**
      * Specify a projection by providing an array of attribute names.
      */
-    withProjection(attributes: (keyof T)[]): this;
-    execute(): Promise<T | null>;
+    withProjection(attributes: (keyof S)[]): this;
+    execute(): Promise<S | null>;
     transactGet(ops: DynamoDB.DocumentClient.TransactGetItemList | DynamoDB.DocumentClient.TransactGetItem): this;
     toTransactGet(): DynamoDB.DocumentClient.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>;
+    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>;
 }