betterddb 0.2.0 → 0.3.0

package/lib/betterddb.d.ts

@@ -1,5 +1,11 @@
 import { ZodSchema } from 'zod';
 import { DynamoDB } from 'aws-sdk';
+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 PrimaryKeyValue = string | number;
 /**
  * A key definition can be either a simple key (a property name)
@@ -56,6 +62,7 @@ export interface KeysConfig<T> {
 export interface BetterDDBOptions<T> {
     schema: ZodSchema<T>;
     tableName: string;
+    entityName: string;
     keys: KeysConfig<T>;
     client: DynamoDB.DocumentClient;
     /**
@@ -73,64 +80,50 @@ export interface BetterDDBOptions<T> {
 export declare class BetterDDB<T> {
     protected schema: ZodSchema<T>;
     protected tableName: string;
+    protected entityName: string;
     protected client: DynamoDB.DocumentClient;
     protected keys: KeysConfig<T>;
     protected autoTimestamps: boolean;
     constructor(options: BetterDDBOptions<T>);
+    getKeys(): KeysConfig<T>;
+    getTableName(): string;
+    getClient(): DynamoDB.DocumentClient;
+    getSchema(): ZodSchema<T>;
+    getAutoTimestamps(): boolean;
     protected getKeyValue(def: KeyDefinition<T>, rawKey: Partial<T>): string;
     /**
      * Build the primary key from a raw key object.
      */
-    protected buildKey(rawKey: Partial<T>): Record<string, any>;
+    buildKey(rawKey: Partial<T>): Record<string, any>;
     /**
      * Build index attributes for each defined GSI.
      */
-    protected buildIndexes(rawItem: Partial<T>): Record<string, any>;
+    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): 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[]>;
+    create(item: T): CreateBuilder<T>;
     /**
-     * Query by primary key (using the computed primary key) and an optional sort key condition.
+     * Get an item by its primary key.
      */
-    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>;
-    }>;
-    buildTransactPut(item: T): DynamoDB.DocumentClient.TransactWriteItem;
-    buildTransactUpdate(rawKey: Partial<T>, update: Partial<T>, options?: {
-        expectedVersion?: number;
-    }): DynamoDB.DocumentClient.TransactWriteItem;
-    buildTransactDelete(rawKey: Partial<T>): DynamoDB.DocumentClient.TransactWriteItem;
-    transactWrite(operations: DynamoDB.DocumentClient.TransactWriteItemList): Promise<void>;
-    transactGetByKeys(rawKeys: Partial<T>[]): Promise<T[]>;
-    transactGet(getItems: {
-        TableName: string;
-        Key: any;
-    }[]): Promise<T[]>;
-    batchWrite(ops: {
-        puts?: T[];
-        deletes?: Partial<T>[];
-    }): Promise<void>;
-    private batchWriteChunk;
-    private retryBatchWrite;
-    batchGet(rawKeys: Partial<T>[]): Promise<T[]>;
+    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

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BetterDDB = void 0;
+const query_builder_1 = require("./builders/query-builder");
+const scan_builder_1 = require("./builders/scan-builder");
+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.
  */
@@ -9,10 +15,26 @@ class BetterDDB {
         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;
     }
+    getKeys() {
+        return this.keys;
+    }
+    getTableName() {
+        return this.tableName;
+    }
+    getClient() {
+        return this.client;
+    }
+    getSchema() {
+        return this.schema;
+    }
+    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') {
@@ -83,376 +105,38 @@ class BetterDDB {
      * - Optionally injects timestamps,
      * - Validates the item and writes it to DynamoDB.
      */
-    async create(item) {
-        if (this.autoTimestamps) {
-            const now = new Date().toISOString();
-            item = { ...item, createdAt: now, updatedAt: now };
-        }
-        const validated = this.schema.parse(item);
-        let finalItem = { ...validated };
-        // Compute and merge primary key.
-        const computedKeys = this.buildKey(validated);
-        finalItem = { ...finalItem, ...computedKeys };
-        // Compute and merge index attributes.
-        const indexAttributes = this.buildIndexes(validated);
-        finalItem = { ...finalItem, ...indexAttributes };
-        try {
-            await this.client.put({ TableName: this.tableName, Item: finalItem }).promise();
-            return validated;
-        }
-        catch (error) {
-            console.error('Error during create operation:', error);
-            throw error;
-        }
-    }
-    async get(rawKey) {
-        const Key = this.buildKey(rawKey);
-        try {
-            const result = await this.client.get({ TableName: this.tableName, Key }).promise();
-            if (!result.Item)
-                return null;
-            return this.schema.parse(result.Item);
-        }
-        catch (error) {
-            console.error('Error during get operation:', error);
-            throw error;
-        }
-    }
-    async update(rawKey, update, options) {
-        const ExpressionAttributeNames = {};
-        const ExpressionAttributeValues = {};
-        const UpdateExpressionParts = [];
-        const ConditionExpressionParts = [];
-        // Exclude key fields from update.
-        const keyFieldNames = [
-            this.keys.primary.name,
-            this.keys.sort ? this.keys.sort.name : undefined
-        ].filter(Boolean);
-        for (const [attr, value] of Object.entries(update)) {
-            if (keyFieldNames.includes(attr))
-                continue;
-            const attributeKey = `#${attr}`;
-            const valueKey = `:${attr}`;
-            ExpressionAttributeNames[attributeKey] = attr;
-            ExpressionAttributeValues[valueKey] = value;
-            UpdateExpressionParts.push(`${attributeKey} = ${valueKey}`);
-        }
-        if (this.autoTimestamps) {
-            const now = new Date().toISOString();
-            ExpressionAttributeNames['#updatedAt'] = 'updatedAt';
-            ExpressionAttributeValues[':updatedAt'] = now;
-            UpdateExpressionParts.push('#updatedAt = :updatedAt');
-        }
-        if ((options === null || options === void 0 ? void 0 : options.expectedVersion) !== undefined) {
-            ExpressionAttributeNames['#version'] = 'version';
-            ExpressionAttributeValues[':expectedVersion'] = options.expectedVersion;
-            ExpressionAttributeValues[':newVersion'] = options.expectedVersion + 1;
-            UpdateExpressionParts.push('#version = :newVersion');
-            ConditionExpressionParts.push('#version = :expectedVersion');
-        }
-        if (UpdateExpressionParts.length === 0) {
-            throw new Error('No attributes provided to update');
-        }
-        const UpdateExpression = 'SET ' + UpdateExpressionParts.join(', ');
-        const params = {
-            TableName: this.tableName,
-            Key: this.buildKey(rawKey),
-            UpdateExpression,
-            ExpressionAttributeNames,
-            ExpressionAttributeValues,
-            ReturnValues: 'ALL_NEW'
-        };
-        if (ConditionExpressionParts.length > 0) {
-            params.ConditionExpression = ConditionExpressionParts.join(' AND ');
-        }
-        try {
-            const result = await this.client.update(params).promise();
-            if (!result.Attributes) {
-                throw new Error('No attributes returned after update');
-            }
-            return this.schema.parse(result.Attributes);
-        }
-        catch (error) {
-            console.error('Error during update operation:', error);
-            throw error;
-        }
-    }
-    async delete(rawKey) {
-        const Key = this.buildKey(rawKey);
-        try {
-            await this.client.delete({ TableName: this.tableName, Key }).promise();
-        }
-        catch (error) {
-            console.error('Error during delete operation:', error);
-            throw error;
-        }
-    }
-    async queryByGsi(gsiName, key, sortKeyCondition) {
-        if (!this.keys.gsis || !this.keys.gsis[gsiName]) {
-            throw new Error(`GSI "${gsiName}" is not configured`);
-        }
-        const indexConfig = this.keys.gsis[gsiName];
-        const ExpressionAttributeNames = {
-            [`#${indexConfig.primary.name}`]: indexConfig.primary.name
-        };
-        const ExpressionAttributeValues = {
-            [`:${indexConfig.primary.name}`]: (typeof indexConfig.primary.definition === 'string' ||
-                typeof indexConfig.primary.definition === 'number' ||
-                typeof indexConfig.primary.definition === 'symbol')
-                ? String(key[indexConfig.primary.definition])
-                : indexConfig.primary.definition.build(key)
-        };
-        let KeyConditionExpression = `#${indexConfig.primary.name} = :${indexConfig.primary.name}`;
-        if (indexConfig.sort && sortKeyCondition) {
-            const skFieldName = indexConfig.sort.name;
-            ExpressionAttributeNames['#gsiSk'] = skFieldName;
-            switch (sortKeyCondition.operator) {
-                case 'eq':
-                    ExpressionAttributeValues[':gsiSk'] = sortKeyCondition.values;
-                    KeyConditionExpression += ' AND #gsiSk = :gsiSk';
-                    break;
-                case 'begins_with':
-                    ExpressionAttributeValues[':gsiSk'] = sortKeyCondition.values;
-                    KeyConditionExpression += ' AND begins_with(#gsiSk, :gsiSk)';
-                    break;
-                case 'between':
-                    if (!Array.isArray(sortKeyCondition.values) || sortKeyCondition.values.length !== 2) {
-                        throw new Error("For 'between' operator, values must be a tuple of two items");
-                    }
-                    ExpressionAttributeValues[':gsiSkStart'] = sortKeyCondition.values[0];
-                    ExpressionAttributeValues[':gsiSkEnd'] = sortKeyCondition.values[1];
-                    KeyConditionExpression += ' AND #gsiSk BETWEEN :gsiSkStart AND :gsiSkEnd';
-                    break;
-                default:
-                    throw new Error(`Unsupported sort key operator: ${sortKeyCondition.operator}`);
-            }
-        }
-        try {
-            const result = await this.client
-                .query({
-                TableName: this.tableName,
-                IndexName: gsiName,
-                KeyConditionExpression,
-                ExpressionAttributeNames,
-                ExpressionAttributeValues
-            })
-                .promise();
-            return (result.Items || []).map(item => this.schema.parse(item));
-        }
-        catch (error) {
-            console.error('Error during queryByGsi operation:', error);
-            throw error;
-        }
+    create(item) {
+        return new create_builder_1.CreateBuilder(this, item);
     }
     /**
-     * Query by primary key (using the computed primary key) and an optional sort key condition.
+     * Get an item by its primary key.
      */
-    async queryByPrimaryKey(rawKey, sortKeyCondition, options) {
-        const pkAttrName = this.keys.primary.name;
-        const pkValue = (typeof this.keys.primary.definition === 'string' ||
-            typeof this.keys.primary.definition === 'number' ||
-            typeof this.keys.primary.definition === 'symbol')
-            ? String(rawKey[this.keys.primary.definition])
-            : this.keys.primary.definition.build(rawKey);
-        const ExpressionAttributeNames = {
-            [`#${pkAttrName}`]: pkAttrName
-        };
-        const ExpressionAttributeValues = {
-            [`:${pkAttrName}`]: pkValue
-        };
-        let KeyConditionExpression = `#${pkAttrName} = :${pkAttrName}`;
-        if (this.keys.sort && sortKeyCondition) {
-            const skAttrName = this.keys.sort.name;
-            ExpressionAttributeNames[`#${skAttrName}`] = skAttrName;
-            switch (sortKeyCondition.operator) {
-                case 'eq':
-                    ExpressionAttributeValues[':skValue'] = sortKeyCondition.values;
-                    KeyConditionExpression += ` AND #${skAttrName} = :skValue`;
-                    break;
-                case 'begins_with':
-                    ExpressionAttributeValues[':skValue'] = sortKeyCondition.values;
-                    KeyConditionExpression += ` AND begins_with(#${skAttrName}, :skValue)`;
-                    break;
-                case 'between':
-                    if (!Array.isArray(sortKeyCondition.values) || sortKeyCondition.values.length !== 2) {
-                        throw new Error("For 'between' operator, values must be a tuple of two items");
-                    }
-                    ExpressionAttributeValues[':skStart'] = sortKeyCondition.values[0];
-                    ExpressionAttributeValues[':skEnd'] = sortKeyCondition.values[1];
-                    KeyConditionExpression += ` AND #${skAttrName} BETWEEN :skStart AND :skEnd`;
-                    break;
-                default:
-                    throw new Error(`Unsupported sort key operator: ${sortKeyCondition.operator}`);
-            }
-        }
-        const queryParams = {
-            TableName: this.tableName,
-            KeyConditionExpression,
-            ExpressionAttributeNames,
-            ExpressionAttributeValues
-        };
-        if (options === null || options === void 0 ? void 0 : options.limit) {
-            queryParams.Limit = options.limit;
-        }
-        if (options === null || options === void 0 ? void 0 : options.lastKey) {
-            queryParams.ExclusiveStartKey = options.lastKey;
-        }
-        const result = await this.client.query(queryParams).promise();
-        const items = (result.Items || []).map(item => this.schema.parse(item));
-        return { items, lastKey: result.LastEvaluatedKey };
-    }
-    // ───── Transaction Helpers ─────────────────────────────
-    buildTransactPut(item) {
-        const computedKeys = this.buildKey(item);
-        const indexAttributes = this.buildIndexes(item);
-        const finalItem = { ...item, ...computedKeys, ...indexAttributes };
-        const validated = this.schema.parse(finalItem);
-        return {
-            Put: {
-                TableName: this.tableName,
-                Item: validated
-            }
-        };
-    }
-    buildTransactUpdate(rawKey, update, options) {
-        const ExpressionAttributeNames = {};
-        const ExpressionAttributeValues = {};
-        const UpdateExpressionParts = [];
-        const ConditionExpressionParts = [];
-        const keyFieldNames = [
-            this.keys.primary.name,
-            this.keys.sort ? this.keys.sort.name : undefined
-        ].filter(Boolean);
-        for (const [attr, value] of Object.entries(update)) {
-            if (keyFieldNames.includes(attr))
-                continue;
-            const attributeKey = `#${attr}`;
-            const valueKey = `:${attr}`;
-            ExpressionAttributeNames[attributeKey] = attr;
-            ExpressionAttributeValues[valueKey] = value;
-            UpdateExpressionParts.push(`${attributeKey} = ${valueKey}`);
-        }
-        if (this.autoTimestamps) {
-            const now = new Date().toISOString();
-            ExpressionAttributeNames['#updatedAt'] = 'updatedAt';
-            ExpressionAttributeValues[':updatedAt'] = now;
-            UpdateExpressionParts.push('#updatedAt = :updatedAt');
-        }
-        if ((options === null || options === void 0 ? void 0 : options.expectedVersion) !== undefined) {
-            ExpressionAttributeNames['#version'] = 'version';
-            ExpressionAttributeValues[':expectedVersion'] = options.expectedVersion;
-            ExpressionAttributeValues[':newVersion'] = options.expectedVersion + 1;
-            UpdateExpressionParts.push('#version = :newVersion');
-            ConditionExpressionParts.push('#version = :expectedVersion');
-        }
-        if (UpdateExpressionParts.length === 0) {
-            throw new Error('No attributes provided to update in transactUpdate');
-        }
-        const UpdateExpression = 'SET ' + UpdateExpressionParts.join(', ');
-        const updateItem = {
-            TableName: this.tableName,
-            Key: this.buildKey(rawKey),
-            UpdateExpression,
-            ExpressionAttributeNames,
-            ExpressionAttributeValues
-        };
-        if (ConditionExpressionParts.length > 0) {
-            updateItem.ConditionExpression = ConditionExpressionParts.join(' AND ');
-        }
-        return { Update: updateItem };
-    }
-    buildTransactDelete(rawKey) {
-        return {
-            Delete: {
-                TableName: this.tableName,
-                Key: this.buildKey(rawKey)
-            }
-        };
-    }
-    async transactWrite(operations) {
-        try {
-            await this.client.transactWrite({ TransactItems: operations }).promise();
-        }
-        catch (error) {
-            console.error('Error during transactWrite operation:', error);
-            throw error;
-        }
+    get(rawKey) {
+        return new get_builder_1.GetBuilder(this, rawKey);
     }
-    async transactGetByKeys(rawKeys) {
-        const getItems = rawKeys.map(key => ({ TableName: this.tableName, Key: this.buildKey(key) }));
-        return this.transactGet(getItems);
-    }
-    async transactGet(getItems) {
-        try {
-            const response = await this.client
-                .transactGet({
-                TransactItems: getItems.map(item => ({ Get: item }))
-            })
-                .promise();
-            return (response.Responses || [])
-                .filter(r => r.Item)
-                .map(r => this.schema.parse(r.Item));
-        }
-        catch (error) {
-            console.error('Error during transactGet operation:', error);
-            throw error;
-        }
-    }
-    // ───── Batch Write Support ─────────────────────────────
-    async batchWrite(ops) {
-        const putRequests = (ops.puts || []).map(item => {
-            const computedKeys = this.buildKey(item);
-            const indexAttributes = this.buildIndexes(item);
-            const finalItem = { ...item, ...computedKeys, ...indexAttributes };
-            const validated = this.schema.parse(finalItem);
-            return { PutRequest: { Item: validated } };
-        });
-        const deleteRequests = (ops.deletes || []).map(rawKey => {
-            const key = this.buildKey(rawKey);
-            return { DeleteRequest: { Key: key } };
-        });
-        const allRequests = [...putRequests, ...deleteRequests];
-        for (let i = 0; i < allRequests.length; i += 25) {
-            const chunk = allRequests.slice(i, i + 25);
-            let unprocessed = await this.batchWriteChunk(chunk);
-            while (unprocessed && Object.keys(unprocessed).length > 0) {
-                await new Promise(resolve => setTimeout(resolve, 1000));
-                unprocessed = await this.retryBatchWrite(unprocessed);
-            }
-        }
+    /**
+     * Update an item.
+     */
+    update(key, expectedVersion) {
+        return new update_builder_1.UpdateBuilder(this, key, expectedVersion);
     }
-    async batchWriteChunk(chunk) {
-        const params = {
-            RequestItems: {
-                [this.tableName]: chunk
-            }
-        };
-        const result = await this.client.batchWrite(params).promise();
-        return result.UnprocessedItems;
+    /**
+     * Delete an item.
+     */
+    delete(rawKey) {
+        return new delete_builder_1.DeleteBuilder(this, rawKey);
     }
-    async retryBatchWrite(unprocessed) {
-        const params = { RequestItems: unprocessed };
-        const result = await this.client.batchWrite(params).promise();
-        return result.UnprocessedItems;
+    /**
+     * Query items.
+     */
+    query(key) {
+        return new query_builder_1.QueryBuilder(this, key);
     }
-    // ───── Batch Get Support ─────────────────────────────
-    async batchGet(rawKeys) {
-        const keys = rawKeys.map(key => this.buildKey(key));
-        const results = [];
-        for (let i = 0; i < keys.length; i += 100) {
-            const chunk = keys.slice(i, i + 100);
-            const params = {
-                RequestItems: {
-                    [this.tableName]: {
-                        Keys: chunk
-                    }
-                }
-            };
-            const result = await this.client.batchGet(params).promise();
-            const items = result.Responses ? result.Responses[this.tableName] : [];
-            results.push(...items.map(item => this.schema.parse(item)));
-        }
-        return results;
+    /**
+     * Scan for items.
+     */
+    scan() {
+        return new scan_builder_1.ScanBuilder(this);
     }
 }
 exports.BetterDDB = BetterDDB;

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

@@ -0,0 +1,14 @@
+import { DynamoDB } from 'aws-sdk';
+import { BetterDDB } from '../betterddb';
+export declare class CreateBuilder<T> {
+    private parent;
+    private item;
+    private extraTransactItems;
+    constructor(parent: BetterDDB<T>, item: T);
+    execute(): Promise<T>;
+    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>;
+}

package/lib/builders/create-builder.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateBuilder = void 0;
+class CreateBuilder {
+    constructor(parent, item) {
+        this.parent = parent;
+        this.item = item;
+        this.extraTransactItems = [];
+    }
+    async execute() {
+        if (this.extraTransactItems.length > 0) {
+            // Build our update transaction item.
+            const myTransactItem = this.toTransactPut();
+            // Combine with extra transaction items.
+            const allItems = [...this.extraTransactItems, myTransactItem];
+            await this.parent.getClient().transactWrite({
+                TransactItems: allItems
+            }).promise();
+            // 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');
+            }
+            return result;
+        }
+        else {
+            let item = this.item;
+            if (this.parent.getAutoTimestamps()) {
+                const now = new Date().toISOString();
+                item = { ...item, createdAt: now, updatedAt: now };
+            }
+            // Validate the item using the schema.
+            const validated = this.parent.getSchema().parse(item);
+            let finalItem = { ...validated };
+            // Compute and merge primary key.
+            const computedKeys = this.parent.buildKey(validated);
+            finalItem = { ...finalItem, ...computedKeys };
+            // Compute and merge index attributes.
+            const indexAttributes = this.parent.buildIndexes(validated);
+            finalItem = { ...finalItem, ...indexAttributes };
+            await this.parent.getClient().put({
+                TableName: this.parent.getTableName(),
+                Item: finalItem
+            }).promise();
+            return validated;
+        }
+    }
+    transactWrite(ops) {
+        if (Array.isArray(ops)) {
+            this.extraTransactItems.push(...ops);
+        }
+        else {
+            this.extraTransactItems.push(ops);
+        }
+        return this;
+    }
+    toTransactPut() {
+        const putItem = {
+            TableName: this.parent.getTableName(),
+            Item: this.item,
+        };
+        return { Put: putItem };
+    }
+    then(onfulfilled, onrejected) {
+        return this.execute().then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.execute().catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.execute().finally(onfinally);
+    }
+}
+exports.CreateBuilder = CreateBuilder;

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

@@ -0,0 +1,19 @@
+import { DynamoDB } from 'aws-sdk';
+import { BetterDDB } from '../betterddb';
+export declare class DeleteBuilder<T> {
+    private parent;
+    private key;
+    private condition?;
+    private extraTransactItems;
+    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;
+    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>;
+}