dyno-table 2.0.2 → 2.1.1

package/dist/index.cjs

@@ -521,30 +521,40 @@ var FilterBuilder = class {
    * @returns The builder instance for method chaining
    */
   filter(condition) {
-    if (typeof condition === "function") {
-      const conditionOperator = {
-        eq,
-        ne,
-        lt,
-        lte,
-        gt,
-        gte,
-        between,
-        inArray,
-        beginsWith,
-        contains,
-        attributeExists,
-        attributeNotExists,
-        and,
-        or,
-        not
-      };
-      this.options.filter = condition(conditionOperator);
+    const newCondition = typeof condition === "function" ? condition(this.getConditionOperator()) : condition;
+    if (this.options.filter) {
+      if (this.options.filter.type === "and" && this.options.filter.conditions) {
+        this.options.filter = {
+          type: "and",
+          conditions: [...this.options.filter.conditions, newCondition]
+        };
+      } else {
+        this.options.filter = and(this.options.filter, newCondition);
+      }
     } else {
-      this.options.filter = condition;
+      this.options.filter = newCondition;
     }
     return this;
   }
+  getConditionOperator() {
+    return {
+      eq,
+      ne,
+      lt,
+      lte,
+      gt,
+      gte,
+      between,
+      inArray,
+      beginsWith,
+      contains,
+      attributeExists,
+      attributeNotExists,
+      and,
+      or,
+      not
+    };
+  }
   /**
    * Specifies which attributes to return in the results.
    *
@@ -835,10 +845,23 @@ var QueryBuilder = class _QueryBuilder extends FilterBuilder {
    */
   clone() {
     const clone = new _QueryBuilder(this.executor, this.keyCondition);
-    clone.options = { ...this.options };
+    clone.options = {
+      ...this.options,
+      filter: this.deepCloneFilter(this.options.filter)
+    };
     clone.selectedFields = new Set(this.selectedFields);
     return clone;
   }
+  deepCloneFilter(filter) {
+    if (!filter) return filter;
+    if (filter.type === "and" || filter.type === "or") {
+      return {
+        ...filter,
+        conditions: filter.conditions?.map((condition) => this.deepCloneFilter(condition)).filter((c) => c !== void 0)
+      };
+    }
+    return { ...filter };
+  }
   /**
    * Executes the query against DynamoDB and returns a generator that behaves like an array.
    *
@@ -3157,10 +3180,23 @@ var ScanBuilder = class _ScanBuilder extends FilterBuilder {
    */
   clone() {
     const clone = new _ScanBuilder(this.executor);
-    clone.options = { ...this.options };
+    clone.options = {
+      ...this.options,
+      filter: this.deepCloneFilter(this.options.filter)
+    };
     clone.selectedFields = new Set(this.selectedFields);
     return clone;
   }
+  deepCloneFilter(filter) {
+    if (!filter) return filter;
+    if (filter.type === "and" || filter.type === "or") {
+      return {
+        ...filter,
+        conditions: filter.conditions?.map((condition) => this.deepCloneFilter(condition)).filter((c) => c !== void 0)
+      };
+    }
+    return { ...filter };
+  }
   /**
    * Executes the scan against DynamoDB and returns a generator that behaves like an array.
    *
@@ -3774,27 +3810,132 @@ function createEntityAwareDeleteBuilder(builder, entityName) {
   return createEntityAwareBuilder(builder, entityName);
 }
 
-// src/entity.ts
-function defineEntity(config) {
-  const entityTypeAttributeName = config.settings?.entityTypeAttributeName ?? "entityType";
-  const buildIndexes = (dataForKeyGeneration, table) => {
-    return Object.entries(config.indexes ?? {}).reduce(
-      (acc, [indexName, index]) => {
-        const key = index.generateKey(dataForKeyGeneration);
-        const gsiConfig = table.gsis[indexName];
-        if (!gsiConfig) {
-          throw new Error(`GSI configuration not found for index: ${indexName}`);
-        }
-        if (key.pk) {
-          acc[gsiConfig.partitionKey] = key.pk;
+// src/entity/ddb-indexing.ts
+var IndexBuilder = class {
+  /**
+   * Creates a new IndexBuilder instance
+   *
+   * @param table - The DynamoDB table instance
+   * @param indexes - The index definitions
+   */
+  constructor(table, indexes = {}) {
+    this.table = table;
+    this.indexes = indexes;
+  }
+  /**
+   * Build index attributes for item creation
+   *
+   * @param item - The item to generate indexes for
+   * @param options - Options for building indexes
+   * @returns Record of GSI attribute names to their values
+   */
+  buildForCreate(item, options = {}) {
+    const attributes = {};
+    for (const [indexName, indexDef] of Object.entries(this.indexes)) {
+      if (options.excludeReadOnly && indexDef.isReadOnly) {
+        continue;
+      }
+      const key = indexDef.generateKey(item);
+      const gsiConfig = this.table.gsis[indexName];
+      if (!gsiConfig) {
+        throw new Error(`GSI configuration not found for index: ${indexName}`);
+      }
+      if (key.pk) {
+        attributes[gsiConfig.partitionKey] = key.pk;
+      }
+      if (key.sk && gsiConfig.sortKey) {
+        attributes[gsiConfig.sortKey] = key.sk;
+      }
+    }
+    return attributes;
+  }
+  /**
+   * Build index attributes for item updates
+   *
+   * @param currentData - The current data before update
+   * @param updates - The update data
+   * @param options - Options for building indexes
+   * @returns Record of GSI attribute names to their updated values
+   */
+  buildForUpdate(currentData, updates) {
+    const attributes = {};
+    const updatedItem = { ...currentData, ...updates };
+    for (const [indexName, indexDef] of Object.entries(this.indexes)) {
+      if (indexDef.isReadOnly) {
+        continue;
+      }
+      let shouldUpdateIndex = false;
+      try {
+        const currentKey = indexDef.generateKey(currentData);
+        const updatedKey = indexDef.generateKey(updatedItem);
+        if (currentKey.pk !== updatedKey.pk || currentKey.sk !== updatedKey.sk) {
+          shouldUpdateIndex = true;
         }
-        if (key.sk && gsiConfig.sortKey) {
-          acc[gsiConfig.sortKey] = key.sk;
+      } catch {
+        shouldUpdateIndex = true;
+      }
+      if (!shouldUpdateIndex) {
+        continue;
+      }
+      let key;
+      try {
+        key = indexDef.generateKey(updatedItem);
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new Error(`Missing attributes: ${error.message}`);
         }
-        return acc;
-      },
-      {}
-    );
+        throw error;
+      }
+      if (this.hasUndefinedValues(key)) {
+        throw new Error(
+          `Missing attributes: Cannot update entity: insufficient data to regenerate index "${indexName}". All attributes required by the index must be provided in the update operation, or the index must be marked as readOnly.`
+        );
+      }
+      const gsiConfig = this.table.gsis[indexName];
+      if (!gsiConfig) {
+        throw new Error(`GSI configuration not found for index: ${indexName}`);
+      }
+      if (key.pk) {
+        attributes[gsiConfig.partitionKey] = key.pk;
+      }
+      if (key.sk && gsiConfig.sortKey) {
+        attributes[gsiConfig.sortKey] = key.sk;
+      }
+    }
+    return attributes;
+  }
+  /**
+   * Check if a key has undefined values
+   *
+   * @param key - The index key to check
+   * @returns True if the key contains undefined values, false otherwise
+   */
+  hasUndefinedValues(key) {
+    return (key.pk?.includes("undefined") ?? false) || (key.sk?.includes("undefined") ?? false);
+  }
+};
+
+// src/entity/index-utils.ts
+function buildIndexes(dataForKeyGeneration, table, indexes, excludeReadOnly = false) {
+  if (!indexes) {
+    return {};
+  }
+  const indexBuilder = new IndexBuilder(table, indexes);
+  return indexBuilder.buildForCreate(dataForKeyGeneration, { excludeReadOnly });
+}
+function buildIndexUpdates(currentData, updates, table, indexes) {
+  if (!indexes) {
+    return {};
+  }
+  const indexBuilder = new IndexBuilder(table, indexes);
+  return indexBuilder.buildForUpdate(currentData, updates);
+}
+
+// src/entity/entity.ts
+function defineEntity(config) {
+  const entityTypeAttributeName = config.settings?.entityTypeAttributeName ?? "entityType";
+  const buildIndexes2 = (dataForKeyGeneration, table, excludeReadOnly = false) => {
+    return buildIndexes(dataForKeyGeneration, table, config.indexes, excludeReadOnly);
   };
   const wrapMethodWithPreparation = (originalMethod, prepareFn, context) => {
     const wrappedMethod = (...args) => {
@@ -3846,7 +3987,7 @@ function defineEntity(config) {
               ...generateTimestamps(["createdAt", "updatedAt"], validatedData.value)
             };
             const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
-            const indexes = buildIndexes(dataForKeyGeneration, table);
+            const indexes = buildIndexes(dataForKeyGeneration, table, config.indexes, false);
             const validatedItem = {
               ...dataForKeyGeneration,
               [entityTypeAttributeName]: config.name,
@@ -3872,7 +4013,7 @@ function defineEntity(config) {
               ...generateTimestamps(["createdAt", "updatedAt"], validationResult.value)
             };
             const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
-            const indexes = buildIndexes(dataForKeyGeneration, table);
+            const indexes = buildIndexes(dataForKeyGeneration, table, config.indexes, false);
             const validatedItem = {
               ...dataForKeyGeneration,
               [entityTypeAttributeName]: config.name,
@@ -3914,7 +4055,7 @@ function defineEntity(config) {
               ...generateTimestamps(["createdAt", "updatedAt"], validatedData.value)
             };
             const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
-            const indexes = buildIndexes(dataForKeyGeneration, table);
+            const indexes = buildIndexes2(dataForKeyGeneration, table, false);
             const validatedItem = {
               [table.partitionKey]: primaryKey.pk,
               ...table.sortKey ? { [table.sortKey]: primaryKey.sk } : {},
@@ -3940,7 +4081,7 @@ function defineEntity(config) {
               ...generateTimestamps(["createdAt", "updatedAt"], validationResult.value)
             };
             const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
-            const indexes = buildIndexes(dataForKeyGeneration, table);
+            const indexes = buildIndexes(dataForKeyGeneration, table, config.indexes, false);
             const validatedItem = {
               [table.partitionKey]: primaryKey.pk,
               ...table.sortKey ? { [table.sortKey]: primaryKey.sk } : {},
@@ -3974,13 +4115,21 @@ function defineEntity(config) {
           }
           return createEntityAwarePutBuilder(builder, config.name);
         },
-        get: (key) => createEntityAwareGetBuilder(table.get(config.primaryKey.generateKey(key)), config.name),
+        get: (key) => {
+          return createEntityAwareGetBuilder(table.get(config.primaryKey.generateKey(key)), config.name);
+        },
         update: (key, data) => {
           const primaryKeyObj = config.primaryKey.generateKey(key);
           const builder = table.update(primaryKeyObj);
           builder.condition(eq(entityTypeAttributeName, config.name));
           const timestamps = generateTimestamps(["updatedAt"], data);
-          builder.set({ ...data, ...timestamps });
+          const indexUpdates = buildIndexUpdates(
+            { ...key },
+            { ...data, ...timestamps },
+            table,
+            config.indexes
+          );
+          builder.set({ ...data, ...timestamps, ...indexUpdates });
           return builder;
         },
         delete: (key) => {
@@ -4051,21 +4200,57 @@ function createQueries() {
 }
 function createIndex() {
   return {
-    input: (schema) => ({
-      partitionKey: (pkFn) => ({
-        sortKey: (skFn) => ({
-          name: "custom",
-          partitionKey: "pk",
-          sortKey: "sk",
-          generateKey: (item) => ({ pk: pkFn(item), sk: skFn(item) })
+    input: (schema) => {
+      const createIndexBuilder = (isReadOnly = false) => ({
+        partitionKey: (pkFn) => ({
+          sortKey: (skFn) => {
+            const index = {
+              name: "custom",
+              partitionKey: "pk",
+              sortKey: "sk",
+              isReadOnly,
+              generateKey: (item) => {
+                const data = schema["~standard"].validate(item);
+                if ("issues" in data && data.issues) {
+                  throw new Error(`Index validation failed: ${data.issues.map((i) => i.message).join(", ")}`);
+                }
+                const validData = "value" in data ? data.value : item;
+                return { pk: pkFn(validData), sk: skFn(validData) };
+              }
+            };
+            return Object.assign(index, {
+              readOnly: (value = false) => ({
+                ...index,
+                isReadOnly: value
+              })
+            });
+          },
+          withoutSortKey: () => {
+            const index = {
+              name: "custom",
+              partitionKey: "pk",
+              isReadOnly,
+              generateKey: (item) => {
+                const data = schema["~standard"].validate(item);
+                if ("issues" in data && data.issues) {
+                  throw new Error(`Index validation failed: ${data.issues.map((i) => i.message).join(", ")}`);
+                }
+                const validData = "value" in data ? data.value : item;
+                return { pk: pkFn(validData) };
+              }
+            };
+            return Object.assign(index, {
+              readOnly: (value = true) => ({
+                ...index,
+                isReadOnly: value
+              })
+            });
+          }
         }),
-        withoutSortKey: () => ({
-          name: "custom",
-          partitionKey: "pk",
-          generateKey: (item) => ({ pk: pkFn(item) })
-        })
-      })
-    })
+        readOnly: (value = true) => createIndexBuilder(value)
+      });
+      return createIndexBuilder(false);
+    }
   };
 }