dyno-table 2.5.1 → 2.6.0

package/dist/operation-types.d.ts

@@ -0,0 +1,8 @@
+import type { PrimaryKeyWithoutExpression } from "./conditions";
+export type BatchWriteOperation<T extends Record<string, unknown>> = {
+    type: "put";
+    item: T;
+} | {
+    type: "delete";
+    key: PrimaryKeyWithoutExpression;
+};

package/dist/standard-schema.d.ts

@@ -1,9 +1,9 @@
 /** The Standard Schema interface. */
-interface StandardSchemaV1<Input = unknown, Output = Input> {
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
     /** The Standard Schema properties. */
     readonly "~standard": StandardSchemaV1.Props<Input, Output>;
 }
-declare namespace StandardSchemaV1 {
+export declare namespace StandardSchemaV1 {
     /** The Standard Schema properties interface. */
     interface Props<Input = unknown, Output = Input> {
         /** The version number of the standard. */
@@ -53,5 +53,3 @@ declare namespace StandardSchemaV1 {
     /** Infers the output type of a Standard Schema. */
     type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
 }
-
-export { StandardSchemaV1 };

package/dist/table.d.ts

@@ -1,9 +1,16 @@
-import { P as PutBuilder, G as GetBuilder, Q as QueryBuilder, S as ScanBuilder, D as DeleteBuilder, U as UpdateBuilder, T as TransactionBuilder, B as BatchBuilder, a as TransactionOptions, C as ConditionCheckBuilder, b as BatchWriteOperation } from './index-Bc-ra0im.js';
-import { P as PrimaryKeyWithoutExpression, a as PrimaryKey } from './conditions-BSAcZswY.js';
-import { TableConfig, Index, DynamoItem } from './types.js';
-import '@aws-sdk/lib-dynamodb';
-
-declare class Table<TConfig extends TableConfig = TableConfig> {
+import { BatchBuilder } from "./builders/batch-builder";
+import { ConditionCheckBuilder } from "./builders/condition-check-builder";
+import { DeleteBuilder } from "./builders/delete-builder";
+import { GetBuilder } from "./builders/get-builder";
+import { PutBuilder } from "./builders/put-builder";
+import { QueryBuilder } from "./builders/query-builder";
+import { ScanBuilder } from "./builders/scan-builder";
+import { TransactionBuilder, type TransactionOptions } from "./builders/transaction-builder";
+import { UpdateBuilder } from "./builders/update-builder";
+import { type PrimaryKey, type PrimaryKeyWithoutExpression } from "./conditions";
+import type { BatchWriteOperation } from "./operation-types";
+import type { DynamoItem, Index, TableConfig } from "./types";
+export declare class Table<TConfig extends TableConfig = TableConfig> {
     private readonly dynamoClient;
     readonly tableName: string;
     /**
@@ -161,5 +168,3 @@ declare class Table<TConfig extends TableConfig = TableConfig> {
         unprocessedItems: Array<BatchWriteOperation<T>>;
     }>;
 }
-
-export { Table };

package/dist/types.d.ts

@@ -1,9 +1,8 @@
-import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
-
-type DynamoItem = {
+import type { DynamoDBDocument } from "@aws-sdk/lib-dynamodb";
+export type DynamoItem = {
     [key: string]: unknown;
 };
-interface Index<T extends DynamoItem = DynamoItem> {
+export interface Index<T extends DynamoItem = DynamoItem> {
     partitionKey: string;
     sortKey?: string;
     /** Function to generate the index key from an item */
@@ -14,16 +13,14 @@ interface Index<T extends DynamoItem = DynamoItem> {
     /** Whether the index is read-only */
     isReadOnly?: boolean;
 }
-interface IndexConfig {
+export interface IndexConfig {
     partitionKey: string;
     sortKey?: string;
     gsis?: Record<string, Index>;
 }
-interface TableConfig {
+export interface TableConfig {
     client: DynamoDBDocument;
     tableName: string;
     indexes: IndexConfig;
 }
-type GSINames<T extends TableConfig> = keyof NonNullable<T["indexes"]["gsis"]>;
-
-export type { DynamoItem, GSINames, Index, IndexConfig, TableConfig };
+export type GSINames<T extends TableConfig> = keyof NonNullable<T["indexes"]["gsis"]>;

package/dist/utils/chunk-array.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Generator function to create chunks of an array on-demand
+ * This is more memory-efficient than creating all chunks at once
+ *
+ * @param array The array to chunk
+ * @param size The size of each chunk
+ * @returns A generator that yields chunks of the array
+ */
+export declare function chunkArray<T>(array: T[], size: number): Generator<T[], void, unknown>;

package/dist/utils/debug-expression.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Interface for DynamoDB command objects that can contain expressions
+ */
+export interface DynamoCommandWithExpressions {
+    conditionExpression?: string;
+    updateExpression?: string;
+    filterExpression?: string;
+    keyConditionExpression?: string;
+    projectionExpression?: string;
+    expressionAttributeNames?: Record<string, string>;
+    expressionAttributeValues?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+type ReadableDynamoCommand = {
+    conditionExpression?: string;
+    updateExpression?: string;
+    filterExpression?: string;
+    keyConditionExpression?: string;
+    projectionExpression?: string;
+};
+/**
+ * Utility function to debug a DynamoDB command by replacing all placeholders
+ * in expressions with their actual values.
+ *
+ * @param command Any DynamoDB command with expressions and attribute maps
+ * @returns An object with the same structure but with readable expressions
+ */
+export declare function debugCommand<T extends DynamoCommandWithExpressions>(command: T): {
+    raw: T;
+    readable: ReadableDynamoCommand;
+};
+export {};

package/dist/utils/debug-transaction.d.ts

@@ -0,0 +1,17 @@
+import type { TransactionItem } from "../builders/builder-types";
+/**
+ * Utility function to create a human-readable representation of a transaction item
+ * by replacing all expression placeholders with their actual values.
+ *
+ * @param item The transaction item to debug
+ * @returns A readable representation of the transaction item
+ */
+export declare function debugTransactionItem(item: TransactionItem): Record<string, unknown>;
+/**
+ * Utility function to create a human-readable representation of all transaction items
+ * in a transaction by replacing all expression placeholders with their actual values.
+ *
+ * @param items Array of transaction items to debug
+ * @returns An array of readable representations of the transaction items
+ */
+export declare function debugTransaction(items: TransactionItem[]): Record<string, unknown>[];

package/dist/utils/error-factory.d.ts

@@ -0,0 +1,162 @@
+import { BatchError, ConfigurationError, EntityValidationError, ExpressionError, IndexGenerationError, KeyGenerationError, OperationError, TransactionError, ValidationError } from "../errors";
+/**
+ * Factory functions for Expression errors
+ */
+export declare const ExpressionErrors: {
+    missingAttribute: (conditionType: string, condition: unknown) => ExpressionError;
+    missingValue: (conditionType: string, condition: unknown) => ExpressionError;
+    invalidCondition: (conditionType: string, condition: unknown, suggestion?: string) => ExpressionError;
+    emptyArray: (conditionType: string, providedValue: unknown) => ExpressionError;
+    unknownType: (conditionType: string, condition: unknown) => ExpressionError;
+};
+/**
+ * Factory functions for Validation errors
+ */
+export declare const ValidationErrors: {
+    indexSchemaValidationFailed: (validationIssues: unknown, keyType: "partition" | "sort" | "both") => ValidationError;
+    noUpdateActions: (tableName: string, key: Record<string, unknown>) => ValidationError;
+    conditionRequired: (tableName: string, key: Record<string, unknown>) => ValidationError;
+    queryInputValidationFailed: (entityName: string, queryName: string, validationIssues: unknown, providedInput: unknown) => ValidationError;
+    undefinedValue: (path: string, tableName: string, key: Record<string, unknown>) => ValidationError;
+};
+/**
+ * Factory functions for Configuration errors
+ */
+export declare const ConfigurationErrors: {
+    invalidChunkSize: (size: number) => ConfigurationError;
+    sortKeyRequired: (tableName: string, partitionKey: string, sortKey?: string) => ConfigurationError;
+    sortKeyNotDefined: (tableName: string, partitionKey: string, indexName?: string) => ConfigurationError;
+    gsiNotFound: (indexName: string, tableName: string, availableIndexes: string[]) => ConfigurationError;
+    primaryKeyMissing: (tableName: string, partitionKeyName: string, providedItem: unknown) => ConfigurationError;
+    pkExtractionFailed: (tableName: string, indexName: string, item: unknown, cause?: Error) => ConfigurationError;
+    conditionGenerationFailed: (condition: unknown, suggestion?: string) => ExpressionError;
+};
+/**
+ * Factory functions for Operation errors
+ */
+export declare const OperationErrors: {
+    queryFailed: (tableName: string, context: Record<string, unknown>, cause?: Error) => OperationError;
+    scanFailed: (tableName: string, context: Record<string, unknown>, cause?: Error) => OperationError;
+    getFailed: (tableName: string, key: Record<string, unknown>, cause?: Error) => OperationError;
+    putFailed: (tableName: string, item: unknown, cause?: Error) => OperationError;
+    updateFailed: (tableName: string, key: Record<string, unknown>, cause?: Error) => OperationError;
+    deleteFailed: (tableName: string, key: Record<string, unknown>, cause?: Error) => OperationError;
+    batchGetFailed: (tableName: string, context: Record<string, unknown>, cause?: Error) => OperationError;
+    batchWriteFailed: (tableName: string, context: Record<string, unknown>, cause?: Error) => OperationError;
+};
+/**
+ * Factory functions for Transaction errors
+ */
+export declare const TransactionErrors: {
+    transactionFailed: (itemCount: number, context: Record<string, unknown>, cause?: Error) => TransactionError;
+    duplicateItem: (tableName: string, partitionKey: {
+        name: string;
+        value: unknown;
+    }, sortKey?: {
+        name: string;
+        value: unknown;
+    }) => TransactionError;
+    transactionEmpty: () => TransactionError;
+    unsupportedType: (item: unknown) => TransactionError;
+};
+/**
+ * Factory functions for Batch errors
+ */
+export declare const BatchErrors: {
+    batchEmpty: (operation: "write" | "read") => BatchError;
+    unsupportedType: (operation: "write" | "read", item: unknown) => BatchError;
+    batchWriteFailed: (unprocessedItems: unknown[], context: Record<string, unknown>, cause?: Error) => BatchError;
+    batchGetFailed: (unprocessedItems: unknown[], context: Record<string, unknown>, cause?: Error) => BatchError;
+};
+/**
+ * Factory functions for Entity errors
+ */
+export declare const EntityErrors: {
+    validationFailed: (entityName: string, operation: string, validationIssues: unknown, providedData: unknown) => EntityValidationError;
+    queryInputValidationFailed: (entityName: string, queryName: string, validationIssues: unknown, providedInput: unknown) => EntityValidationError;
+    asyncValidationNotSupported: (entityName: string, operation: string) => EntityValidationError;
+    keyGenerationFailed: (entityName: string, operation: string, providedData: unknown, requiredAttributes?: string[], cause?: Error) => KeyGenerationError;
+    keyInvalidFormat: (entityName: string, operation: string, providedData: unknown, generatedKey: unknown) => KeyGenerationError;
+    keyMissingAttributes: (entityName: string, operation: string, missingAttributes: string[], providedData: unknown) => KeyGenerationError;
+};
+/**
+ * Factory functions for Index errors
+ */
+export declare const IndexErrors: {
+    generationFailed: (indexName: string, operation: string, providedItem: unknown, partitionKeyAttribute?: string, sortKeyAttribute?: string, cause?: Error) => IndexGenerationError;
+    missingAttributes: (indexName: string, operation: string, missingAttributes: string[], providedData: unknown, isReadOnly: boolean) => IndexGenerationError;
+    undefinedValues: (indexName: string, operation: string, generatedKey: unknown, providedItem: unknown) => IndexGenerationError;
+    notFound: (requestedIndexes: string[], availableIndexes: string[], entityName?: string, tableName?: string) => IndexGenerationError;
+    readonlyUpdateFailed: (indexName: string, operation: string, providedData: unknown) => IndexGenerationError;
+};
+/**
+ * Combined error factory - provides access to all error factories
+ */
+export declare const ErrorFactory: {
+    expression: {
+        missingAttribute: (conditionType: string, condition: unknown) => ExpressionError;
+        missingValue: (conditionType: string, condition: unknown) => ExpressionError;
+        invalidCondition: (conditionType: string, condition: unknown, suggestion?: string) => ExpressionError;
+        emptyArray: (conditionType: string, providedValue: unknown) => ExpressionError;
+        unknownType: (conditionType: string, condition: unknown) => ExpressionError;
+    };
+    validation: {
+        indexSchemaValidationFailed: (validationIssues: unknown, keyType: "partition" | "sort" | "both") => ValidationError;
+        noUpdateActions: (tableName: string, key: Record<string, unknown>) => ValidationError;
+        conditionRequired: (tableName: string, key: Record<string, unknown>) => ValidationError;
+        queryInputValidationFailed: (entityName: string, queryName: string, validationIssues: unknown, providedInput: unknown) => ValidationError;
+        undefinedValue: (path: string, tableName: string, key: Record<string, unknown>) => ValidationError;
+    };
+    configuration: {
+        invalidChunkSize: (size: number) => ConfigurationError;
+        sortKeyRequired: (tableName: string, partitionKey: string, sortKey?: string) => ConfigurationError;
+        sortKeyNotDefined: (tableName: string, partitionKey: string, indexName?: string) => ConfigurationError;
+        gsiNotFound: (indexName: string, tableName: string, availableIndexes: string[]) => ConfigurationError;
+        primaryKeyMissing: (tableName: string, partitionKeyName: string, providedItem: unknown) => ConfigurationError;
+        pkExtractionFailed: (tableName: string, indexName: string, item: unknown, cause?: Error) => ConfigurationError;
+        conditionGenerationFailed: (condition: unknown, suggestion?: string) => ExpressionError;
+    };
+    operation: {
+        queryFailed: (tableName: string, context: Record<string, unknown>, cause?: Error) => OperationError;
+        scanFailed: (tableName: string, context: Record<string, unknown>, cause?: Error) => OperationError;
+        getFailed: (tableName: string, key: Record<string, unknown>, cause?: Error) => OperationError;
+        putFailed: (tableName: string, item: unknown, cause?: Error) => OperationError;
+        updateFailed: (tableName: string, key: Record<string, unknown>, cause?: Error) => OperationError;
+        deleteFailed: (tableName: string, key: Record<string, unknown>, cause?: Error) => OperationError;
+        batchGetFailed: (tableName: string, context: Record<string, unknown>, cause?: Error) => OperationError;
+        batchWriteFailed: (tableName: string, context: Record<string, unknown>, cause?: Error) => OperationError;
+    };
+    transaction: {
+        transactionFailed: (itemCount: number, context: Record<string, unknown>, cause?: Error) => TransactionError;
+        duplicateItem: (tableName: string, partitionKey: {
+            name: string;
+            value: unknown;
+        }, sortKey?: {
+            name: string;
+            value: unknown;
+        }) => TransactionError;
+        transactionEmpty: () => TransactionError;
+        unsupportedType: (item: unknown) => TransactionError;
+    };
+    batch: {
+        batchEmpty: (operation: "write" | "read") => BatchError;
+        unsupportedType: (operation: "write" | "read", item: unknown) => BatchError;
+        batchWriteFailed: (unprocessedItems: unknown[], context: Record<string, unknown>, cause?: Error) => BatchError;
+        batchGetFailed: (unprocessedItems: unknown[], context: Record<string, unknown>, cause?: Error) => BatchError;
+    };
+    entity: {
+        validationFailed: (entityName: string, operation: string, validationIssues: unknown, providedData: unknown) => EntityValidationError;
+        queryInputValidationFailed: (entityName: string, queryName: string, validationIssues: unknown, providedInput: unknown) => EntityValidationError;
+        asyncValidationNotSupported: (entityName: string, operation: string) => EntityValidationError;
+        keyGenerationFailed: (entityName: string, operation: string, providedData: unknown, requiredAttributes?: string[], cause?: Error) => KeyGenerationError;
+        keyInvalidFormat: (entityName: string, operation: string, providedData: unknown, generatedKey: unknown) => KeyGenerationError;
+        keyMissingAttributes: (entityName: string, operation: string, missingAttributes: string[], providedData: unknown) => KeyGenerationError;
+    };
+    index: {
+        generationFailed: (indexName: string, operation: string, providedItem: unknown, partitionKeyAttribute?: string, sortKeyAttribute?: string, cause?: Error) => IndexGenerationError;
+        missingAttributes: (indexName: string, operation: string, missingAttributes: string[], providedData: unknown, isReadOnly: boolean) => IndexGenerationError;
+        undefinedValues: (indexName: string, operation: string, generatedKey: unknown, providedItem: unknown) => IndexGenerationError;
+        notFound: (requestedIndexes: string[], availableIndexes: string[], entityName?: string, tableName?: string) => IndexGenerationError;
+        readonlyUpdateFailed: (indexName: string, operation: string, providedData: unknown) => IndexGenerationError;
+    };
+};

package/dist/utils/error-utils.d.ts

@@ -0,0 +1,170 @@
+/**
+ * Utility functions for error handling
+ *
+ * This module provides helper functions for wrapping AWS SDK errors,
+ * extracting information from errors, and formatting error context.
+ */
+import type { BatchError, ConfigurationError, DynoTableError, EntityError, EntityValidationError, ExpressionError, IndexGenerationError, KeyGenerationError, OperationError, TransactionError, ValidationError } from "../errors";
+/**
+ * Checks if an error is a DynamoDB conditional check failure
+ *
+ * @param error - The error to check
+ * @returns true if the error is a conditional check failure
+ */
+export declare function isConditionalCheckFailed(error: unknown): boolean;
+/**
+ * Checks if an error is a DynamoDB transaction cancellation
+ *
+ * @param error - The error to check
+ * @returns true if the error is a transaction cancellation
+ */
+export declare function isTransactionCanceled(error: unknown): boolean;
+/**
+ * Checks if an error is a DynamoDB validation exception
+ *
+ * @param error - The error to check
+ * @returns true if the error is a validation exception
+ */
+export declare function isValidationException(error: unknown): boolean;
+/**
+ * Checks if an error is a DynamoDB provisioned throughput exceeded exception
+ *
+ * @param error - The error to check
+ * @returns true if the error is a throughput exceeded exception
+ */
+export declare function isProvisionedThroughputExceeded(error: unknown): boolean;
+/**
+ * Checks if an error is a retryable error
+ *
+ * Retryable errors include:
+ * - ProvisionedThroughputExceededException
+ * - ThrottlingException
+ * - RequestLimitExceeded
+ * - InternalServerError
+ * - ServiceUnavailable
+ *
+ * @param error - The error to check
+ * @returns true if the error is retryable
+ */
+export declare function isRetryableError(error: unknown): boolean;
+/**
+ * Extracts the AWS error code from an error
+ *
+ * @param error - The error to extract the code from
+ * @returns The error code, or undefined if not found
+ */
+export declare function getAwsErrorCode(error: unknown): string | undefined;
+/**
+ * Extracts the AWS error message from an error
+ *
+ * @param error - The error to extract the message from
+ * @returns The error message, or undefined if not found
+ */
+export declare function getAwsErrorMessage(error: unknown): string | undefined;
+/**
+ * Attempts to extract required attribute names from an error message
+ *
+ * This is a best-effort function that looks for common patterns in error
+ * messages to identify which attributes are missing or required.
+ *
+ * @param error - The error to extract attributes from
+ * @returns Array of attribute names, or undefined if none found
+ */
+export declare function extractRequiredAttributes(error: unknown): string[] | undefined;
+/**
+ * Formats error context for logging
+ *
+ * Converts the error context object to a readable string format,
+ * handling special types like arrays and nested objects.
+ *
+ * @param context - The error context to format
+ * @param indent - The indentation level (for nested objects)
+ * @returns Formatted context string
+ */
+export declare function formatErrorContext(context: Record<string, unknown>, indent?: number): string;
+/**
+ * Creates a detailed error summary including context
+ *
+ * Useful for logging or displaying error information to developers.
+ *
+ * @param error - The DynoTableError to summarize
+ * @returns Formatted error summary
+ */
+export declare function getErrorSummary(error: DynoTableError): string;
+/**
+ * Type guard to check if an error is a DynoTableError
+ *
+ * @param error - The error to check
+ * @returns true if the error is a DynoTableError
+ */
+export declare function isDynoTableError(error: unknown): error is DynoTableError;
+/**
+ * Type guard to check if an error is a ValidationError
+ *
+ * @param error - The error to check
+ * @returns true if the error is a ValidationError
+ */
+export declare function isValidationError(error: unknown): error is ValidationError;
+/**
+ * Type guard to check if an error is an OperationError
+ *
+ * @param error - The error to check
+ * @returns true if the error is an OperationError
+ */
+export declare function isOperationError(error: unknown): error is OperationError;
+/**
+ * Type guard to check if an error is a TransactionError
+ *
+ * @param error - The error to check
+ * @returns true if the error is a TransactionError
+ */
+export declare function isTransactionError(error: unknown): error is TransactionError;
+/**
+ * Type guard to check if an error is a BatchError
+ *
+ * @param error - The error to check
+ * @returns true if the error is a BatchError
+ */
+export declare function isBatchError(error: unknown): error is BatchError;
+/**
+ * Type guard to check if an error is an ExpressionError
+ *
+ * @param error - The error to check
+ * @returns true if the error is an ExpressionError
+ */
+export declare function isExpressionError(error: unknown): error is ExpressionError;
+/**
+ * Type guard to check if an error is a ConfigurationError
+ *
+ * @param error - The error to check
+ * @returns true if the error is a ConfigurationError
+ */
+export declare function isConfigurationError(error: unknown): error is ConfigurationError;
+/**
+ * Type guard to check if an error is an EntityError
+ *
+ * @param error - The error to check
+ * @returns true if the error is an EntityError
+ */
+export declare function isEntityError(error: unknown): error is EntityError;
+/**
+ * Type guard to check if an error is a KeyGenerationError
+ *
+ * @param error - The error to check
+ * @returns true if the error is a KeyGenerationError
+ */
+export declare function isKeyGenerationError(error: unknown): error is KeyGenerationError;
+/**
+ * Type guard to check if an error is an IndexGenerationError
+ *
+ * @param error - The error to check
+ * @returns true if the error is an IndexGenerationError
+ */
+export declare function isIndexGenerationError(error: unknown): error is IndexGenerationError;
+/**
+ * Type guard to check if an error is an EntityValidationError
+ *
+ * @param error - The error to check
+ * @returns true if the error is an EntityValidationError
+ */
+export declare function isEntityValidationError(error: unknown): error is EntityValidationError;

package/dist/utils/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Utilities for working with DynamoDB keys.
+ *
+ * @module
+ */
+export { partitionKey } from "./partition-key-template";
+export { sortKey } from "./sort-key-template";

package/dist/utils/partition-key-template.d.ts

@@ -0,0 +1,30 @@
+export type StrictGenerateType<T extends readonly string[]> = {
+    [K in T[number]]: string;
+};
+/**
+ * Creates a template function for generating DynamoDB partition keys with dynamic values.
+ * Use this function when you need to:
+ * - Create consistent partition key patterns with variable parts
+ * - Generate partition keys that follow a specific format
+ * - Ensure type safety for partition key parameters
+ * - Require all parameters to be provided
+ *
+ * @example
+ * ```ts
+ * // Define a partition key template
+ * const pk = partitionKey`country#${"country"}#enclosure#${"enclosure"}`;
+ *
+ * // Generate a partition key (all parameters required)
+ * const key = pk({ country: "NZ", enclosure: "A1" });
+ * // Result: "country#NZ#enclosure#A1"
+ *
+ * // Type checking ensures all parameters are provided
+ * const invalidKey = pk({ country: "NZ" }); // TypeScript error
+ * ```
+ *
+ * @param strings - The static parts of the template string
+ * @param keys - The dynamic parts of the template string that will be replaced with values
+ *
+ * @returns A function that accepts an object with the dynamic values and returns the formatted partition key
+ */
+export declare function partitionKey<T extends readonly string[]>(strings: TemplateStringsArray, ...keys: T): (params: StrictGenerateType<T>) => string;

package/dist/utils/sort-key-template.d.ts

@@ -0,0 +1,33 @@
+export type GenerateType<T extends readonly string[], U extends string = never> = T extends [infer F, ...infer R] ? F extends string ? R extends string[] ? ({
+    [K in F | U]: string | number;
+} & Partial<Record<Exclude<T[number], F | U>, never>>) | GenerateType<R, F | U> : never : never : never;
+/**
+ * Creates a template function for generating DynamoDB sort keys with dynamic values.
+ * Use this function when you need to:
+ * - Create consistent sort key patterns with variable parts
+ * - Generate sort keys that follow a specific format
+ * - Ensure type safety for sort key parameters
+ *
+ * @example
+ * ```ts
+ * // Define a sort key template
+ * const sk = sortKey`country#${"country"}#enclosure#${"enclosure"}#diet#${"diet"}`;
+ *
+ * // Generate a sort key with partial parameters
+ * const templatedString = sk({ country: "NZ", enclosure: "A1" });
+ * // Result: "country#NZ#enclosure#A1#diet#"
+ *
+ * // Generate a complete sort key
+ * const fullKey = sk({ country: "NZ", enclosure: "A1", diet: "carnivore" });
+ * // Result: "country#NZ#enclosure#A1#diet#carnivore"
+ *
+ * // Type checking ensures only valid parameters are used
+ * const invalidKey = sk({ country: "NZ", invalid: "value" }); // TypeScript error
+ * ```
+ *
+ * @param strings - The static parts of the template string
+ * @param keys - The dynamic parts of the template string that will be replaced with values
+ *
+ * @returns A function that accepts an object with the dynamic values and returns the formatted sort key
+ */
+export declare function sortKey<T extends readonly string[]>(strings: TemplateStringsArray, ...keys: T): (params: GenerateType<T>) => string;

package/dist/utils.d.ts

@@ -1,66 +1 @@
-type StrictGenerateType<T extends readonly string[]> = {
-    [K in T[number]]: string;
-};
-/**
- * Creates a template function for generating DynamoDB partition keys with dynamic values.
- * Use this function when you need to:
- * - Create consistent partition key patterns with variable parts
- * - Generate partition keys that follow a specific format
- * - Ensure type safety for partition key parameters
- * - Require all parameters to be provided
- *
- * @example
- * ```ts
- * // Define a partition key template
- * const pk = partitionKey`country#${"country"}#enclosure#${"enclosure"}`;
- *
- * // Generate a partition key (all parameters required)
- * const key = pk({ country: "NZ", enclosure: "A1" });
- * // Result: "country#NZ#enclosure#A1"
- *
- * // Type checking ensures all parameters are provided
- * const invalidKey = pk({ country: "NZ" }); // TypeScript error
- * ```
- *
- * @param strings - The static parts of the template string
- * @param keys - The dynamic parts of the template string that will be replaced with values
- *
- * @returns A function that accepts an object with the dynamic values and returns the formatted partition key
- */
-declare function partitionKey<T extends readonly string[]>(strings: TemplateStringsArray, ...keys: T): (params: StrictGenerateType<T>) => string;
-
-type GenerateType<T extends readonly string[], U extends string = never> = T extends [infer F, ...infer R] ? F extends string ? R extends string[] ? ({
-    [K in F | U]: string | number;
-} & Partial<Record<Exclude<T[number], F | U>, never>>) | GenerateType<R, F | U> : never : never : never;
-/**
- * Creates a template function for generating DynamoDB sort keys with dynamic values.
- * Use this function when you need to:
- * - Create consistent sort key patterns with variable parts
- * - Generate sort keys that follow a specific format
- * - Ensure type safety for sort key parameters
- *
- * @example
- * ```ts
- * // Define a sort key template
- * const sk = sortKey`country#${"country"}#enclosure#${"enclosure"}#diet#${"diet"}`;
- *
- * // Generate a sort key with partial parameters
- * const templatedString = sk({ country: "NZ", enclosure: "A1" });
- * // Result: "country#NZ#enclosure#A1#diet#"
- *
- * // Generate a complete sort key
- * const fullKey = sk({ country: "NZ", enclosure: "A1", diet: "carnivore" });
- * // Result: "country#NZ#enclosure#A1#diet#carnivore"
- *
- * // Type checking ensures only valid parameters are used
- * const invalidKey = sk({ country: "NZ", invalid: "value" }); // TypeScript error
- * ```
- *
- * @param strings - The static parts of the template string
- * @param keys - The dynamic parts of the template string that will be replaced with values
- *
- * @returns A function that accepts an object with the dynamic values and returns the formatted sort key
- */
-declare function sortKey<T extends readonly string[]>(strings: TemplateStringsArray, ...keys: T): (params: GenerateType<T>) => string;
-
-export { partitionKey, sortKey };
+export * from "./utils/index";