dyno-table 0.1.4 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dyno-table",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "A TypeScript library to simplify working with DynamoDB",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/index.d.mts

@@ -1,323 +0,0 @@
-import * as _aws_sdk_lib_dynamodb from '@aws-sdk/lib-dynamodb';
-import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
-import { z } from 'zod';
-
-interface ExpressionAttributes {
-    names?: Record<string, string>;
-    values?: Record<string, unknown>;
-}
-interface ExpressionResult {
-    expression?: string;
-    attributes: ExpressionAttributes;
-}
-type FunctionOperator = "attribute_exists" | "attribute_not_exists" | "begins_with" | "contains" | "not_contains" | "attribute_type";
-type ComparisonOperator = "=" | "<" | "<=" | ">" | ">=" | "<>";
-type SpecialOperator = "BETWEEN" | "IN" | "size";
-type ConditionOperator = FunctionOperator | ComparisonOperator | SpecialOperator;
-type FilterOperator = "=" | "<" | "<=" | ">" | ">=" | "<>" | "BETWEEN" | "IN" | "contains" | "begins_with";
-interface FilterCondition {
-    field: string;
-    operator: FilterOperator;
-    value: unknown;
-}
-interface Condition {
-    field: string;
-    operator: ConditionOperator;
-    value?: unknown;
-}
-type SKCondition = {
-    operator: FilterOperator;
-    value: string;
-};
-type PrimaryKey = {
-    pk: string;
-    sk?: SKCondition | string;
-};
-interface TableIndexConfig {
-    pkName: string;
-    skName?: string;
-}
-
-interface IExpressionBuilder {
-    buildKeyCondition(key: PrimaryKey, indexConfig: TableIndexConfig): ExpressionResult;
-    createExpression(filters: Condition[]): ExpressionResult;
-    buildUpdateExpression(updates: Record<string, unknown>): ExpressionResult;
-}
-declare class ExpressionBuilder implements IExpressionBuilder {
-    private nameCount;
-    private valueCount;
-    private generateAlias;
-    private reset;
-    private createAttributePath;
-    private addValue;
-    private buildComparison;
-    createExpression(conditions: Array<{
-        field: string;
-        operator: ConditionOperator;
-        value?: unknown;
-    }>): ExpressionResult;
-    private formatAttributes;
-    buildKeyCondition(key: PrimaryKey, indexConfig: TableIndexConfig): ExpressionResult;
-    buildUpdateExpression(updates: Record<string, unknown>): ExpressionResult;
-}
-
-type DynamoKey = Record<string, unknown>;
-interface DynamoExpression {
-    expression?: string;
-    names?: Record<string, string>;
-    values?: Record<string, unknown>;
-}
-interface DynamoBatchWriteItem {
-    put?: Record<string, unknown>;
-    delete?: DynamoKey;
-}
-interface DynamoPutOperation {
-    type: "put";
-    item: Record<string, unknown>;
-    condition?: DynamoExpression;
-}
-interface DynamoUpdateOperation {
-    type: "update";
-    key: PrimaryKeyWithoutExpression;
-    update: DynamoExpression;
-    condition?: DynamoExpression;
-}
-interface DynamoQueryOperation {
-    type: "query";
-    keyCondition?: DynamoExpression;
-    filter?: DynamoExpression;
-    limit?: number;
-    indexName?: string;
-}
-interface DynamoDeleteOperation {
-    type: "delete";
-    key: PrimaryKeyWithoutExpression;
-    condition?: DynamoExpression;
-}
-interface DynamoBatchWriteOperation {
-    type: "batchWrite";
-    operations: DynamoBatchWriteItem[];
-}
-interface DynamoTransactOperation {
-    type: "transactWrite";
-    operations: Array<{
-        put?: {
-            item: Record<string, unknown>;
-            condition?: DynamoExpression;
-        };
-        delete?: {
-            key: PrimaryKeyWithoutExpression;
-            condition?: DynamoExpression;
-        };
-        update?: {
-            key: PrimaryKeyWithoutExpression;
-            update: DynamoExpression;
-            condition?: DynamoExpression;
-        };
-    }>;
-}
-type DynamoOperation = DynamoPutOperation | DynamoUpdateOperation | DynamoQueryOperation | DynamoDeleteOperation | DynamoBatchWriteOperation | DynamoTransactOperation;
-type PrimaryKeyWithoutExpression = {
-    pk: string;
-    sk?: string;
-};
-type BatchWriteOperation = {
-    type: "put";
-    item: Record<string, unknown>;
-} | {
-    type: "delete";
-    key: PrimaryKeyWithoutExpression;
-};
-
-declare abstract class OperationBuilder<T extends DynamoOperation> {
-    protected expressionBuilder: IExpressionBuilder;
-    protected conditions: Array<{
-        field: string;
-        operator: ConditionOperator;
-        value?: unknown;
-    }>;
-    constructor(expressionBuilder: IExpressionBuilder);
-    where(field: string, operator: FilterOperator, value: unknown): this;
-    whereExists(field: string): this;
-    whereNotExists(field: string): this;
-    whereEquals(field: string, value: unknown): this;
-    whereBetween(field: string, start: unknown, end: unknown): this;
-    whereIn(field: string, values: unknown[]): this;
-    protected buildConditionExpression(): ExpressionResult;
-    abstract build(): T;
-}
-
-declare class PutBuilder extends OperationBuilder<DynamoPutOperation> {
-    private readonly item;
-    private readonly onBuild;
-    constructor(item: Record<string, unknown>, expressionBuilder: IExpressionBuilder, onBuild: (operation: DynamoPutOperation) => Promise<void>);
-    build(): DynamoPutOperation;
-    execute(): Promise<void>;
-}
-
-declare class QueryBuilder extends OperationBuilder<DynamoQueryOperation> {
-    private readonly key;
-    private readonly indexConfig;
-    private readonly onBuild;
-    private limitValue?;
-    private indexNameValue?;
-    constructor(key: PrimaryKey, indexConfig: TableIndexConfig, expressionBuilder: IExpressionBuilder, onBuild: (operation: DynamoQueryOperation) => Promise<{
-        Items?: Record<string, unknown>[];
-        Count?: number;
-        ScannedCount?: number;
-        LastEvaluatedKey?: Record<string, unknown>;
-    }>);
-    limit(value: number): this;
-    useIndex(indexName: string): this;
-    build(): DynamoQueryOperation;
-    execute(): Promise<{
-        Items?: Record<string, unknown>[];
-        Count?: number;
-        ScannedCount?: number;
-        LastEvaluatedKey?: Record<string, unknown>;
-    }>;
-}
-
-declare class UpdateBuilder extends OperationBuilder<DynamoUpdateOperation> {
-    private readonly key;
-    private readonly onBuild;
-    private updates;
-    constructor(key: PrimaryKeyWithoutExpression, expressionBuilder: IExpressionBuilder, onBuild: (operation: DynamoUpdateOperation) => Promise<{
-        Attributes?: Record<string, unknown>;
-    }>);
-    set(field: string, value: unknown): this;
-    setMany(attribtues: Record<string, unknown>): this;
-    remove(...fields: string[]): this;
-    increment(field: string, by?: number): this;
-    build(): DynamoUpdateOperation;
-    execute(): Promise<{
-        Attributes?: Record<string, unknown>;
-    }>;
-}
-
-declare class Table {
-    private readonly dynamoService;
-    private readonly expressionBuilder;
-    private readonly indexes;
-    constructor({ client, tableName, tableIndexes, expressionBuilder, }: {
-        client: DynamoDBDocument;
-        tableName: string;
-        tableIndexes: Record<string, TableIndexConfig>;
-        expressionBuilder?: ExpressionBuilder;
-    });
-    getIndexConfig(indexName?: string): TableIndexConfig;
-    put(item: Record<string, unknown>): PutBuilder;
-    update(key: PrimaryKeyWithoutExpression, data?: Record<string, unknown>): UpdateBuilder;
-    query(key: PrimaryKey): QueryBuilder;
-    get(key: PrimaryKeyWithoutExpression, options?: {
-        indexName?: string;
-    }): Promise<Record<string, any> | undefined>;
-    delete(key: PrimaryKeyWithoutExpression): Promise<unknown>;
-    scan(filters?: FilterCondition[], options?: {
-        limit?: number;
-        pageKey?: Record<string, unknown>;
-        indexName?: string;
-    }): Promise<_aws_sdk_lib_dynamodb.ScanCommandOutput>;
-    batchWrite(operations: BatchWriteOperation[]): Promise<unknown>;
-    transactWrite(operations: Array<{
-        put?: {
-            item: Record<string, unknown>;
-            condition?: {
-                expression: string;
-                names?: Record<string, string>;
-                values?: Record<string, unknown>;
-            };
-        };
-        delete?: {
-            key: PrimaryKeyWithoutExpression;
-            condition?: {
-                expression: string;
-                names?: Record<string, string>;
-                values?: Record<string, unknown>;
-            };
-        };
-        update?: {
-            key: PrimaryKeyWithoutExpression;
-            update: {
-                expression: string;
-                names?: Record<string, string>;
-                values?: Record<string, unknown>;
-            };
-            condition?: {
-                expression: string;
-                names?: Record<string, string>;
-                values?: Record<string, unknown>;
-            };
-        };
-    }>): Promise<unknown>;
-    private executeOperation;
-    private buildKeyFromIndex;
-    private validateKey;
-}
-
-type InferZodSchema<T extends z.ZodType> = z.infer<T>;
-declare abstract class BaseRepository<TSchema extends z.ZodType> {
-    protected readonly table: Table;
-    protected readonly schema: TSchema;
-    constructor(table: Table, schema: TSchema);
-    protected abstract createPrimaryKey(data: InferZodSchema<TSchema>): PrimaryKeyWithoutExpression;
-    protected abstract getIndexKeys(): {
-        pk: string;
-        sk?: string;
-    };
-    /**
-     * Default attribute applied to ALL records that get stored in DDB
-     */
-    protected abstract getType(): string;
-    protected abstract getTypeAttributeName(): string;
-    protected beforeInsert(data: InferZodSchema<TSchema>): InferZodSchema<TSchema>;
-    protected beforeUpdate(data: InferZodSchema<TSchema>): InferZodSchema<TSchema>;
-    create(data: InferZodSchema<TSchema>): Promise<InferZodSchema<TSchema>>;
-    update(key: PrimaryKeyWithoutExpression, updates: Partial<InferZodSchema<TSchema>>): Promise<InferZodSchema<TSchema>>;
-    delete(key: PrimaryKeyWithoutExpression): Promise<void>;
-    findOne(key: PrimaryKeyWithoutExpression): Promise<InferZodSchema<TSchema> | null>;
-    findOrFail(key: PrimaryKeyWithoutExpression): Promise<InferZodSchema<TSchema>>;
-    protected query(key: PrimaryKeyWithoutExpression): QueryBuilder;
-}
-
-interface RetryStrategy {
-    maxAttempts: number;
-    baseDelay: number;
-    /**
-     * Check if the error should be retried
-     * @param error The error that was thrown
-     * @param attempt The amount of attempts this action has made to run the action
-     * @returns Whether the action should be retried
-     */
-    shouldRetry: (error: unknown, attempt: number) => boolean;
-    /**
-     * Get the delay in milliseconds for the next retry attempt
-     * @param attempt The amount of attempts this action has made to run the action
-     * @returns The delay in milliseconds
-     */
-    getDelay: (attempt: number) => number;
-}
-
-declare class ExponentialBackoffStrategy implements RetryStrategy {
-    maxAttempts: number;
-    baseDelay: number;
-    private maxDelay;
-    private jitter;
-    constructor(maxAttempts?: number, baseDelay?: number, maxDelay?: number, jitter?: boolean);
-    shouldRetry(error: unknown, attempt: number): boolean;
-    getDelay(attempt: number): number;
-}
-
-declare class DynamoError extends Error {
-    readonly originalError: Error;
-    readonly context?: Record<string, unknown> | undefined;
-    constructor(message: string, originalError: Error, context?: Record<string, unknown> | undefined);
-}
-declare class ConditionalCheckFailedError extends DynamoError {
-    constructor(message: string, originalError: Error, context?: Record<string, unknown>);
-}
-declare class ResourceNotFoundError extends DynamoError {
-    constructor(message: string, originalError: Error, context?: Record<string, unknown>);
-}
-
-export { BaseRepository, ConditionalCheckFailedError, DynamoError, ExponentialBackoffStrategy, type FilterCondition, type FilterOperator, type PrimaryKey, ResourceNotFoundError, type RetryStrategy, Table, type TableIndexConfig };

package/dist/index.mjs

@@ -1,1051 +0,0 @@
-// 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());
-  }
-};
-export {
-  BaseRepository,
-  ConditionalCheckFailedError,
-  DynamoError,
-  ExponentialBackoffStrategy,
-  ResourceNotFoundError,
-  Table
-};