betterddb 0.4.8 → 0.5.0

package/README.md

@@ -61,8 +61,8 @@ const userDdb = new BetterDDB({
     }
   },
   client,
-  autoTimestamps: true,
-  entityName: 'USER'
+  timestamps: true,
+  entityType: 'USER'
 });
 
 (async () => {

package/lib/betterddb.d.ts

@@ -63,7 +63,7 @@ export interface KeysConfig<T> {
 export interface BetterDDBOptions<T> {
     schema: z.ZodType<T, z.ZodTypeDef, any>;
     tableName: string;
-    entityName: string;
+    entityType: string;
     keys: KeysConfig<T>;
     client: DynamoDBDocumentClient;
     /**
@@ -73,7 +73,7 @@ export interface BetterDDBOptions<T> {
      *
      * (T should include these fields if enabled.)
      */
-    autoTimestamps?: boolean;
+    timestamps?: boolean;
 }
 /**
  * BetterDDB is a definition-based DynamoDB wrapper library.
@@ -81,16 +81,17 @@ export interface BetterDDBOptions<T> {
 export declare class BetterDDB<T> {
     protected schema: z.ZodType<T, z.ZodTypeDef, any>;
     protected tableName: string;
-    protected entityName: string;
+    protected entityType: string;
     protected client: DynamoDBDocumentClient;
     protected keys: KeysConfig<T>;
-    protected autoTimestamps: boolean;
+    protected timestamps: boolean;
     constructor(options: BetterDDBOptions<T>);
     getKeys(): KeysConfig<T>;
     getTableName(): string;
     getClient(): DynamoDBDocumentClient;
     getSchema(): z.ZodType<T, z.ZodTypeDef, any>;
-    getAutoTimestamps(): boolean;
+    getTimestamps(): boolean;
+    getEntityType(): string;
     protected getKeyValue(def: KeyDefinition<T>, rawKey: Partial<T>): string;
     /**
      * Build the primary key from a raw key object.
@@ -118,7 +119,7 @@ export declare class BetterDDB<T> {
     /**
      * Update an item.
      */
-    update(key: Partial<T>, expectedVersion?: number): UpdateBuilder<T>;
+    update(key: Partial<T>): UpdateBuilder<T>;
     /**
      * Delete an item.
      */

package/lib/betterddb.js

@@ -16,10 +16,10 @@ class BetterDDB {
         var _a;
         this.schema = options.schema;
         this.tableName = options.tableName;
-        this.entityName = options.entityName.toUpperCase();
+        this.entityType = options.entityType.toUpperCase();
         this.keys = options.keys;
         this.client = options.client;
-        this.autoTimestamps = (_a = options.autoTimestamps) !== null && _a !== void 0 ? _a : false;
+        this.timestamps = (_a = options.timestamps) !== null && _a !== void 0 ? _a : false;
     }
     getKeys() {
         return this.keys;
@@ -33,8 +33,11 @@ class BetterDDB {
     getSchema() {
         return this.schema;
     }
-    getAutoTimestamps() {
-        return this.autoTimestamps;
+    getTimestamps() {
+        return this.timestamps;
+    }
+    getEntityType() {
+        return this.entityType;
     }
     // Helper: Retrieve the key value from a KeyDefinition.
     getKeyValue(def, rawKey) {
@@ -124,8 +127,8 @@ class BetterDDB {
     /**
      * Update an item.
      */
-    update(key, expectedVersion) {
-        return new update_builder_1.UpdateBuilder(this, key, expectedVersion);
+    update(key) {
+        return new update_builder_1.UpdateBuilder(this, key);
     }
     /**
      * Delete an item.

package/lib/builders/create-builder.js

@@ -9,6 +9,7 @@ class CreateBuilder {
         this.extraTransactItems = [];
     }
     async execute() {
+        const validated = this.parent.getSchema().parse(this.item);
         if (this.extraTransactItems.length > 0) {
             // Build our update transaction item.
             const myTransactItem = this.toTransactPut();
@@ -25,14 +26,11 @@ class CreateBuilder {
             return result;
         }
         else {
-            let item = this.item;
-            if (this.parent.getAutoTimestamps()) {
+            let finalItem = { ...this.item, entityType: this.parent.getEntityType() };
+            if (this.parent.getTimestamps()) {
                 const now = new Date().toISOString();
-                item = { ...item, createdAt: now, updatedAt: now };
+                finalItem = { ...finalItem, 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 };

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

@@ -1,12 +1,14 @@
 import { BetterDDB } from '../betterddb';
+import { Operator } from '../operator';
+import { PaginatedResult } from '../types/paginated-result';
 export declare class QueryBuilder<T> {
     private parent;
     private key;
-    private filters;
+    private keyConditions;
+    private filterConditions;
     private expressionAttributeNames;
     private expressionAttributeValues;
     private index?;
-    private sortKeyCondition?;
     private limit?;
     private lastKey?;
     private ascending;
@@ -14,11 +16,12 @@ export declare class QueryBuilder<T> {
     usingIndex(indexName: string): this;
     sortAscending(): this;
     sortDescending(): this;
-    where(attribute: keyof T, operator: 'eq' | 'begins_with' | 'between', values: any | [any, any]): this;
+    where(operator: Operator, values: Partial<T> | [Partial<T>, Partial<T>]): this;
+    filter(attribute: keyof T, operator: Operator, 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<T[]>;
+    execute(): Promise<PaginatedResult<T>>;
 }

package/lib/builders/query-builder.js

@@ -2,11 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryBuilder = void 0;
 const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
+const operator_1 = require("../operator");
 class QueryBuilder {
     constructor(parent, key) {
         this.parent = parent;
         this.key = key;
-        this.filters = [];
+        this.keyConditions = [];
+        this.filterConditions = [];
         this.expressionAttributeNames = {};
         this.expressionAttributeValues = {};
         this.ascending = true;
@@ -29,32 +31,78 @@ class QueryBuilder {
         this.ascending = false;
         return this;
     }
-    where(attribute, operator, values) {
-        const attrStr = String(attribute);
-        const nameKey = `#attr_${attrStr}`;
-        this.expressionAttributeNames[nameKey] = attrStr;
-        if (operator === 'eq') {
-            const valueKey = `:val_${attrStr}`;
-            this.expressionAttributeValues[valueKey] = values;
-            this.filters.push(`${nameKey} = ${valueKey}`);
+    where(operator, values) {
+        var _a, _b;
+        const keys = this.parent.getKeys();
+        // Determine the sort key name from either the index or the primary keys.
+        const sortKeyName = this.index ? (_a = this.index.sort) === null || _a === void 0 ? void 0 : _a.name : (_b = keys.sort) === null || _b === void 0 ? void 0 : _b.name;
+        if (!sortKeyName) {
+            throw new Error('Sort key is not defined for this table/index.');
+        }
+        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 (operator === 'between') {
+            if (!Array.isArray(values) || values.length !== 2) {
+                throw new Error(`For 'between' operator, values must be a tuple of two objects`);
+            }
+            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]
+                : this.parent.buildKey(values[0])[sortKeyName];
+            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 = `:val_${attrStr}`;
-            this.expressionAttributeValues[valueKey] = values;
-            this.filters.push(`begins_with(${nameKey}, ${valueKey})`);
+            const valueKey = ':sk_value';
+            this.expressionAttributeValues[valueKey] = this.index
+                ? this.parent.buildIndexes(values)[sortKeyName]
+                : this.parent.buildKey(values)[sortKeyName];
+            this.keyConditions.push(`begins_with(${nameKey}, ${valueKey})`);
         }
-        else if (operator === 'between') {
+        else {
+            // For eq, lt, lte, gt, gte:
+            const valueKey = ':sk_value';
+            this.expressionAttributeValues[valueKey] = this.index
+                ? this.parent.buildIndexes(values)[sortKeyName]
+                : this.parent.buildKey(values)[sortKeyName];
+            const condition = (0, operator_1.getOperatorExpression)(operator, nameKey, valueKey);
+            this.keyConditions.push(condition);
+        }
+        return this;
+    }
+    filter(attribute, operator, values) {
+        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 (!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 valueKeyStart = `:val_start_${attrStr}`;
-            const valueKeyEnd = `:val_end_${attrStr}`;
-            this.expressionAttributeValues[valueKeyStart] = values[0];
-            this.expressionAttributeValues[valueKeyEnd] = values[1];
-            this.filters.push(`${nameKey} BETWEEN ${valueKeyStart} AND ${valueKeyEnd}`);
+            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') {
+            const placeholderValue = `:val_${attrStr}_${randomString}`;
+            this.expressionAttributeValues[placeholderValue] = values;
+            this.filterConditions.push(`${operator}(${placeholderName}, ${placeholderValue})`);
         }
         else {
-            throw new Error(`Unsupported operator: ${operator}`);
+            const placeholderValue = `:val_${attrStr}_${randomString}`;
+            this.expressionAttributeValues[placeholderValue] = values;
+            const condition = (0, operator_1.getOperatorExpression)(operator, placeholderName, placeholderValue);
+            this.filterConditions.push(condition);
         }
         return this;
     }
@@ -70,7 +118,7 @@ class QueryBuilder {
      * Executes the query and returns a Promise that resolves with an array of items.
      */
     async execute() {
-        var _a, _b;
+        var _a, _b, _c;
         const keys = this.parent.getKeys();
         let pkName = keys.primary.name;
         let builtKey = this.parent.buildKey(this.key);
@@ -78,12 +126,12 @@ class QueryBuilder {
             pkName = this.index.primary.name;
             builtKey = this.parent.buildIndexes(this.key);
         }
-        this.expressionAttributeNames['#pk'] = pkName;
-        let keyConditionExpression = `#pk = :pk_value`;
-        if (this.sortKeyCondition) {
-            keyConditionExpression += ` AND ${this.sortKeyCondition}`;
+        if (!this.expressionAttributeNames['#pk']) {
+            this.expressionAttributeNames['#pk'] = pkName;
+            this.expressionAttributeValues[':pk_value'] = builtKey[pkName];
+            this.keyConditions.unshift(`#pk = :pk_value`);
         }
-        this.expressionAttributeValues[':pk_value'] = builtKey[pkName];
+        const keyConditionExpression = this.keyConditions.join(' AND ');
         const params = {
             TableName: this.parent.getTableName(),
             KeyConditionExpression: keyConditionExpression,
@@ -92,13 +140,14 @@ class QueryBuilder {
             ScanIndexForward: this.ascending,
             Limit: this.limit,
             ExclusiveStartKey: this.lastKey,
-            IndexName: (_b = (_a = this.index) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : undefined
+            IndexName: (_b = (_a = this.index) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : undefined,
         };
-        if (this.filters.length > 0) {
-            params.FilterExpression = this.filters.join(' AND ');
-        }
+        this.filterConditions.push(`#entity = :entity_value`);
+        this.expressionAttributeNames['#entity'] = 'entityType';
+        this.expressionAttributeValues[':entity_value'] = this.parent.getEntityType();
+        params.FilterExpression = this.filterConditions.join(' AND ');
         const result = await this.parent.getClient().send(new lib_dynamodb_1.QueryCommand(params));
-        return this.parent.getSchema().array().parse(result.Items);
+        return { items: this.parent.getSchema().array().parse(result.Items), lastKey: (_c = result.LastEvaluatedKey) !== null && _c !== void 0 ? _c : undefined };
     }
 }
 exports.QueryBuilder = QueryBuilder;

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

@@ -1,4 +1,6 @@
 import { BetterDDB } from '../betterddb';
+import { Operator } from '../operator';
+import { PaginatedResult } from '../types/paginated-result';
 export declare class ScanBuilder<T> {
     private parent;
     private filters;
@@ -7,11 +9,11 @@ export declare class ScanBuilder<T> {
     private limit?;
     private lastKey?;
     constructor(parent: BetterDDB<T>);
-    where(attribute: keyof T, operator: 'eq' | 'begins_with' | 'between', values: any | [any, any]): this;
+    where(attribute: keyof T, operator: Operator, 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<T[]>;
+    execute(): Promise<PaginatedResult<T>>;
 }

package/lib/builders/scan-builder.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScanBuilder = void 0;
 const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
+const operator_1 = require("../operator");
 class ScanBuilder {
     constructor(parent) {
         this.parent = parent;
@@ -13,17 +14,7 @@ class ScanBuilder {
         const attrStr = String(attribute);
         const nameKey = `#attr_${attrStr}`;
         this.expressionAttributeNames[nameKey] = attrStr;
-        if (operator === 'eq') {
-            const valueKey = `:val_${attrStr}`;
-            this.expressionAttributeValues[valueKey] = values;
-            this.filters.push(`${nameKey} = ${valueKey}`);
-        }
-        else if (operator === 'begins_with') {
-            const valueKey = `:val_${attrStr}`;
-            this.expressionAttributeValues[valueKey] = values;
-            this.filters.push(`begins_with(${nameKey}, ${valueKey})`);
-        }
-        else 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`);
             }
@@ -33,8 +24,16 @@ class ScanBuilder {
             this.expressionAttributeValues[valueKeyEnd] = values[1];
             this.filters.push(`${nameKey} BETWEEN ${valueKeyStart} AND ${valueKeyEnd}`);
         }
+        else if (operator === 'begins_with' || operator === 'contains') {
+            const valueKey = `:val_${attrStr}`;
+            this.expressionAttributeValues[valueKey] = values;
+            this.filters.push(`${operator}(${nameKey}, ${valueKey})`);
+        }
         else {
-            throw new Error(`Unsupported operator: ${operator}`);
+            const valueKey = `:val_${attrStr}`;
+            this.expressionAttributeValues[valueKey] = values;
+            const condition = (0, operator_1.getOperatorExpression)(operator, nameKey, valueKey);
+            this.filters.push(condition);
         }
         return this;
     }
@@ -50,6 +49,7 @@ class ScanBuilder {
      * Executes the scan and returns a Promise that resolves with an array of items.
      */
     async execute() {
+        var _a;
         const params = {
             TableName: this.parent.getTableName(),
             ExpressionAttributeNames: this.expressionAttributeNames,
@@ -61,7 +61,7 @@ class ScanBuilder {
             params.FilterExpression = this.filters.join(' AND ');
         }
         const result = await this.parent.getClient().send(new lib_dynamodb_1.ScanCommand(params));
-        return this.parent.getSchema().array().parse(result.Items);
+        return { items: this.parent.getSchema().array().parse(result.Items), lastKey: (_a = result.LastEvaluatedKey) !== null && _a !== void 0 ? _a : undefined };
     }
 }
 exports.ScanBuilder = ScanBuilder;

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

@@ -5,9 +5,8 @@ export declare class UpdateBuilder<T> {
     private key;
     private actions;
     private condition?;
-    private expectedVersion?;
     private extraTransactItems;
-    constructor(parent: BetterDDB<T>, key: Partial<T>, expectedVersion?: number);
+    constructor(parent: BetterDDB<T>, key: Partial<T>);
     set(attrs: Partial<T>): this;
     remove(attrs: (keyof T)[]): this;
     add(attrs: Partial<Record<keyof T, number | Set<any>>>): this;

package/lib/builders/update-builder.js

@@ -4,13 +4,12 @@ exports.UpdateBuilder = void 0;
 const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
 class UpdateBuilder {
     // Reference to the parent BetterDDB instance and key.
-    constructor(parent, key, expectedVersion) {
+    constructor(parent, key) {
         this.parent = parent;
         this.key = key;
         this.actions = {};
         // When using transaction mode, we store extra transaction items.
         this.extraTransactItems = [];
-        this.expectedVersion = expectedVersion;
     }
     // Chainable methods:
     set(attrs) {
@@ -113,28 +112,6 @@ class UpdateBuilder {
                 clauses.push(`DELETE ${deleteParts.join(', ')}`);
             }
         }
-        // Incorporate expectedVersion if provided.
-        if (this.expectedVersion !== undefined) {
-            ExpressionAttributeNames['#version'] = 'version';
-            ExpressionAttributeValues[':expectedVersion'] = this.expectedVersion;
-            ExpressionAttributeValues[':newVersion'] = this.expectedVersion + 1;
-            // Append version update in SET clause.
-            const versionClause = '#version = :newVersion';
-            const setIndex = clauses.findIndex(clause => clause.startsWith('SET '));
-            if (setIndex >= 0) {
-                clauses[setIndex] += `, ${versionClause}`;
-            }
-            else {
-                clauses.push(`SET ${versionClause}`);
-            }
-            // Ensure condition expression includes version check.
-            if (this.condition && this.condition.expression) {
-                this.condition.expression += ` AND #version = :expectedVersion`;
-            }
-            else {
-                this.condition = { expression: '#version = :expectedVersion', attributeValues: {} };
-            }
-        }
         // Merge any provided condition attribute values.
         if (this.condition) {
             Object.assign(ExpressionAttributeValues, this.condition.attributeValues);

package/lib/operator.d.ts

@@ -0,0 +1,2 @@
+export type Operator = '==' | '!=' | '<' | '<=' | '>' | '>=' | 'begins_with' | 'between' | 'contains';
+export declare function getOperatorExpression(operator: Operator, nameKey: string, valueKey: string, secondValueKey?: string): string;

package/lib/operator.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOperatorExpression = void 0;
+function getOperatorExpression(operator, nameKey, valueKey, secondValueKey) {
+    switch (operator) {
+        case '==':
+            return `${nameKey} = ${valueKey}`;
+        case '!=':
+            return `${nameKey} <> ${valueKey}`;
+        case '<':
+            return `${nameKey} < ${valueKey}`;
+        case '<=':
+            return `${nameKey} <= ${valueKey}`;
+        case '>':
+            return `${nameKey} > ${valueKey}`;
+        case '>=':
+            return `${nameKey} >= ${valueKey}`;
+        case 'begins_with':
+            return `begins_with(${nameKey}, ${valueKey})`;
+        case 'between':
+            if (!secondValueKey) {
+                throw new Error("The 'between' operator requires two value keys");
+            }
+            return `${nameKey} BETWEEN ${valueKey} AND ${secondValueKey}`;
+        case 'contains':
+            return `contains(${nameKey}, ${valueKey})`;
+        default:
+            throw new Error(`Unsupported operator: ${operator}`);
+    }
+}
+exports.getOperatorExpression = getOperatorExpression;

package/lib/types/paginated-result.d.ts

@@ -0,0 +1,4 @@
+export type PaginatedResult<T> = {
+    items: T[];
+    lastKey: Record<string, any> | undefined;
+};

package/lib/types/paginated-result.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "betterddb",
-  "version": "0.4.8",
+  "version": "0.5.0",
   "description": "A definition-based DynamoDB wrapper library that provides a schema-driven and fully typesafe DAL.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/betterddb.ts

@@ -72,7 +72,7 @@ export interface KeysConfig<T> {
 export interface BetterDDBOptions<T> {
   schema: z.ZodType<T, z.ZodTypeDef, any>;
   tableName: string;
-  entityName: string;
+  entityType: string;
   keys: KeysConfig<T>;
   client: DynamoDBDocumentClient;
   /**
@@ -82,7 +82,7 @@ export interface BetterDDBOptions<T> {
    *
    * (T should include these fields if enabled.)
    */
-  autoTimestamps?: boolean;
+  timestamps?: boolean;
 }
 
 /**
@@ -91,18 +91,18 @@ export interface BetterDDBOptions<T> {
 export class BetterDDB<T> {
   protected schema: z.ZodType<T, z.ZodTypeDef, any>;
   protected tableName: string;
-  protected entityName: string;
+  protected entityType: string;
   protected client: DynamoDBDocumentClient;
   protected keys: KeysConfig<T>;
-  protected autoTimestamps: boolean;
+  protected timestamps: boolean;
 
   constructor(options: BetterDDBOptions<T>) {
     this.schema = options.schema;
     this.tableName = options.tableName;
-    this.entityName = options.entityName.toUpperCase();
+    this.entityType = options.entityType.toUpperCase();
     this.keys = options.keys;
     this.client = options.client;
-    this.autoTimestamps = options.autoTimestamps ?? false;
+    this.timestamps = options.timestamps ?? false;
   }
 
   public getKeys(): KeysConfig<T> {
@@ -122,8 +122,12 @@ export class BetterDDB<T> {
     return this.schema;
   }
 
-  public getAutoTimestamps(): boolean {
-    return this.autoTimestamps;
+  public getTimestamps(): boolean {
+    return this.timestamps;
+  }
+
+  public getEntityType(): string {
+    return this.entityType;
   }
 
   // Helper: Retrieve the key value from a KeyDefinition.
@@ -223,8 +227,8 @@ export class BetterDDB<T> {
   /**
    * Update an item.
    */
-  public update(key: Partial<T>, expectedVersion?: number): UpdateBuilder<T> {
-    return new UpdateBuilder<T>(this, key, expectedVersion);
+  public update(key: Partial<T>): UpdateBuilder<T> {
+    return new UpdateBuilder<T>(this, key);
   }
 
   /**

package/src/builders/create-builder.ts

@@ -9,6 +9,7 @@ export class CreateBuilder<T> {
   constructor(private parent: BetterDDB<T>, private item: T) {}
 
   public async execute(): Promise<T> {
+    const validated = this.parent.getSchema().parse(this.item);
     if (this.extraTransactItems.length > 0) {
       // Build our update transaction item.
       const myTransactItem = this.toTransactPut();
@@ -24,14 +25,12 @@ export class CreateBuilder<T> {
       }
       return result;
     } else {
-    let item = this.item;
-    if (this.parent.getAutoTimestamps()) {
+
+    let finalItem: T = { ...this.item , entityType: this.parent.getEntityType() };
+    if (this.parent.getTimestamps()) {
       const now = new Date().toISOString();
-      item = { ...item, createdAt: now, updatedAt: now } as T;
+      finalItem = { ...finalItem, createdAt: now, updatedAt: now } as T;
     }
-    // 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 as Partial<T>);