dyno-table 2.5.2 → 2.6.1

package/dist/chunk-RNX2DAHA.js

@@ -1,818 +0,0 @@
-import { EntityErrors, OperationErrors, DynoTableError, ValidationErrors, IndexErrors, ConfigurationErrors } from './chunk-FF7FYGDH.js';
-import { eq } from './chunk-2WIBY7PZ.js';
-
-// 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 {
-      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/utils/error-utils.ts
-function isConditionalCheckFailed(error) {
-  if (typeof error === "object" && error !== null && "name" in error) {
-    return error.name === "ConditionalCheckFailedException";
-  }
-  return false;
-}
-function isTransactionCanceled(error) {
-  if (typeof error === "object" && error !== null && "name" in error) {
-    return error.name === "TransactionCanceledException";
-  }
-  return false;
-}
-function isValidationException(error) {
-  if (typeof error === "object" && error !== null && "name" in error) {
-    return error.name === "ValidationException";
-  }
-  return false;
-}
-function isProvisionedThroughputExceeded(error) {
-  if (typeof error === "object" && error !== null && "name" in error) {
-    return error.name === "ProvisionedThroughputExceededException";
-  }
-  return false;
-}
-function isRetryableError(error) {
-  if (typeof error === "object" && error !== null && "name" in error) {
-    const errorName = error.name;
-    return errorName === "ProvisionedThroughputExceededException" || errorName === "ThrottlingException" || errorName === "RequestLimitExceeded" || errorName === "InternalServerError" || errorName === "ServiceUnavailable";
-  }
-  return false;
-}
-function getAwsErrorCode(error) {
-  if (typeof error === "object" && error !== null && "name" in error) {
-    return error.name;
-  }
-  return void 0;
-}
-function getAwsErrorMessage(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  if (typeof error === "object" && error !== null && "message" in error) {
-    return String(error.message);
-  }
-  return void 0;
-}
-function extractRequiredAttributes(error) {
-  const message = getAwsErrorMessage(error);
-  if (!message) return void 0;
-  const patterns = [
-    /(?:missing|required)\s+(?:attribute|field|property)(?:s)?[:\s]+([a-zA-Z0-9_,\s]+)/i,
-    /(?:attribute|field|property)[:\s]+([a-zA-Z0-9_]+)\s+is\s+(?:missing|required)/i,
-    /"([a-zA-Z0-9_]+)"\s+is\s+(?:missing|required)/i
-  ];
-  for (const pattern of patterns) {
-    const match = message.match(pattern);
-    if (match?.[1]) {
-      return match[1].split(",").map((attr) => attr.trim()).filter((attr) => attr.length > 0);
-    }
-  }
-  return void 0;
-}
-function formatErrorContext(context, indent = 0) {
-  const indentStr = "  ".repeat(indent);
-  const lines = [];
-  for (const [key, value] of Object.entries(context)) {
-    if (value === void 0 || value === null) {
-      lines.push(`${indentStr}${key}: ${value}`);
-    } else if (Array.isArray(value)) {
-      lines.push(`${indentStr}${key}: [${value.map((v) => JSON.stringify(v)).join(", ")}]`);
-    } else if (typeof value === "object") {
-      lines.push(`${indentStr}${key}:`);
-      lines.push(formatErrorContext(value, indent + 1));
-    } else if (typeof value === "string" && value.length > 100) {
-      lines.push(`${indentStr}${key}: ${value.substring(0, 100)}...`);
-    } else {
-      lines.push(`${indentStr}${key}: ${JSON.stringify(value)}`);
-    }
-  }
-  return lines.join("\n");
-}
-function getErrorSummary(error) {
-  const parts = [];
-  parts.push(`Error: ${error.name}`);
-  parts.push(`Code: ${error.code}`);
-  parts.push(`Message: ${error.message}`);
-  if (Object.keys(error.context).length > 0) {
-    parts.push("Context:");
-    parts.push(formatErrorContext(error.context, 1));
-  }
-  if (error.cause) {
-    parts.push(`Caused by: ${error.cause.name}: ${error.cause.message}`);
-  }
-  return parts.join("\n");
-}
-function isDynoTableError(error) {
-  return typeof error === "object" && error !== null && "code" in error && "context" in error && error instanceof Error;
-}
-function isValidationError(error) {
-  return error instanceof Error && error.name === "ValidationError";
-}
-function isOperationError(error) {
-  return error instanceof Error && error.name === "OperationError";
-}
-function isTransactionError(error) {
-  return error instanceof Error && error.name === "TransactionError";
-}
-function isBatchError(error) {
-  return error instanceof Error && error.name === "BatchError";
-}
-function isExpressionError(error) {
-  return error instanceof Error && error.name === "ExpressionError";
-}
-function isConfigurationError(error) {
-  return error instanceof Error && error.name === "ConfigurationError";
-}
-function isEntityError(error) {
-  return error instanceof Error && error.name === "EntityError";
-}
-function isKeyGenerationError(error) {
-  return error instanceof Error && error.name === "KeyGenerationError";
-}
-function isIndexGenerationError(error) {
-  return error instanceof Error && error.name === "IndexGenerationError";
-}
-function isEntityValidationError(error) {
-  return error instanceof Error && error.name === "EntityValidationError";
-}
-
-// 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;
-      }
-      let key;
-      try {
-        key = indexDef.generateKey(item);
-        if (this.hasUndefinedValues(key)) {
-          throw IndexErrors.undefinedValues(indexName, "create", key, item);
-        }
-      } catch (error) {
-        if (error instanceof DynoTableError) throw error;
-        throw IndexErrors.generationFailed(
-          indexName,
-          "create",
-          item,
-          indexDef.partitionKey,
-          indexDef.sortKey,
-          error instanceof Error ? error : void 0
-        );
-      }
-      const gsiConfig = this.table.gsis[indexName];
-      if (!gsiConfig) {
-        throw ConfigurationErrors.gsiNotFound(indexName, this.table.tableName, Object.keys(this.table.gsis));
-      }
-      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 IndexErrors.notFound(invalidIndexes, Object.keys(this.indexes), void 0, this.table.tableName);
-      }
-    }
-    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 DynoTableError) throw error;
-        throw IndexErrors.missingAttributes(
-          indexName,
-          "update",
-          [],
-          // We don't know which specific attributes are missing from the error
-          updates,
-          indexDef.isReadOnly
-        );
-      }
-      if (this.hasUndefinedValues(key)) {
-        throw IndexErrors.undefinedValues(indexName, "update", key, updates);
-      }
-      const gsiConfig = this.table.gsis[indexName];
-      if (!gsiConfig) {
-        throw ConfigurationErrors.gsiNotFound(indexName, this.table.tableName, Object.keys(this.table.gsis));
-      }
-      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 EntityErrors.validationFailed(config.name, "create", validatedData.issues, data);
-            }
-            const dataForKeyGeneration = {
-              ...validatedData.value,
-              ...generateTimestamps(["createdAt", "updatedAt"], validatedData.value)
-            };
-            let primaryKey;
-            try {
-              primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
-              if (primaryKey.pk === void 0 || primaryKey.pk === null) {
-                throw EntityErrors.keyInvalidFormat(config.name, "create", dataForKeyGeneration, primaryKey);
-              }
-            } catch (error) {
-              if (error instanceof DynoTableError) throw error;
-              throw EntityErrors.keyGenerationFailed(
-                config.name,
-                "create",
-                dataForKeyGeneration,
-                extractRequiredAttributes(error),
-                error instanceof Error ? error : void 0
-              );
-            }
-            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 EntityErrors.asyncValidationNotSupported(config.name, "create");
-            }
-            if ("issues" in validationResult && validationResult.issues) {
-              throw EntityErrors.validationFailed(config.name, "create", validationResult.issues, data);
-            }
-            const dataForKeyGeneration = {
-              ...validationResult.value,
-              ...generateTimestamps(["createdAt", "updatedAt"], validationResult.value)
-            };
-            let primaryKey;
-            try {
-              primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
-              if (primaryKey.pk === void 0 || primaryKey.pk === null) {
-                throw EntityErrors.keyInvalidFormat(config.name, "create", dataForKeyGeneration, primaryKey);
-              }
-            } catch (error) {
-              if (error instanceof DynoTableError) throw error;
-              throw EntityErrors.keyGenerationFailed(
-                config.name,
-                "create",
-                dataForKeyGeneration,
-                extractRequiredAttributes(error),
-                error instanceof Error ? error : void 0
-              );
-            }
-            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 EntityErrors.validationFailed(config.name, "upsert", validatedData.issues, data);
-            }
-            const dataForKeyGeneration = {
-              ...validatedData.value,
-              ...generateTimestamps(["createdAt", "updatedAt"], validatedData.value)
-            };
-            let primaryKey;
-            try {
-              primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
-              if (primaryKey.pk === void 0 || primaryKey.pk === null) {
-                throw EntityErrors.keyInvalidFormat(config.name, "upsert", dataForKeyGeneration, primaryKey);
-              }
-            } catch (error) {
-              if (error instanceof DynoTableError) throw error;
-              throw EntityErrors.keyGenerationFailed(
-                config.name,
-                "upsert",
-                dataForKeyGeneration,
-                extractRequiredAttributes(error),
-                error instanceof Error ? error : void 0
-              );
-            }
-            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 EntityErrors.asyncValidationNotSupported(config.name, "upsert");
-            }
-            if ("issues" in validationResult && validationResult.issues) {
-              throw EntityErrors.validationFailed(config.name, "upsert", validationResult.issues, data);
-            }
-            const dataForKeyGeneration = {
-              ...validationResult.value,
-              ...generateTimestamps(["createdAt", "updatedAt"], validationResult.value)
-            };
-            let primaryKey;
-            try {
-              primaryKey = config.primaryKey.generateKey(dataForKeyGeneration);
-              if (primaryKey.pk === void 0 || primaryKey.pk === null) {
-                throw EntityErrors.keyInvalidFormat(config.name, "upsert", dataForKeyGeneration, primaryKey);
-              }
-            } catch (error) {
-              if (error instanceof DynoTableError) throw error;
-              throw EntityErrors.keyGenerationFailed(
-                config.name,
-                "upsert",
-                dataForKeyGeneration,
-                extractRequiredAttributes(error),
-                error instanceof Error ? error : void 0
-              );
-            }
-            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 () => {
-            const validatedItem = await prepareValidatedItemAsync();
-            await originalExecute.call(builder);
-            return validatedItem;
-          };
-          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) => {
-          const builder = table.get(config.primaryKey.generateKey(key));
-          return createEntityAwareGetBuilder(builder, config.name);
-        },
-        update: (key, data) => {
-          const primaryKeyObj = config.primaryKey.generateKey(key);
-          const builder = table.update(primaryKeyObj);
-          builder.condition(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(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(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 EntityErrors.queryInputValidationFailed(config.name, key, validationResult.issues, input);
-                      }
-                    }
-                  }
-                  const result = await originalExecute.call(builder);
-                  if (!result) {
-                    throw OperationErrors.queryFailed(config.name, { queryName: key }, void 0);
-                  }
-                  return result;
-                };
-              }
-              return builder;
-            };
-            return acc;
-          },
-          {}
-        ),
-        scan: () => {
-          const builder = table.scan();
-          builder.filter(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 ValidationErrors.indexSchemaValidationFailed(data.issues, "both");
-                }
-                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 ValidationErrors.indexSchemaValidationFailed(data.issues, "partition");
-                }
-                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);
-    }
-  };
-}
-
-export { createIndex, createQueries, defineEntity, extractRequiredAttributes, formatErrorContext, getAwsErrorCode, getAwsErrorMessage, getErrorSummary, isBatchError, isConditionalCheckFailed, isConfigurationError, isDynoTableError, isEntityError, isEntityValidationError, isExpressionError, isIndexGenerationError, isKeyGenerationError, isOperationError, isProvisionedThroughputExceeded, isRetryableError, isTransactionCanceled, isTransactionError, isValidationError, isValidationException };