dyno-table 2.5.1 → 2.6.0

package/dist/conditions.d.cts

@@ -1,3 +0,0 @@
-export { C as ComparisonOperator, b as Condition, c as ConditionOperator, E as ExpressionParams, K as KeyConditionOperator, L as LogicalOperator, a as PrimaryKey, P as PrimaryKeyWithoutExpression, d as and, e as attributeExists, f as attributeNotExists, g as beginsWith, h as between, i as contains, u as createComparisonCondition, j as eq, k as gt, l as gte, m as inArray, n as lt, o as lte, p as ne, q as not, r as or } from './conditions-C8bM__Pn.cjs';
-import './types.cjs';
-import '@aws-sdk/lib-dynamodb';

package/dist/entity.d.cts

@@ -1,261 +0,0 @@
-import { s as Path, t as PathType, b as Condition, c as ConditionOperator, P as PrimaryKeyWithoutExpression, a as PrimaryKey } from './conditions-C8bM__Pn.cjs';
-import { P as PutBuilder, G as GetBuilder, U as UpdateBuilder, p as UpdateCommandParams, T as TransactionBuilder, D as DeleteBuilder, S as ScanBuilder, Q as QueryBuilder } from './index-CPCmWsEv.cjs';
-import { StandardSchemaV1 } from './standard-schema.cjs';
-import { Table } from './table.cjs';
-import { DynamoItem, Index, TableConfig } from './types.cjs';
-import '@aws-sdk/lib-dynamodb';
-
-type SetElementType<T> = T extends Set<infer U> ? U : T extends Array<infer U> ? U : never;
-type PathSetElementType<T, K extends Path<T>> = SetElementType<PathType<T, K>>;
-/**
- * Entity-aware wrapper for PutBuilder that automatically provides entity name to batch operations
- */
-type EntityAwarePutBuilder<T extends DynamoItem> = PutBuilder<T> & {
-    readonly entityName: string;
-};
-/**
- * Entity-aware wrapper for GetBuilder that automatically provides entity name to batch operations
- */
-type EntityAwareGetBuilder<T extends DynamoItem> = GetBuilder<T> & {
-    readonly entityName: string;
-};
-/**
- * Entity-aware wrapper for DeleteBuilder that automatically provides entity name to batch operations
- */
-type EntityAwareDeleteBuilder = DeleteBuilder & {
-    readonly entityName: string;
-};
-/**
- * Entity-aware wrapper for UpdateBuilder that adds forceIndexRebuild functionality
- * and automatically provides entity name to batch operations
- */
-declare class EntityAwareUpdateBuilder<T extends DynamoItem> {
-    private forceRebuildIndexes;
-    readonly entityName: string;
-    private builder;
-    private entityConfig?;
-    private updateDataApplied;
-    constructor(builder: UpdateBuilder<T>, entityName: string);
-    /**
-     * Configure entity-specific logic for automatic timestamp generation and index updates
-     */
-    configureEntityLogic(config: {
-        data: Partial<T>;
-        key: T;
-        table: Table;
-        indexes: Record<string, IndexDefinition<T>> | undefined;
-        generateTimestamps: () => Record<string, string | number>;
-        buildIndexUpdates: (currentData: T, updates: Partial<T>, table: Table, indexes: Record<string, IndexDefinition<T>> | undefined, forceRebuildIndexes?: string[]) => Record<string, string>;
-    }): void;
-    /**
-     * 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: string | string[]): 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(): string[];
-    /**
-     * Apply entity-specific update data (timestamps and index updates)
-     * This is called automatically when needed
-     */
-    private applyEntityUpdates;
-    set(values: Partial<T>): this;
-    set<K extends Path<T>>(path: K, value: PathType<T, K>): this;
-    remove<K extends Path<T>>(path: K): this;
-    add<K extends Path<T>>(path: K, value: PathType<T, K>): this;
-    deleteElementsFromSet<K extends Path<T>>(path: K, value: PathSetElementType<T, K>[] | Set<PathSetElementType<T, K>>): this;
-    condition(condition: Condition | ((op: ConditionOperator<T>) => Condition)): this;
-    returnValues(returnValues: "ALL_NEW" | "UPDATED_NEW" | "ALL_OLD" | "UPDATED_OLD" | "NONE"): this;
-    toDynamoCommand(): UpdateCommandParams;
-    withTransaction(transaction: TransactionBuilder): void;
-    debug(): ReturnType<UpdateBuilder<T>["debug"]>;
-    execute(): Promise<{
-        item?: T;
-    }>;
-}
-
-type QueryFunction<_T extends DynamoItem, I, R> = (input: I) => R;
-type QueryFunctionWithSchema<T extends DynamoItem, I, R> = QueryFunction<T, I, R> & {
-    schema?: StandardSchemaV1<I>;
-};
-type QueryRecord<T extends DynamoItem> = {
-    [K: string]: QueryFunctionWithSchema<T, any, any>;
-};
-type MappedQueries<T extends DynamoItem, Q extends QueryRecord<T>> = {
-    [K in keyof Q]: Q[K] extends QueryFunctionWithSchema<T, infer I, infer R> ? (input: I) => R : never;
-};
-type QueryEntity<T extends DynamoItem> = {
-    scan: () => ScanBuilder<T>;
-    get: (key: PrimaryKeyWithoutExpression) => EntityAwareGetBuilder<T>;
-    query: (keyCondition: PrimaryKey) => QueryBuilder<T, TableConfig>;
-};
-interface Settings {
-    /**
-     * Defaults to "entityType"
-     */
-    entityTypeAttributeName?: string;
-    timestamps?: {
-        createdAt?: {
-            /**
-             * ISO vs Unix trade-offs
-             *
-             * Both options support between, greater than and less than comparisons.
-             *
-             * ISO:
-             * - Human readable, but requires more storage space
-             * - Does not work with DynamoDBs TTL feature.
-             *
-             * UNIX:
-             * - Less readable, but requires less storage space.
-             * - Works with DynamoDBs TTL feature.
-             */
-            format: "ISO" | "UNIX";
-            /**
-             * Defaults to "createdAt"
-             */
-            attributeName?: string;
-        };
-        updatedAt?: {
-            /**
-             * ISO vs Unix trade-offs
-             *
-             * Both options support between, greater than and less than comparisons.
-             *
-             * ISO:
-             * - Human readable, but requires more storage space
-             * - Does not work with DynamoDBs TTL feature.
-             *
-             * UNIX:
-             * - Less readable, but requires less storage space.
-             * - Works with DynamoDBs TTL feature.
-             */
-            format: "ISO" | "UNIX";
-            /**
-             * Defaults to "updatedAt"
-             */
-            attributeName?: string;
-        };
-    };
-}
-interface EntityConfig<T extends DynamoItem, TInput extends DynamoItem = T, I extends DynamoItem = T, Q extends QueryRecord<T> = QueryRecord<T>> {
-    name: string;
-    schema: StandardSchemaV1<TInput, T>;
-    primaryKey: IndexDefinition<I>;
-    indexes?: Record<string, IndexDefinition<T>>;
-    queries: Q;
-    settings?: Settings;
-}
-interface EntityRepository<
-/**
- * The Entity Type (output type)
- */
-T extends DynamoItem, 
-/**
- * The Input Type (for create operations)
- */
-TInput extends DynamoItem = T, 
-/**
- * The Primary Index (Partition index) Type
- */
-I extends DynamoItem = T, 
-/**
- * The Queries object
- */
-Q extends QueryRecord<T> = QueryRecord<T>> {
-    create: (data: TInput) => EntityAwarePutBuilder<T>;
-    upsert: (data: TInput & I) => EntityAwarePutBuilder<T>;
-    get: (key: I) => EntityAwareGetBuilder<T>;
-    update: (key: I, data: Partial<T>) => EntityAwareUpdateBuilder<T>;
-    delete: (key: I) => EntityAwareDeleteBuilder;
-    query: MappedQueries<T, Q>;
-    scan: () => ScanBuilder<T>;
-}
-/**
- * Creates an entity definition with type-safe operations
- *
- * @example
- * ```typescript
- * interface User {
- *   id: string;
- *   name: string;
- * }
- *
- * const UserEntity = defineEntity<User>({
- *   name: "User",
- *   schema: userSchema,
- *   primaryKey: primaryKey,
- * });
- * ```
- */
-declare function defineEntity<T extends DynamoItem, TInput extends DynamoItem = T, I extends DynamoItem = T, Q extends QueryRecord<T> = QueryRecord<T>>(config: EntityConfig<T, TInput, I, Q>): {
-    name: string;
-    createRepository: (table: Table) => EntityRepository<T, TInput, I, Q>;
-};
-declare function createQueries<T extends DynamoItem>(): {
-    input: <I>(schema: StandardSchemaV1<I>) => {
-        query: <R extends ScanBuilder<T> | QueryBuilder<T, TableConfig> | GetBuilder<T>>(handler: (params: {
-            input: I;
-            entity: QueryEntity<T>;
-        }) => R) => QueryFunctionWithSchema<T, I, R>;
-    };
-};
-/**
- * Defines a DynamoDB index configuration
- */
-interface IndexDefinition<T extends DynamoItem> extends Index<T> {
-    /** The name of the index */
-    name: string;
-    /** Whether the index is read-only */
-    isReadOnly: boolean;
-    /** Function to generate the index key from an item */
-    generateKey: (item: T) => {
-        pk: string;
-        sk?: string;
-    };
-}
-declare function createIndex(): {
-    input: <T extends DynamoItem>(schema: StandardSchemaV1<T>) => {
-        partitionKey: <P extends (item: T) => string>(pkFn: P) => {
-            sortKey: <S extends (item: T) => string>(skFn: S) => IndexDefinition<T> & {
-                readOnly: (value?: boolean) => IndexDefinition<T>;
-            };
-            withoutSortKey: () => IndexDefinition<T> & {
-                readOnly: (value?: boolean) => IndexDefinition<T>;
-            };
-        };
-        readOnly: (value?: boolean) => /*elided*/ any;
-    };
-};
-
-export { type EntityConfig, type EntityRepository, type IndexDefinition, type MappedQueries, type QueryEntity, type QueryFunction, type QueryFunctionWithSchema, type QueryRecord, createIndex, createQueries, defineEntity };