dyno-table 2.0.2 → 2.1.0

package/dist/index.js

@@ -3772,27 +3772,133 @@ 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];
+// 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;
+        }
+      } catch {
+        shouldUpdateIndex = true;
+      }
+      if (!shouldUpdateIndex) {
+        continue;
+      }
+      try {
+        const key = indexDef.generateKey(updatedItem);
+        if (this.hasUndefinedValues(key)) {
+          throw new Error(
+            `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) {
-          acc[gsiConfig.partitionKey] = key.pk;
+          attributes[gsiConfig.partitionKey] = key.pk;
         }
         if (key.sk && gsiConfig.sortKey) {
-          acc[gsiConfig.sortKey] = key.sk;
+          attributes[gsiConfig.sortKey] = key.sk;
         }
-        return acc;
-      },
-      {}
-    );
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("insufficient data")) {
+          throw error;
+        }
+        throw new Error(
+          `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 readOnly.`
+        );
+      }
+    }
+    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) => {
@@ -3844,7 +3950,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,
@@ -3870,7 +3976,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,
@@ -3912,7 +4018,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 } : {},
@@ -3938,7 +4044,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 } : {},
@@ -3972,13 +4078,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) => {
@@ -4049,21 +4163,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);
+    }
   };
 }