dyno-table 1.3.0 → 1.4.0

package/dist/table.d.cts

@@ -1,12 +1,12 @@
 import './types.cjs';
-import './conditions-ChhQWd6z.cjs';
-import './query-builder-D2FM9rsu.cjs';
+import './conditions-x6kGWMR7.cjs';
+import './query-builder-Dg9Loeco.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-CM56NptV.cjs';
+export { T as Table } from './table-CmIQe-jD.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 './conditions-BIpBkh4m.js';
+import './query-builder-H9Dn0qaS.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-B3fvMnkB.js';
+export { T as Table } from './table-TI4ULfra.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

@@ -15,6 +15,11 @@ var between = (attr, lower, upper) => ({
   attr,
   value: [lower, upper]
 });
+var inArray = (attr, values) => ({
+  type: "in",
+  attr,
+  value: values
+});
 var beginsWith = createComparisonCondition("beginsWith");
 var contains = createComparisonCondition("contains");
 var attributeExists = (attr) => ({
@@ -84,6 +89,21 @@ var buildBetweenExpression = (condition, params) => {
   const upperName = generateValueName(params, condition.value[1]);
   return `${attrName} BETWEEN ${lowerName} AND ${upperName}`;
 };
+var buildInExpression = (condition, params) => {
+  validateCondition(condition);
+  if (!condition.attr) {
+    throw new Error(`Attribute is required for ${condition.type} condition`);
+  }
+  if (!Array.isArray(condition.value) || condition.value.length === 0) {
+    throw new Error("In condition requires a non-empty array of values");
+  }
+  if (condition.value.length > 100) {
+    throw new Error("In condition supports a maximum of 100 values");
+  }
+  const attrName = generateAttributeName(params, condition.attr);
+  const valueNames = condition.value.map((value) => generateValueName(params, value));
+  return `${attrName} IN (${valueNames.join(", ")})`;
+};
 var buildFunctionExpression = (functionName, condition, params) => {
   validateCondition(condition);
   if (!condition.attr) {
@@ -119,6 +139,7 @@ var buildExpression = (condition, params) => {
       gt: () => buildComparisonExpression(condition, ">", params),
       gte: () => buildComparisonExpression(condition, ">=", params),
       between: () => buildBetweenExpression(condition, params),
+      in: () => buildInExpression(condition, params),
       beginsWith: () => buildFunctionExpression("begins_with", condition, params),
       contains: () => buildFunctionExpression("contains", condition, params),
       attributeExists: () => buildAttributeFunction("attribute_exists", condition, params),
@@ -513,6 +534,7 @@ var FilterBuilder = class {
         gt,
         gte,
         between,
+        inArray,
         beginsWith,
         contains,
         attributeExists,
@@ -936,6 +958,7 @@ var PutBuilder = class {
         gt,
         gte,
         between,
+        inArray,
         beginsWith,
         contains,
         attributeExists,
@@ -956,7 +979,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 +999,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) {
@@ -1148,6 +1177,7 @@ var DeleteBuilder = class {
         gt,
         gte,
         between,
+        inArray,
         beginsWith,
         contains,
         attributeExists,
@@ -1452,6 +1482,7 @@ var UpdateBuilder = class {
         gt,
         gte,
         between,
+        inArray,
         beginsWith,
         contains,
         attributeExists,
@@ -2496,6 +2527,7 @@ var ConditionCheckBuilder = class {
         gt,
         gte,
         between,
+        inArray,
         beginsWith,
         contains,
         attributeExists,
@@ -2823,13 +2855,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 +2923,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,