dyno-table 0.0.1

package/dist/index.js

@@ -0,0 +1,1083 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BaseRepository: () => BaseRepository,
+  ConditionalCheckFailedError: () => ConditionalCheckFailedError,
+  DynamoError: () => DynamoError,
+  ExponentialBackoffStrategy: () => ExponentialBackoffStrategy,
+  ResourceNotFoundError: () => ResourceNotFoundError,
+  Table: () => Table
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/builders/expression-builder.ts
+var ExpressionBuilder = class {
+  nameCount = 0;
+  valueCount = 0;
+  generateAlias(type, prefix = type === "name" ? "n" : "v") {
+    const count = type === "name" ? this.nameCount++ : this.valueCount++;
+    const symbol = type === "name" ? "#" : ":";
+    return `${symbol}${prefix}${count}`;
+  }
+  reset() {
+    this.nameCount = 0;
+    this.valueCount = 0;
+  }
+  createAttributePath(path) {
+    const parts = path.split(".");
+    const aliases = parts.map(() => this.generateAlias("name"));
+    return {
+      path: aliases.join("."),
+      names: Object.fromEntries(parts.map((part, i) => [aliases[i], part]))
+    };
+  }
+  addValue(attributes, value, prefix) {
+    const alias = this.generateAlias("value", prefix);
+    attributes.values[alias] = value;
+    return alias;
+  }
+  buildComparison(path, operator, value, attributes, prefix) {
+    const simpleOperators = ["=", "<>", "<", "<=", ">", ">="];
+    if (simpleOperators.includes(operator)) {
+      const valueAlias = this.addValue(attributes, value, prefix);
+      return `${path} ${operator} ${valueAlias}`;
+    }
+    switch (operator) {
+      case "attribute_exists":
+      case "attribute_not_exists":
+        return `${operator}(${path})`;
+      case "begins_with":
+      case "contains":
+      case "attribute_type":
+        return `${operator}(${path}, ${this.addValue(attributes, value, prefix)})`;
+      case "not_contains":
+        return `NOT contains(${path}, ${this.addValue(attributes, value, prefix)})`;
+      case "size": {
+        const { compare, value: sizeValue } = value;
+        return `size(${path}) ${compare} ${this.addValue(attributes, sizeValue, prefix)}`;
+      }
+      case "BETWEEN": {
+        const valueAlias = this.addValue(attributes, value, prefix);
+        return `${path} BETWEEN ${valueAlias}[0] AND ${valueAlias}[1]`;
+      }
+      case "IN":
+        return `${path} IN (${this.addValue(attributes, value, prefix)})`;
+      default:
+        throw new Error(`Unsupported operator: ${operator}`);
+    }
+  }
+  createExpression(conditions) {
+    this.reset();
+    const attributes = { names: {}, values: {} };
+    const expressions = conditions.map(({ field, operator, value }) => {
+      const { path, names } = this.createAttributePath(field);
+      Object.assign(attributes.names, names);
+      return this.buildComparison(path, operator, value, attributes);
+    });
+    return {
+      expression: expressions.length ? expressions.join(" AND ") : void 0,
+      attributes: this.formatAttributes(attributes)
+    };
+  }
+  formatAttributes({
+    names,
+    values
+  }) {
+    return {
+      ...Object.keys(names).length && { names },
+      ...Object.keys(values).length && { values }
+    };
+  }
+  buildKeyCondition(key, indexConfig) {
+    this.reset();
+    const attributes = { names: {}, values: {} };
+    const conditions = [];
+    const pkName = this.generateAlias("name", "pk");
+    attributes.names[pkName] = indexConfig.pkName;
+    conditions.push(`${pkName} = ${this.addValue(attributes, key.pk, "pk")}`);
+    if (key.sk && indexConfig.skName) {
+      const skName = this.generateAlias("name", "sk");
+      attributes.names[skName] = indexConfig.skName;
+      if (typeof key.sk === "string") {
+        conditions.push(
+          `${skName} = ${this.addValue(attributes, key.sk, "sk")}`
+        );
+      } else {
+        conditions.push(
+          this.buildComparison(
+            skName,
+            key.sk.operator,
+            key.sk.value,
+            attributes
+          )
+        );
+      }
+    }
+    return {
+      expression: conditions.join(" AND "),
+      attributes: this.formatAttributes(attributes)
+    };
+  }
+  buildUpdateExpression(updates) {
+    this.reset();
+    const attributes = { names: {}, values: {} };
+    const operations = { sets: [], removes: [] };
+    for (const [key, value] of Object.entries(updates)) {
+      if (key === "") {
+        throw new Error("Empty key provided");
+      }
+      const nameAlias = this.generateAlias("name", "u");
+      attributes.names[nameAlias] = key;
+      if (value == null) {
+        operations.removes.push(nameAlias);
+      } else {
+        const valueAlias = this.addValue(attributes, value, "u");
+        operations.sets.push(`${nameAlias} = ${valueAlias}`);
+      }
+    }
+    const expression = [
+      operations.sets.length && `SET ${operations.sets.join(", ")}`,
+      operations.removes.length && `REMOVE ${operations.removes.join(", ")}`
+    ].filter(Boolean).join(" ");
+    return {
+      expression,
+      attributes: this.formatAttributes(attributes)
+    };
+  }
+};
+
+// src/builders/operation-builder.ts
+var OperationBuilder = class {
+  constructor(expressionBuilder) {
+    this.expressionBuilder = expressionBuilder;
+  }
+  conditions = [];
+  where(field, operator, value) {
+    this.conditions.push({ field, operator, value });
+    return this;
+  }
+  whereExists(field) {
+    this.conditions.push({ field, operator: "attribute_exists" });
+    return this;
+  }
+  whereNotExists(field) {
+    this.conditions.push({ field, operator: "attribute_not_exists" });
+    return this;
+  }
+  whereEquals(field, value) {
+    return this.where(field, "=", value);
+  }
+  whereBetween(field, start, end) {
+    return this.where(field, "BETWEEN", [start, end]);
+  }
+  whereIn(field, values) {
+    return this.where(field, "IN", values);
+  }
+  buildConditionExpression() {
+    return this.expressionBuilder.createExpression(this.conditions);
+  }
+};
+
+// src/builders/put-builder.ts
+var PutBuilder = class extends OperationBuilder {
+  constructor(item, expressionBuilder, onBuild) {
+    super(expressionBuilder);
+    this.item = item;
+    this.onBuild = onBuild;
+  }
+  build() {
+    const { expression, attributes } = this.buildConditionExpression();
+    return {
+      type: "put",
+      item: this.item,
+      condition: expression ? {
+        expression,
+        names: attributes.names,
+        values: attributes.values
+      } : void 0
+    };
+  }
+  async execute() {
+    return this.onBuild(this.build());
+  }
+};
+
+// src/builders/query-builder.ts
+var QueryBuilder = class extends OperationBuilder {
+  constructor(key, indexConfig, expressionBuilder, onBuild) {
+    super(expressionBuilder);
+    this.key = key;
+    this.indexConfig = indexConfig;
+    this.onBuild = onBuild;
+  }
+  limitValue;
+  indexNameValue;
+  limit(value) {
+    this.limitValue = value;
+    return this;
+  }
+  useIndex(indexName) {
+    this.indexNameValue = indexName;
+    return this;
+  }
+  build() {
+    const filter = this.buildConditionExpression();
+    const keyCondition = this.expressionBuilder.buildKeyCondition(
+      this.key,
+      this.indexConfig
+    );
+    return {
+      type: "query",
+      keyCondition: {
+        expression: keyCondition.expression,
+        names: keyCondition.attributes.names,
+        values: keyCondition.attributes.values
+      },
+      filter: filter.expression ? {
+        expression: filter.expression,
+        names: filter.attributes.names,
+        values: filter.attributes.values
+      } : void 0,
+      limit: this.limitValue,
+      indexName: this.indexNameValue
+    };
+  }
+  async execute() {
+    return this.onBuild(this.build());
+  }
+};
+
+// src/builders/update-builder.ts
+var UpdateBuilder = class extends OperationBuilder {
+  constructor(key, expressionBuilder, onBuild) {
+    super(expressionBuilder);
+    this.key = key;
+    this.onBuild = onBuild;
+  }
+  updates = {};
+  set(field, value) {
+    this.updates[field] = value;
+    return this;
+  }
+  setMany(attribtues) {
+    this.updates = { ...this.updates, ...attribtues };
+    return this;
+  }
+  remove(...fields) {
+    for (const field of fields) {
+      this.updates[field] = null;
+    }
+    return this;
+  }
+  increment(field, by = 1) {
+    this.updates[field] = { $add: by };
+    return this;
+  }
+  build() {
+    const condition = this.buildConditionExpression();
+    const update = this.expressionBuilder.buildUpdateExpression(this.updates);
+    return {
+      type: "update",
+      key: this.key,
+      update: {
+        expression: update.expression,
+        names: update.attributes.names,
+        values: update.attributes.values
+      },
+      condition: condition.expression ? {
+        expression: condition.expression,
+        names: condition.attributes.names,
+        values: condition.attributes.values
+      } : void 0
+    };
+  }
+  async execute() {
+    return this.onBuild(this.build());
+  }
+};
+
+// src/errors/dynamo-error.ts
+var DynamoError = class _DynamoError extends Error {
+  constructor(message, originalError, context) {
+    super(message);
+    this.originalError = originalError;
+    this.context = context;
+    this.name = "DynamoError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _DynamoError);
+    }
+  }
+};
+var ConditionalCheckFailedError = class extends DynamoError {
+  constructor(message, originalError, context) {
+    super(message, originalError, context);
+    this.name = "ConditionalCheckFailedError";
+  }
+};
+var ResourceNotFoundError = class extends DynamoError {
+  constructor(message, originalError, context) {
+    super(message, originalError, context);
+    this.name = "ResourceNotFoundError";
+  }
+};
+
+// src/errors/error-handler.ts
+function translateExpression(expression, attributes) {
+  if (!expression || !attributes) return expression || "";
+  let translated = expression;
+  if (attributes.names) {
+    for (const [alias, name] of Object.entries(attributes.names)) {
+      translated = translated.replace(new RegExp(alias, "g"), name);
+    }
+  }
+  if (attributes.values) {
+    for (const [alias, value] of Object.entries(attributes.values)) {
+      translated = translated.replace(
+        new RegExp(alias, "g"),
+        typeof value === "string" ? `"${value}"` : String(value)
+      );
+    }
+  }
+  return translated;
+}
+function buildErrorMessage(context, error) {
+  const parts = [`DynamoDB ${context.operation} operation failed`];
+  if (context.tableName) {
+    parts.push(`
+Table: ${context.tableName}`);
+  }
+  if (context.key) {
+    parts.push(`
+Key: ${JSON.stringify(context.key, null, 2)}`);
+  }
+  if (context.expression) {
+    const { condition, update, filter, keyCondition } = context.expression;
+    if (condition) {
+      parts.push(
+        `
+Condition: ${translateExpression(condition, context.attributes)}`
+      );
+    }
+    if (update) {
+      parts.push(
+        `
+Update: ${translateExpression(update, context.attributes)}`
+      );
+    }
+    if (filter) {
+      parts.push(
+        `
+Filter: ${translateExpression(filter, context.attributes)}`
+      );
+    }
+    if (keyCondition) {
+      parts.push(
+        `
+Key Condition: ${translateExpression(keyCondition, context.attributes)}`
+      );
+    }
+  }
+  parts.push(`
+Original Error: ${error.message}`);
+  return parts.join("");
+}
+function handleDynamoError(error, context) {
+  if (!(error instanceof Error)) {
+    throw error;
+  }
+  const errorMessage = buildErrorMessage(context, error);
+  switch (error.name) {
+    case "ConditionalCheckFailedException":
+      throw new ConditionalCheckFailedError(errorMessage, error, context);
+    case "ResourceNotFoundException":
+      throw new ResourceNotFoundError(errorMessage, error, context);
+    default:
+      throw new DynamoError(errorMessage, error, context);
+  }
+}
+
+// src/retry/retry-strategy.ts
+var RETRYABLE_ERRORS = /* @__PURE__ */ new Set([
+  "ProvisionedThroughputExceededException",
+  "ThrottlingException",
+  "RequestLimitExceeded",
+  "InternalServerError",
+  "ServiceUnavailable"
+]);
+var isRetryableError = (error) => {
+  if (!error || typeof error !== "object") return false;
+  return "name" in error && RETRYABLE_ERRORS.has(error.name);
+};
+
+// src/retry/exponential-backoff-strategy.ts
+var ExponentialBackoffStrategy = class {
+  constructor(maxAttempts = 3, baseDelay = 100, maxDelay = 5e3, jitter = true) {
+    this.maxAttempts = maxAttempts;
+    this.baseDelay = baseDelay;
+    this.maxDelay = maxDelay;
+    this.jitter = jitter;
+  }
+  shouldRetry(error, attempt) {
+    return attempt < this.maxAttempts && isRetryableError(error);
+  }
+  getDelay(attempt) {
+    const delay = Math.min(this.baseDelay * attempt ** 2, this.maxDelay);
+    if (!this.jitter) return delay;
+    return delay * (0.5 + Math.random());
+  }
+};
+
+// src/dynamo/dynamo-converter.ts
+var DynamoConverter = class {
+  constructor(tableName) {
+    this.tableName = tableName;
+  }
+  /**
+   * Converts our expression format to DynamoDB expression format
+   */
+  convertExpression(expr) {
+    if (!expr) return {};
+    return {
+      ...expr.expression && { Expression: expr.expression },
+      ...expr.names && { ExpressionAttributeNames: expr.names },
+      ...expr.values && { ExpressionAttributeValues: expr.values }
+    };
+  }
+  /**
+   * Convert our format to DynamoDB put command input
+   */
+  toPutCommand(options) {
+    return {
+      TableName: this.tableName,
+      Item: options.item,
+      ...options.condition && {
+        ConditionExpression: options.condition.expression,
+        ExpressionAttributeNames: options.condition.names,
+        ExpressionAttributeValues: options.condition.values
+      }
+    };
+  }
+  /**
+   * Convert our format to DynamoDB get command input
+   */
+  toGetCommand(options) {
+    return {
+      TableName: this.tableName,
+      Key: options.key,
+      ...options.indexName && { IndexName: options.indexName }
+    };
+  }
+  /**
+   * Convert our format to DynamoDB update command input
+   */
+  toUpdateCommand(options) {
+    return {
+      TableName: this.tableName,
+      Key: options.key,
+      UpdateExpression: options.update.expression,
+      ExpressionAttributeNames: {
+        ...options.update.names,
+        ...options.condition?.names
+      },
+      ExpressionAttributeValues: {
+        ...options.update.values,
+        ...options.condition?.values
+      },
+      ...options.condition && {
+        ConditionExpression: options.condition.expression
+      },
+      ...options.returnValues && {
+        ReturnValues: options.returnValues
+      }
+    };
+  }
+  /**
+   * Convert our format to DynamoDB delete command input
+   */
+  toDeleteCommand(options) {
+    return {
+      TableName: this.tableName,
+      Key: options.key,
+      ...options.condition && {
+        ConditionExpression: options.condition.expression,
+        ExpressionAttributeNames: options.condition.names,
+        ExpressionAttributeValues: options.condition.values
+      }
+    };
+  }
+  /**
+   * Convert our format to DynamoDB query command input
+   */
+  toQueryCommand(options) {
+    return {
+      TableName: this.tableName,
+      ...options.keyCondition && {
+        KeyConditionExpression: options.keyCondition.expression,
+        ExpressionAttributeNames: {
+          ...options.keyCondition.names,
+          ...options.filter?.names
+        },
+        ExpressionAttributeValues: {
+          ...options.keyCondition.values,
+          ...options.filter?.values
+        }
+      },
+      ...options.filter && {
+        FilterExpression: options.filter.expression
+      },
+      IndexName: options.indexName,
+      Limit: options.limit,
+      ExclusiveStartKey: options.pageKey,
+      ConsistentRead: options.consistentRead
+    };
+  }
+  /**
+   * Convert our format to DynamoDB scan command input
+   */
+  toScanCommand(options) {
+    return {
+      TableName: this.tableName,
+      ...options.filter && {
+        FilterExpression: options.filter.expression,
+        ExpressionAttributeNames: options.filter.names,
+        ExpressionAttributeValues: options.filter.values
+      },
+      IndexName: options.indexName,
+      Limit: options.limit,
+      ExclusiveStartKey: options.pageKey
+    };
+  }
+  /**
+   * Convert our format to DynamoDB batch write command input
+   */
+  toBatchWriteCommand(items) {
+    const requests = items.map((item) => {
+      if (item.put) {
+        return {
+          PutRequest: {
+            Item: item.put
+          }
+        };
+      }
+      if (item.delete) {
+        return {
+          DeleteRequest: {
+            Key: item.delete
+          }
+        };
+      }
+      throw new Error("Invalid batch write item");
+    });
+    return {
+      RequestItems: {
+        [this.tableName]: requests
+      }
+    };
+  }
+  /**
+   * Convert our format to DynamoDB transact write command input
+   */
+  toTransactWriteCommand(items) {
+    return {
+      TransactItems: items.map((item) => {
+        if (item.put) {
+          return {
+            Put: {
+              TableName: this.tableName,
+              Item: item.put.item,
+              ...item.put.condition && {
+                ConditionExpression: item.put.condition.expression,
+                ExpressionAttributeNames: item.put.condition.names,
+                ExpressionAttributeValues: item.put.condition.values
+              }
+            }
+          };
+        }
+        if (item.delete) {
+          return {
+            Delete: {
+              TableName: this.tableName,
+              Key: item.delete.key,
+              ...item.delete.condition && {
+                ConditionExpression: item.delete.condition.expression,
+                ExpressionAttributeNames: item.delete.condition.names,
+                ExpressionAttributeValues: item.delete.condition.values
+              }
+            }
+          };
+        }
+        if (item.update) {
+          return {
+            Update: {
+              TableName: this.tableName,
+              Key: item.update.key,
+              UpdateExpression: item.update.update.expression,
+              ...item.update.condition && {
+                ConditionExpression: item.update.condition.expression,
+                ExpressionAttributeNames: {
+                  ...item.update.update.names,
+                  ...item.update.condition.names
+                },
+                ExpressionAttributeValues: {
+                  ...item.update.update.values,
+                  ...item.update.condition.values
+                }
+              }
+            }
+          };
+        }
+        throw new Error("Invalid transaction item");
+      })
+    };
+  }
+  /**
+   * Convert DynamoDB batch write response to our format
+   */
+  fromBatchWriteResponse(response) {
+    return response.map((item) => {
+      if ("PutRequest" in item) {
+        return {
+          put: item.PutRequest.Item
+        };
+      }
+      if ("DeleteRequest" in item) {
+        return {
+          delete: item.DeleteRequest.Key
+        };
+      }
+      throw new Error("Invalid batch write response item");
+    });
+  }
+};
+
+// src/dynamo/dynamo-service.ts
+var BATCH_WRITE_LIMIT = 25;
+var TRANSACTION_LIMIT = 100;
+var DynamoService = class {
+  constructor(client, tableName) {
+    this.client = client;
+    this.tableName = tableName;
+    this.converter = new DynamoConverter(tableName);
+  }
+  converter;
+  async put(options) {
+    try {
+      const params = this.converter.toPutCommand(options);
+      return await this.withRetry(() => this.client.put(params));
+    } catch (error) {
+      handleDynamoError(error, {
+        operation: "PUT",
+        tableName: this.tableName,
+        key: options.item,
+        expression: {
+          condition: options.condition?.expression
+        }
+      });
+    }
+  }
+  async update(options) {
+    try {
+      const params = this.converter.toUpdateCommand(options);
+      return await this.withRetry(() => this.client.update(params));
+    } catch (error) {
+      handleDynamoError(error, {
+        operation: "UPDATE",
+        tableName: this.tableName,
+        key: options.key,
+        expression: {
+          update: options.update.expression,
+          condition: options.condition?.expression
+        }
+      });
+    }
+  }
+  async delete(options) {
+    const params = this.converter.toDeleteCommand(options);
+    try {
+      return await this.withRetry(() => this.client.delete(params));
+    } catch (error) {
+      handleDynamoError(error, {
+        operation: "DELETE",
+        tableName: this.tableName,
+        key: options.key,
+        expression: {
+          condition: params.ConditionExpression
+        }
+      });
+    }
+  }
+  async get(key, options) {
+    try {
+      const params = this.converter.toGetCommand({ key, ...options });
+      return await this.withRetry(() => this.client.get(params));
+    } catch (error) {
+      handleDynamoError(error, {
+        operation: "GET",
+        tableName: this.tableName,
+        key
+      });
+    }
+  }
+  async query(options) {
+    try {
+      if (options.autoPaginate) {
+        return await this.executeWithAutoPagination(options);
+      }
+      const params = this.converter.toQueryCommand(options);
+      return await this.withRetry(() => this.client.query(params));
+    } catch (error) {
+      handleDynamoError(error, {
+        operation: "QUERY",
+        tableName: this.tableName,
+        expression: {
+          keyCondition: options.keyCondition?.expression,
+          filter: options.filter?.expression
+        }
+      });
+    }
+  }
+  async scan(options) {
+    try {
+      const params = this.converter.toScanCommand(options);
+      return await this.withRetry(() => this.client.scan(params));
+    } catch (error) {
+      handleDynamoError(error, {
+        operation: "SCAN",
+        tableName: this.tableName,
+        expression: {
+          filter: options.filter?.expression
+        }
+      });
+    }
+  }
+  async batchWrite(items) {
+    try {
+      const chunks = this.chunkArray(items, BATCH_WRITE_LIMIT);
+      return await Promise.all(
+        chunks.map((chunk) => this.processBatchWrite(chunk))
+      );
+    } catch (error) {
+      handleDynamoError(error, {
+        operation: "BATCH_WRITE",
+        tableName: this.tableName
+      });
+    }
+  }
+  async transactWrite(items) {
+    if (items.length > TRANSACTION_LIMIT) {
+      throw new Error(
+        `Transaction limit exceeded. Maximum is ${TRANSACTION_LIMIT} items, got ${items.length}`
+      );
+    }
+    try {
+      const params = this.converter.toTransactWriteCommand(items);
+      return await this.withRetry(() => this.client.transactWrite(params));
+    } catch (error) {
+      handleDynamoError(error, {
+        operation: "TRANSACT_WRITE",
+        tableName: this.tableName
+      });
+    }
+  }
+  async executeWithAutoPagination(options) {
+    const allItems = [];
+    let lastEvaluatedKey;
+    do {
+      const result = await this.query({
+        ...options,
+        pageKey: lastEvaluatedKey,
+        autoPaginate: false
+      });
+      if (result.Items) {
+        allItems.push(...result.Items);
+      }
+      lastEvaluatedKey = result.LastEvaluatedKey;
+    } while (lastEvaluatedKey);
+    return {
+      Items: allItems,
+      Count: allItems.length,
+      ScannedCount: allItems.length,
+      LastEvaluatedKey: void 0
+    };
+  }
+  async processBatchWrite(items) {
+    const processUnprocessedItems = async (unprocessedItems2) => {
+      const params2 = this.converter.toBatchWriteCommand(unprocessedItems2);
+      const result = await this.client.batchWrite(params2);
+      if (result.UnprocessedItems?.[this.tableName]?.length) {
+        const remainingItems = this.converter.fromBatchWriteResponse(
+          result.UnprocessedItems[this.tableName]
+        );
+        throw {
+          name: "UnprocessedItemsError",
+          unprocessedItems: remainingItems
+        };
+      }
+      return result;
+    };
+    const params = this.converter.toBatchWriteCommand(items);
+    const initialResult = await this.client.batchWrite(params);
+    if (!initialResult.UnprocessedItems?.[this.tableName]?.length) {
+      return initialResult;
+    }
+    const unprocessedItems = this.converter.fromBatchWriteResponse(
+      initialResult.UnprocessedItems[this.tableName]
+    );
+    return this.withRetry(() => processUnprocessedItems(unprocessedItems));
+  }
+  async withRetry(operation, strategy = new ExponentialBackoffStrategy()) {
+    let attempt = 0;
+    while (true) {
+      try {
+        return await operation();
+      } catch (error) {
+        if (!strategy.shouldRetry(error, attempt)) {
+          throw error;
+        }
+        await new Promise(
+          (resolve) => setTimeout(resolve, strategy.getDelay(attempt))
+        );
+        attempt++;
+      }
+    }
+  }
+  chunkArray(array, size) {
+    return Array.from(
+      { length: Math.ceil(array.length / size) },
+      (_, index) => array.slice(index * size, (index + 1) * size)
+    );
+  }
+};
+
+// src/table.ts
+var Table = class {
+  dynamoService;
+  expressionBuilder;
+  indexes;
+  constructor({
+    client,
+    tableName,
+    tableIndexes,
+    expressionBuilder
+  }) {
+    this.dynamoService = new DynamoService(client, tableName);
+    this.expressionBuilder = expressionBuilder ?? new ExpressionBuilder();
+    this.indexes = tableIndexes;
+  }
+  getIndexConfig(indexName) {
+    if (!indexName) {
+      return this.indexes.primary;
+    }
+    if (this.indexes[indexName]) {
+      return this.indexes[indexName];
+    }
+    throw new Error(`Index ${indexName} does not exist`);
+  }
+  put(item) {
+    return new PutBuilder(
+      item,
+      this.expressionBuilder,
+      (operation) => this.executeOperation(operation)
+    );
+  }
+  update(key, data) {
+    const builder = new UpdateBuilder(
+      key,
+      this.expressionBuilder,
+      (operation) => this.executeOperation(operation)
+    );
+    if (data) {
+      builder.setMany(data);
+    }
+    return builder;
+  }
+  query(key) {
+    return new QueryBuilder(
+      key,
+      this.getIndexConfig(),
+      this.expressionBuilder,
+      (operation) => this.executeOperation(operation)
+    );
+  }
+  async get(key, options) {
+    const indexConfig = this.getIndexConfig(options?.indexName);
+    const keyObject = this.buildKeyFromIndex(key, indexConfig);
+    const result = await this.dynamoService.get(keyObject, options);
+    return result.Item;
+  }
+  async delete(key) {
+    const operation = {
+      type: "delete",
+      key
+    };
+    return this.executeOperation(operation);
+  }
+  async scan(filters, options) {
+    let filter = void 0;
+    if (filters?.length) {
+      const filterResult = this.expressionBuilder.createExpression(filters);
+      filter = {
+        expression: filterResult.expression,
+        names: filterResult.attributes.names,
+        values: filterResult.attributes.values
+      };
+    }
+    return this.dynamoService.scan({
+      filter,
+      limit: options?.limit,
+      pageKey: options?.pageKey,
+      indexName: options?.indexName
+    });
+  }
+  async batchWrite(operations) {
+    const batchOperation = {
+      type: "batchWrite",
+      operations: operations.map((op) => {
+        if (op.type === "put") {
+          return { put: op.item };
+        }
+        return { delete: op.key };
+      })
+    };
+    return this.executeOperation(batchOperation);
+  }
+  async transactWrite(operations) {
+    const transactOperation = {
+      type: "transactWrite",
+      operations
+    };
+    return this.executeOperation(transactOperation);
+  }
+  async executeOperation(operation) {
+    switch (operation.type) {
+      case "put":
+        return this.dynamoService.put({
+          item: operation.item,
+          condition: operation.condition
+        });
+      case "update":
+        return this.dynamoService.update({
+          key: operation.key,
+          update: operation.update,
+          condition: operation.condition,
+          returnValues: "ALL_NEW"
+        });
+      case "query":
+        return this.dynamoService.query({
+          keyCondition: operation.keyCondition,
+          filter: operation.filter,
+          limit: operation.limit,
+          indexName: operation.indexName
+        });
+      case "delete":
+        return this.dynamoService.delete({
+          key: operation.key
+        });
+      case "batchWrite":
+        return this.dynamoService.batchWrite(operation.operations);
+      case "transactWrite":
+        return this.dynamoService.transactWrite(operation.operations);
+      default:
+        throw new Error("Unknown operation type");
+    }
+  }
+  buildKeyFromIndex(key, indexConfig) {
+    this.validateKey(key, indexConfig);
+    const keyObject = {
+      [indexConfig.pkName]: key.pk
+    };
+    if (indexConfig.skName && key.sk) {
+      keyObject[indexConfig.skName] = key.sk;
+    }
+    return keyObject;
+  }
+  validateKey(key, indexConfig) {
+    if (!key.pk) {
+      throw new Error("Partition key is required");
+    }
+    if (key.sk && !indexConfig.skName) {
+      throw new Error("Sort key provided but index does not support sort keys");
+    }
+    if (!key.sk && indexConfig.skName) {
+      throw new Error("Index requires a sort key but none was provided");
+    }
+  }
+};
+
+// src/repository/base-repository.ts
+var BaseRepository = class {
+  constructor(table, schema) {
+    this.table = table;
+    this.schema = schema;
+  }
+  beforeInsert(data) {
+    return data;
+  }
+  beforeUpdate(data) {
+    return data;
+  }
+  async create(data) {
+    const parsed = this.schema.parse(data);
+    const key = this.createPrimaryKey(parsed);
+    const item = {
+      ...parsed,
+      ...key
+    };
+    const indexConfig = this.table.getIndexConfig();
+    await this.table.put(item).whereNotExists(indexConfig.pkName).execute();
+    return parsed;
+  }
+  async update(key, updates) {
+    const parsed = this.schema.parse(updates);
+    const result = await this.table.update(key).setMany(parsed).execute();
+    return result.Attributes ? this.schema.parse(result.Attributes) : null;
+  }
+  async delete(key) {
+    await this.table.delete(key);
+  }
+  async findOne(key) {
+    const item = await this.table.query(key).where(this.getTypeAttributeName(), "=", this.getType()).execute();
+    if (!item) {
+      return null;
+    }
+    return this.schema.parse(item);
+  }
+  async findOrFail(key) {
+    const result = await this.findOne(key);
+    if (!result) {
+      throw new Error("Item not found");
+    }
+    return this.schema.parse(result);
+  }
+  query(key) {
+    return this.table.query(key).where(this.getTypeAttributeName(), "=", this.getType());
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseRepository,
+  ConditionalCheckFailedError,
+  DynamoError,
+  ExponentialBackoffStrategy,
+  ResourceNotFoundError,
+  Table
+});