dyno-table 0.1.3 → 0.1.5

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 };