dyno-table 2.2.0 → 2.3.0

package/dist/chunk-NTA6GDPP.cjs

@@ -0,0 +1,622 @@
+'use strict';
+
+var chunk7UJJ7JXM_cjs = require('./chunk-7UJJ7JXM.cjs');
+
+// src/builders/entity-aware-builders.ts
+function createEntityAwareBuilder(builder, entityName) {
+  return new Proxy(builder, {
+    get(target, prop, receiver) {
+      if (prop === "entityName") {
+        return entityName;
+      }
+      if (prop === "withBatch" && typeof target[prop] === "function") {
+        return (batch, entityType) => {
+          const typeToUse = entityType ?? entityName;
+          const fn = target[prop];
+          return fn.call(target, batch, typeToUse);
+        };
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function createEntityAwarePutBuilder(builder, entityName) {
+  return createEntityAwareBuilder(builder, entityName);
+}
+function createEntityAwareGetBuilder(builder, entityName) {
+  return createEntityAwareBuilder(builder, entityName);
+}
+function createEntityAwareDeleteBuilder(builder, entityName) {
+  return createEntityAwareBuilder(builder, entityName);
+}
+var EntityAwareUpdateBuilder = class {
+  forceRebuildIndexes = [];
+  entityName;
+  builder;
+  entityConfig;
+  updateDataApplied = false;
+  constructor(builder, entityName) {
+    this.builder = builder;
+    this.entityName = entityName;
+  }
+  /**
+   * Configure entity-specific logic for automatic timestamp generation and index updates
+   */
+  configureEntityLogic(config) {
+    this.entityConfig = config;
+  }
+  /**
+   * Forces a rebuild of one or more readonly indexes during the update operation.
+   *
+   * By default, readonly indexes are not updated during entity updates to prevent
+   * errors when required index attributes are missing. This method allows you to
+   * override that behavior and force specific indexes to be rebuilt.
+   *
+   * @example
+   * ```typescript
+   * // Force rebuild a single readonly index
+   * const result = await repo.update({ id: 'TREX-001' }, { status: 'ACTIVE' })
+   *   .forceIndexRebuild('gsi1')
+   *   .execute();
+   *
+   * // Force rebuild multiple readonly indexes
+   * const result = await repo.update({ id: 'TREX-001' }, { status: 'ACTIVE' })
+   *   .forceIndexRebuild(['gsi1', 'gsi2'])
+   *   .execute();
+   *
+   * // Chain with other update operations
+   * const result = await repo.update({ id: 'TREX-001' }, { status: 'ACTIVE' })
+   *   .set('lastUpdated', new Date().toISOString())
+   *   .forceIndexRebuild('gsi1')
+   *   .condition(op => op.eq('status', 'INACTIVE'))
+   *   .execute();
+   * ```
+   *
+   * @param indexes - A single index name or array of index names to force rebuild
+   * @returns The builder instance for method chaining
+   */
+  forceIndexRebuild(indexes) {
+    if (Array.isArray(indexes)) {
+      this.forceRebuildIndexes = [...this.forceRebuildIndexes, ...indexes];
+    } else {
+      this.forceRebuildIndexes.push(indexes);
+    }
+    return this;
+  }
+  /**
+   * Gets the list of indexes that should be force rebuilt.
+   * This is used internally by entity update logic.
+   *
+   * @returns Array of index names to force rebuild
+   */
+  getForceRebuildIndexes() {
+    return [...this.forceRebuildIndexes];
+  }
+  /**
+   * Apply entity-specific update data (timestamps and index updates)
+   * This is called automatically when needed
+   */
+  applyEntityUpdates() {
+    if (!this.entityConfig || this.updateDataApplied) return;
+    const timestamps = this.entityConfig.generateTimestamps();
+    const updatedItem = { ...this.entityConfig.key, ...this.entityConfig.data, ...timestamps };
+    const indexUpdates = this.entityConfig.buildIndexUpdates(
+      this.entityConfig.key,
+      updatedItem,
+      this.entityConfig.table,
+      this.entityConfig.indexes,
+      this.forceRebuildIndexes
+    );
+    this.builder.set({ ...this.entityConfig.data, ...timestamps, ...indexUpdates });
+    this.updateDataApplied = true;
+  }
+  set(valuesOrPath, value) {
+    if (typeof valuesOrPath === "object") {
+      this.builder.set(valuesOrPath);
+    } else {
+      if (value === void 0) {
+        throw new Error("Value is required when setting a single path");
+      }
+      this.builder.set(valuesOrPath, value);
+    }
+    return this;
+  }
+  remove(path) {
+    this.builder.remove(path);
+    return this;
+  }
+  add(path, value) {
+    this.builder.add(path, value);
+    return this;
+  }
+  deleteElementsFromSet(path, value) {
+    this.builder.deleteElementsFromSet(path, value);
+    return this;
+  }
+  condition(condition) {
+    this.builder.condition(condition);
+    return this;
+  }
+  returnValues(returnValues) {
+    this.builder.returnValues(returnValues);
+    return this;
+  }
+  toDynamoCommand() {
+    return this.builder.toDynamoCommand();
+  }
+  withTransaction(transaction) {
+    this.applyEntityUpdates();
+    this.builder.withTransaction(transaction);
+  }
+  debug() {
+    return this.builder.debug();
+  }
+  async execute() {
+    this.updateDataApplied = false;
+    this.applyEntityUpdates();
+    return this.builder.execute();
+  }
+};
+function createEntityAwareUpdateBuilder(builder, entityName) {
+  return new EntityAwareUpdateBuilder(builder, entityName);
+}
+
+// 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, options = {}) {
+    const attributes = {};
+    const updatedItem = { ...currentData, ...updates };
+    if (options.forceRebuildIndexes && options.forceRebuildIndexes.length > 0) {
+      const invalidIndexes = options.forceRebuildIndexes.filter((indexName) => !this.indexes[indexName]);
+      if (invalidIndexes.length > 0) {
+        throw new Error(
+          `Cannot force rebuild unknown indexes: ${invalidIndexes.join(", ")}. Available indexes: ${Object.keys(this.indexes).join(", ")}`
+        );
+      }
+    }
+    for (const [indexName, indexDef] of Object.entries(this.indexes)) {
+      const isForced = options.forceRebuildIndexes?.includes(indexName);
+      if (indexDef.isReadOnly && !isForced) {
+        continue;
+      }
+      if (!isForced) {
+        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;
+        }
+      }
+      let key;
+      try {
+        key = indexDef.generateKey(updatedItem);
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new Error(`Missing attributes: ${error.message}`);
+        }
+        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, forceRebuildIndexes) {
+  if (!indexes) {
+    return {};
+  }
+  const indexBuilder = new IndexBuilder(table, indexes);
+  return indexBuilder.buildForUpdate(currentData, updates, { forceRebuildIndexes });
+}
+
+// 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) => {
+      prepareFn();
+      return originalMethod.call(context, ...args);
+    };
+    Object.setPrototypeOf(wrappedMethod, originalMethod);
+    const propertyNames = Object.getOwnPropertyNames(originalMethod);
+    for (let i = 0; i < propertyNames.length; i++) {
+      const prop = propertyNames[i];
+      if (prop !== "length" && prop !== "name" && prop !== "prototype") {
+        const descriptor = Object.getOwnPropertyDescriptor(originalMethod, prop);
+        if (descriptor && descriptor.writable !== false && !descriptor.get) {
+          wrappedMethod[prop] = originalMethod[prop];
+        }
+      }
+    }
+    return wrappedMethod;
+  };
+  const generateTimestamps = (timestampsToGenerate, data) => {
+    if (!config.settings?.timestamps) return {};
+    const timestamps = {};
+    const now = /* @__PURE__ */ new Date();
+    const unixTime = Math.floor(Date.now() / 1e3);
+    const { createdAt, updatedAt } = config.settings.timestamps;
+    if (createdAt && timestampsToGenerate.includes("createdAt") && !data.createdAt) {
+      const name = createdAt.attributeName ?? "createdAt";
+      timestamps[name] = createdAt.format === "UNIX" ? unixTime : now.toISOString();
+    }
+    if (updatedAt && timestampsToGenerate.includes("updatedAt") && !data.updatedAt) {
+      const name = updatedAt.attributeName ?? "updatedAt";
+      timestamps[name] = updatedAt.format === "UNIX" ? unixTime : now.toISOString();
+    }
+    return timestamps;
+  };
+  return {
+    name: config.name,
+    createRepository: (table) => {
+      const repository = {
+        create: (data) => {
+          const builder = table.create({});
+          const prepareValidatedItemAsync = async () => {
+            const validatedData = await config.schema["~standard"].validate(data);
+            if ("issues" in validatedData && validatedData.issues) {
+              throw new Error(`Validation failed: ${validatedData.issues.map((i) => i.message).join(", ")}`);
+            }
+            const dataForKeyGeneration = {
+              ...validatedData.value,
+              ...generateTimestamps(["createdAt", "updatedAt"], validatedData.value)
+            };
+            const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
+            const indexes = buildIndexes(dataForKeyGeneration, table, config.indexes, false);
+            const validatedItem = {
+              ...dataForKeyGeneration,
+              [entityTypeAttributeName]: config.name,
+              [table.partitionKey]: primaryKey.pk,
+              ...table.sortKey ? { [table.sortKey]: primaryKey.sk } : {},
+              ...indexes
+            };
+            Object.assign(builder, { item: validatedItem });
+            return validatedItem;
+          };
+          const prepareValidatedItemSync = () => {
+            const validationResult = config.schema["~standard"].validate(data);
+            if (validationResult instanceof Promise) {
+              throw new Error(
+                "Async validation is not supported in withBatch or withTransaction. The schema must support synchronous validation for compatibility."
+              );
+            }
+            if ("issues" in validationResult && validationResult.issues) {
+              throw new Error(`Validation failed: ${validationResult.issues.map((i) => i.message).join(", ")}`);
+            }
+            const dataForKeyGeneration = {
+              ...validationResult.value,
+              ...generateTimestamps(["createdAt", "updatedAt"], validationResult.value)
+            };
+            const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
+            const indexes = buildIndexes(dataForKeyGeneration, table, config.indexes, false);
+            const validatedItem = {
+              ...dataForKeyGeneration,
+              [entityTypeAttributeName]: config.name,
+              [table.partitionKey]: primaryKey.pk,
+              ...table.sortKey ? { [table.sortKey]: primaryKey.sk } : {},
+              ...indexes
+            };
+            Object.assign(builder, { item: validatedItem });
+            return validatedItem;
+          };
+          const originalExecute = builder.execute;
+          builder.execute = async () => {
+            await prepareValidatedItemAsync();
+            return await originalExecute.call(builder);
+          };
+          const originalWithTransaction = builder.withTransaction;
+          if (originalWithTransaction) {
+            builder.withTransaction = wrapMethodWithPreparation(
+              originalWithTransaction,
+              prepareValidatedItemSync,
+              builder
+            );
+          }
+          const originalWithBatch = builder.withBatch;
+          if (originalWithBatch) {
+            builder.withBatch = wrapMethodWithPreparation(originalWithBatch, prepareValidatedItemSync, builder);
+          }
+          return createEntityAwarePutBuilder(builder, config.name);
+        },
+        upsert: (data) => {
+          const builder = table.put({});
+          const prepareValidatedItemAsync = async () => {
+            const validatedData = await config.schema["~standard"].validate(data);
+            if ("issues" in validatedData && validatedData.issues) {
+              throw new Error(`Validation failed: ${validatedData.issues.map((i) => i.message).join(", ")}`);
+            }
+            const dataForKeyGeneration = {
+              ...validatedData.value,
+              ...generateTimestamps(["createdAt", "updatedAt"], validatedData.value)
+            };
+            const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
+            const indexes = buildIndexes2(dataForKeyGeneration, table, false);
+            const validatedItem = {
+              [table.partitionKey]: primaryKey.pk,
+              ...table.sortKey ? { [table.sortKey]: primaryKey.sk } : {},
+              ...dataForKeyGeneration,
+              [entityTypeAttributeName]: config.name,
+              ...indexes
+            };
+            Object.assign(builder, { item: validatedItem });
+            return validatedItem;
+          };
+          const prepareValidatedItemSync = () => {
+            const validationResult = config.schema["~standard"].validate(data);
+            if (validationResult instanceof Promise) {
+              throw new Error(
+                "Async validation is not supported in withTransaction or withBatch. Use execute() instead."
+              );
+            }
+            if ("issues" in validationResult && validationResult.issues) {
+              throw new Error(`Validation failed: ${validationResult.issues.map((i) => i.message).join(", ")}`);
+            }
+            const dataForKeyGeneration = {
+              ...validationResult.value,
+              ...generateTimestamps(["createdAt", "updatedAt"], validationResult.value)
+            };
+            const primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
+            const indexes = buildIndexes(dataForKeyGeneration, table, config.indexes, false);
+            const validatedItem = {
+              [table.partitionKey]: primaryKey.pk,
+              ...table.sortKey ? { [table.sortKey]: primaryKey.sk } : {},
+              ...dataForKeyGeneration,
+              [entityTypeAttributeName]: config.name,
+              ...indexes
+            };
+            Object.assign(builder, { item: validatedItem });
+            return validatedItem;
+          };
+          const originalExecute = builder.execute;
+          builder.execute = async () => {
+            await prepareValidatedItemAsync();
+            const result = await originalExecute.call(builder);
+            if (!result) {
+              throw new Error("Failed to upsert item");
+            }
+            return result;
+          };
+          const originalWithTransaction = builder.withTransaction;
+          if (originalWithTransaction) {
+            builder.withTransaction = wrapMethodWithPreparation(
+              originalWithTransaction,
+              prepareValidatedItemSync,
+              builder
+            );
+          }
+          const originalWithBatch = builder.withBatch;
+          if (originalWithBatch) {
+            builder.withBatch = wrapMethodWithPreparation(originalWithBatch, prepareValidatedItemSync, builder);
+          }
+          return createEntityAwarePutBuilder(builder, 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(chunk7UJJ7JXM_cjs.eq(entityTypeAttributeName, config.name));
+          const entityAwareBuilder = createEntityAwareUpdateBuilder(builder, config.name);
+          entityAwareBuilder.configureEntityLogic({
+            data,
+            key,
+            table,
+            indexes: config.indexes,
+            generateTimestamps: () => generateTimestamps(["updatedAt"], data),
+            buildIndexUpdates
+          });
+          return entityAwareBuilder;
+        },
+        delete: (key) => {
+          const builder = table.delete(config.primaryKey.generateKey(key));
+          builder.condition(chunk7UJJ7JXM_cjs.eq(entityTypeAttributeName, config.name));
+          return createEntityAwareDeleteBuilder(builder, config.name);
+        },
+        query: Object.entries(config.queries || {}).reduce((acc, [key, inputCallback]) => {
+          acc[key] = (input) => {
+            const queryEntity = {
+              scan: repository.scan,
+              get: (key2) => createEntityAwareGetBuilder(table.get(key2), config.name),
+              query: (keyCondition) => {
+                return table.query(keyCondition);
+              }
+            };
+            const queryBuilderCallback = inputCallback(input);
+            const builder = queryBuilderCallback(queryEntity);
+            if (builder && typeof builder === "object" && "filter" in builder && typeof builder.filter === "function") {
+              builder.filter(chunk7UJJ7JXM_cjs.eq(entityTypeAttributeName, config.name));
+            }
+            if (builder && typeof builder === "object" && "execute" in builder) {
+              const originalExecute = builder.execute;
+              builder.execute = async () => {
+                const queryFn = config.queries[key];
+                if (queryFn && typeof queryFn === "function") {
+                  const schema = queryFn.schema;
+                  if (schema?.["~standard"]?.validate && typeof schema["~standard"].validate === "function") {
+                    const validationResult = schema["~standard"].validate(input);
+                    if ("issues" in validationResult && validationResult.issues) {
+                      throw new Error(
+                        `Validation failed: ${validationResult.issues.map((issue) => issue.message).join(", ")}`
+                      );
+                    }
+                  }
+                }
+                const result = await originalExecute.call(builder);
+                if (!result) {
+                  throw new Error("Failed to execute query");
+                }
+                return result;
+              };
+            }
+            return builder;
+          };
+          return acc;
+        }, {}),
+        scan: () => {
+          const builder = table.scan();
+          builder.filter(chunk7UJJ7JXM_cjs.eq(entityTypeAttributeName, config.name));
+          return builder;
+        }
+      };
+      return repository;
+    }
+  };
+}
+function createQueries() {
+  return {
+    input: (schema) => ({
+      query: (handler) => {
+        const queryFn = (input) => (entity) => handler({ input, entity });
+        queryFn.schema = schema;
+        return queryFn;
+      }
+    })
+  };
+}
+function createIndex() {
+  return {
+    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
+              })
+            });
+          }
+        }),
+        readOnly: (value = true) => createIndexBuilder(value)
+      });
+      return createIndexBuilder(false);
+    }
+  };
+}
+
+exports.createIndex = createIndex;
+exports.createQueries = createQueries;
+exports.defineEntity = defineEntity;

package/dist/chunk-PB7BBCZO.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+// src/utils/partition-key-template.ts
+function partitionKey(strings, ...keys) {
+  return (params) => {
+    let result = strings[0] ?? "";
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      if (key) {
+        result += params[key] + (strings[i + 1] ?? "");
+      }
+    }
+    return result;
+  };
+}
+
+// src/utils/sort-key-template.ts
+function sortKey(strings, ...keys) {
+  return (params) => {
+    let result = strings[0] ?? "";
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      if (key && params && key in params) {
+        result += params[key] + (strings[i + 1] ?? "");
+      }
+    }
+    return result;
+  };
+}
+
+exports.partitionKey = partitionKey;
+exports.sortKey = sortKey;

package/dist/chunk-QVRMYGC4.js

@@ -0,0 +1,29 @@
+// src/utils/partition-key-template.ts
+function partitionKey(strings, ...keys) {
+  return (params) => {
+    let result = strings[0] ?? "";
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      if (key) {
+        result += params[key] + (strings[i + 1] ?? "");
+      }
+    }
+    return result;
+  };
+}
+
+// src/utils/sort-key-template.ts
+function sortKey(strings, ...keys) {
+  return (params) => {
+    let result = strings[0] ?? "";
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      if (key && params && key in params) {
+        result += params[key] + (strings[i + 1] ?? "");
+      }
+    }
+    return result;
+  };
+}
+
+export { partitionKey, sortKey };