dyno-table 2.5.2 → 2.6.1

package/dist/conditions.js

@@ -1 +1,46 @@
-export { and, attributeExists, attributeNotExists, beginsWith, between, contains, createComparisonCondition, eq, gt, gte, inArray, lt, lte, ne, not, or } from './chunk-2WIBY7PZ.js';
+// src/conditions.ts
+var createComparisonCondition = (type) => (attr, value) => ({
+  type,
+  attr,
+  value
+});
+var eq = createComparisonCondition("eq");
+var ne = createComparisonCondition("ne");
+var lt = createComparisonCondition("lt");
+var lte = createComparisonCondition("lte");
+var gt = createComparisonCondition("gt");
+var gte = createComparisonCondition("gte");
+var between = (attr, lower, upper) => ({
+  type: "between",
+  attr,
+  value: [lower, upper]
+});
+var inArray = (attr, values) => ({
+  type: "in",
+  attr,
+  value: values
+});
+var beginsWith = createComparisonCondition("beginsWith");
+var contains = createComparisonCondition("contains");
+var attributeExists = (attr) => ({
+  type: "attributeExists",
+  attr
+});
+var attributeNotExists = (attr) => ({
+  type: "attributeNotExists",
+  attr
+});
+var and = (...conditions) => ({
+  type: "and",
+  conditions
+});
+var or = (...conditions) => ({
+  type: "or",
+  conditions
+});
+var not = (condition) => ({
+  type: "not",
+  condition
+});
+
+export { and, attributeExists, attributeNotExists, beginsWith, between, contains, createComparisonCondition, eq, gt, gte, inArray, lt, lte, ne, not, or };

package/dist/entity/ddb-indexing.d.ts

@@ -0,0 +1,45 @@
+import type { Table } from "../table";
+import type { DynamoItem } from "../types";
+import type { IndexDefinition } from "./entity";
+/**
+ * Helper class for building indexes for DynamoDB operations
+ */
+export declare class IndexBuilder<T extends DynamoItem> {
+    private readonly table;
+    private readonly indexes;
+    /**
+     * Creates a new IndexBuilder instance
+     *
+     * @param table - The DynamoDB table instance
+     * @param indexes - The index definitions
+     */
+    constructor(table: Table, indexes?: Record<string, IndexDefinition<T>>);
+    /**
+     * Build index attributes for item creation
+     *
+     * @param item - The item to generate indexes for
+     * @param options - Options for building indexes
+     * @returns Record of GSI attribute names to their values
+     */
+    buildForCreate(item: T, options?: {
+        excludeReadOnly?: boolean;
+    }): Record<string, string>;
+    /**
+     * Build index attributes for item updates
+     *
+     * @param currentData - The current data before update
+     * @param updates - The update data
+     * @param options - Options for building indexes
+     * @returns Record of GSI attribute names to their updated values
+     */
+    buildForUpdate(currentData: T, updates: Partial<T>, options?: {
+        forceRebuildIndexes?: string[];
+    }): Record<string, string>;
+    /**
+     * Check if a key has undefined values
+     *
+     * @param key - The index key to check
+     * @returns True if the key contains undefined values, false otherwise
+     */
+    private hasUndefinedValues;
+}

package/dist/entity/entity.d.ts

@@ -0,0 +1,188 @@
+import type { DeleteBuilder, GetBuilder, Path, PathType, PutBuilder, QueryBuilder, ScanBuilder, TransactionBuilder, UpdateBuilder, UpdateCommandParams } from "../builders";
+import { type Condition, type ConditionOperator, type PrimaryKey, type PrimaryKeyWithoutExpression } from "../conditions";
+import type { StandardSchemaV1 } from "../standard-schema";
+import type { Table } from "../table";
+import type { DynamoItem, Index, TableConfig } from "../types";
+export type QueryFunction<_T extends DynamoItem, I, R> = (input: I) => R;
+export type QueryFunctionWithSchema<T extends DynamoItem, I, R> = QueryFunction<T, I, R> & {
+    schema?: StandardSchemaV1<I>;
+};
+export type QueryRecord<T extends DynamoItem> = {
+    [K: string]: QueryFunctionWithSchema<T, any, any>;
+};
+export 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;
+};
+export type QueryEntity<T extends DynamoItem> = {
+    scan: () => ScanBuilder<T>;
+    get: (key: PrimaryKeyWithoutExpression) => EntityGetBuilder<T>;
+    query: (keyCondition: PrimaryKey) => QueryBuilder<T, TableConfig>;
+};
+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>>;
+export type EntityPutBuilder<T extends DynamoItem> = PutBuilder<T> & {
+    readonly entityName: string;
+};
+export type EntityGetBuilder<T extends DynamoItem> = GetBuilder<T> & {
+    readonly entityName: string;
+};
+export type EntityDeleteBuilder = DeleteBuilder & {
+    readonly entityName: string;
+};
+export type EntityUpdateBuilder<T extends DynamoItem> = {
+    readonly entityName: string;
+    set(values: Partial<T>): EntityUpdateBuilder<T>;
+    set<K extends Path<T>>(path: K, value: PathType<T, K>): EntityUpdateBuilder<T>;
+    remove<K extends Path<T>>(path: K): EntityUpdateBuilder<T>;
+    add<K extends Path<T>>(path: K, value: PathType<T, K>): EntityUpdateBuilder<T>;
+    deleteElementsFromSet<K extends Path<T>>(path: K, value: PathSetElementType<T, K>[] | Set<PathSetElementType<T, K>>): EntityUpdateBuilder<T>;
+    condition(condition: Condition | ((op: ConditionOperator<T>) => Condition)): EntityUpdateBuilder<T>;
+    returnValues(returnValues: "ALL_NEW" | "UPDATED_NEW" | "ALL_OLD" | "UPDATED_OLD" | "NONE"): EntityUpdateBuilder<T>;
+    toDynamoCommand(): UpdateCommandParams;
+    withTransaction(transaction: TransactionBuilder): void;
+    debug(): ReturnType<UpdateBuilder<T>["debug"]>;
+    execute(): Promise<{
+        item?: T;
+    }>;
+    forceIndexRebuild(indexes: string | string[]): EntityUpdateBuilder<T>;
+    getForceRebuildIndexes(): string[];
+};
+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;
+        };
+    };
+}
+export 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;
+}
+export 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) => EntityPutBuilder<T>;
+    upsert: (data: TInput & I) => EntityPutBuilder<T>;
+    get: (key: I) => EntityGetBuilder<T>;
+    update: (key: I, data: Partial<T>) => EntityUpdateBuilder<T>;
+    delete: (key: I) => EntityDeleteBuilder;
+    query: MappedQueries<T, Q>;
+    scan: () => ScanBuilder<T>;
+}
+export interface EntityDefinition<T extends DynamoItem, TInput extends DynamoItem = T, I extends DynamoItem = T, Q extends QueryRecord<T> = QueryRecord<T>> {
+    name: string;
+    createRepository: (table: Table) => EntityRepository<T, TInput, I, Q>;
+}
+/**
+ * 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,
+ * });
+ * ```
+ */
+export 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>): EntityDefinition<T, TInput, I, Q>;
+export 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
+ */
+export 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;
+    };
+}
+export 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 {};

package/dist/entity/index-utils.d.ts

@@ -0,0 +1,24 @@
+import type { Table } from "../table";
+import type { DynamoItem } from "../types";
+import type { IndexDefinition } from "./entity";
+/**
+ * Builds secondary indexes for an item based on the configured indexes
+ *
+ * @param dataForKeyGeneration - The validated data to generate keys from
+ * @param table - The DynamoDB table instance containing GSI configurations
+ * @param indexes - The index definitions
+ * @param excludeReadOnly - Whether to exclude read-only indexes
+ * @returns Record of GSI attribute names to their values
+ */
+export declare function buildIndexes<T extends DynamoItem>(dataForKeyGeneration: T, table: Table, indexes: Record<string, IndexDefinition<T>> | undefined, excludeReadOnly?: boolean): Record<string, string>;
+/**
+ * Builds index updates for an item based on the configured indexes
+ *
+ * @param currentData - The current data before update
+ * @param updates - The update data
+ * @param table - The DynamoDB table instance containing GSI configurations
+ * @param indexes - The index definitions
+ * @param forceRebuildIndexes - Array of index names to force rebuild even if readonly
+ * @returns Record of GSI attribute names to their updated values
+ */
+export declare function buildIndexUpdates<T extends DynamoItem>(currentData: T, updates: Partial<T>, table: Table, indexes: Record<string, IndexDefinition<T>> | undefined, forceRebuildIndexes?: string[]): Record<string, string>;