dyno-table 1.2.0 → 1.3.1

package/dist/table.d.cts

@@ -1,12 +1,12 @@
 import './types.cjs';
 import './conditions-ChhQWd6z.cjs';
-import './query-builder-D2FM9rsu.cjs';
+import './query-builder-DLY2lgjI.cjs';
 import './builders/put-builder.cjs';
 import './builders/delete-builder.cjs';
 import './builders/update-builder.cjs';
 import './builders/transaction-builder.cjs';
-export { T as Table } from './table-DIfupG_s.cjs';
+export { T as Table } from './table-BAfnBHoH.cjs';
 import './builders/condition-check-builder.cjs';
 import '@aws-sdk/lib-dynamodb';
 import './builders/paginator.cjs';
-import './builder-types-DtwbqMeF.cjs';
+import './builder-types-DlaUSc-b.cjs';

package/dist/table.d.ts

@@ -1,12 +1,12 @@
 import './types.js';
 import './conditions--ld9a78i.js';
-import './query-builder-Csror9Iu.js';
+import './query-builder-BehSUVpp.js';
 import './builders/put-builder.js';
 import './builders/delete-builder.js';
 import './builders/update-builder.js';
 import './builders/transaction-builder.js';
-export { T as Table } from './table-BelHPTvr.js';
+export { T as Table } from './table-BcnNHdOb.js';
 import './builders/condition-check-builder.js';
 import '@aws-sdk/lib-dynamodb';
 import './builders/paginator.js';
-import './builder-types-C_PDZhnP.js';
+import './builder-types-B_tCpn9F.js';

package/dist/table.js

@@ -956,7 +956,8 @@ var PutBuilder = class {
    * @options
    *  - NONE: No return value
    *  - ALL_OLD: Returns the item's previous state if it existed, no read capacity units are consumed
-   *  - CONSISTENT: (default) Performs a GET operation after the put to retrieve the item's new state
+   *  - CONSISTENT: Performs a GET operation after the put to retrieve the item's new state
+   *  - INPUT: Returns the input values that were passed to the operation
    *
    * @example
    * ```ts
@@ -975,9 +976,14 @@ var PutBuilder = class {
    *     }
    *   });
    * }
+   *
+   * // Return input values for create operations
+   * const createResult = await builder
+   *   .returnValues('INPUT')
+   *   .execute();
    * ```
    *
-   * @param returnValues - Use 'ALL_OLD' to return previous values if the item was overwritten, or 'NONE' (default).
+   * @param returnValues - Use 'ALL_OLD' to return previous values, 'INPUT' to return input values, 'CONSISTENT' for fresh data, or 'NONE' (default).
    * @returns The builder instance for method chaining
    */
   returnValues(returnValues) {
@@ -2823,13 +2829,38 @@ var Table = class {
     return primaryCondition;
   }
   /**
-   * Creates a new item in the table, it will fail if the item already exists
+   * Creates a new item in the table, it will fail if the item already exists.
+   *
+   * By default, this method returns the input values passed to the create operation
+   * upon successful creation.
+   *
+   * You can customise the return behaviour by chaining the `.returnValues()` method:
    *
    * @param item The item to create
-   * @returns A PutBuilder instance for chaining conditions and executing the put operation
+   * @returns A PutBuilder instance for chaining additional conditions and executing the create operation
+   *
+   * @example
+   * ```ts
+   * // Create with default behavior (returns input values)
+   * const result = await table.create({
+   *   id: 'user-123',
+   *   name: 'John Doe',
+   *   email: 'john@example.com'
+   * }).execute();
+   * console.log(result); // Returns the input object
+   *
+   * // Create with no return value for better performance
+   * await table.create(userData).returnValues('NONE').execute();
+   *
+   * // Create and get fresh data from dynamodb using a strongly consistent read
+   * const freshData = await table.create(userData).returnValues('CONSISTENT').execute();
+   *
+   * // Create and get previous values (if the item was overwritten)
+   * const oldData = await table.create(userData).returnValues('ALL_OLD').execute();
+   * ```
    */
   create(item) {
-    return this.put(item).condition((op) => op.attributeNotExists(this.partitionKey));
+    return this.put(item).condition((op) => op.attributeNotExists(this.partitionKey)).returnValues("INPUT");
   }
   get(keyCondition) {
     const executor = async (params) => {
@@ -2866,10 +2897,13 @@ var Table = class {
           ConditionExpression: params.conditionExpression,
           ExpressionAttributeNames: params.expressionAttributeNames,
           ExpressionAttributeValues: params.expressionAttributeValues,
-          // CONSISTENT is not a valid ReturnValue for DDB, so we set NONE as we are not interested in its
-          // response and will be reloading the item from the DB through a get instead
-          ReturnValues: params.returnValues === "CONSISTENT" ? "NONE" : params.returnValues
+          // CONSISTENT and INPUT are not valid ReturnValues for DDB, so we set NONE as we are not interested in its
+          // response and will be handling these cases separately
+          ReturnValues: params.returnValues === "CONSISTENT" || params.returnValues === "INPUT" ? "NONE" : params.returnValues
         });
+        if (params.returnValues === "INPUT") {
+          return params.item;
+        }
         if (params.returnValues === "CONSISTENT") {
           const getResult = await this.dynamoClient.get({
             TableName: params.tableName,
@@ -3123,23 +3157,20 @@ var Table = class {
    * @param options Optional transaction options
    * @returns A promise that resolves when the transaction is complete
    */
-  transaction(callback, options) {
-    const executor = async () => {
-      const transactionExecutor = async (params) => {
-        await this.dynamoClient.transactWrite(params);
-      };
-      const transaction = new TransactionBuilder(transactionExecutor, {
-        partitionKey: this.partitionKey,
-        sortKey: this.sortKey
-      });
-      if (options) {
-        transaction.withOptions(options);
-      }
-      const result = await callback(transaction);
-      await transaction.execute();
-      return result;
+  async transaction(callback, options) {
+    const transactionExecutor = async (params) => {
+      await this.dynamoClient.transactWrite(params);
     };
-    return executor();
+    const transaction = new TransactionBuilder(transactionExecutor, {
+      partitionKey: this.partitionKey,
+      sortKey: this.sortKey
+    });
+    if (options) {
+      transaction.withOptions(options);
+    }
+    const result = await callback(transaction);
+    await transaction.execute();
+    return result;
   }
   /**
    * Creates a condition check operation for use in transactions