dynamodb-reactive 0.1.0 → 0.1.1

package/dist/server.d.ts

@@ -1,2 +1,631 @@
-export * from '@dynamodb-reactive/server';
-//# sourceMappingURL=server.d.ts.map
+import { z } from 'zod';
+import { D as DynamoTable } from './table-CSJysZPQ.js';
+import { A as AnyDynamoTable, F as FieldRef, a as FilterCondition, Q as QueryMetadata, J as JsonPatch } from './types-Ci7IieDA.js';
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { DynamoDBStreamEvent, APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
+
+/**
+ * Context type for procedures
+ */
+interface ProcedureContext<TContext = unknown> {
+    ctx: TContext & {
+        db: DatabaseContext;
+    };
+    input: unknown;
+}
+/**
+ * Database context provided to procedures
+ */
+interface DatabaseContext {
+    query<TTable extends AnyDynamoTable>(table: TTable): QueryBuilder<TTable>;
+    get<TTable extends AnyDynamoTable>(table: TTable, key: TableKeyInput<TTable>): Promise<TableItem<TTable> | null>;
+    put<TTable extends AnyDynamoTable>(table: TTable, item: TableItem<TTable>): Promise<void>;
+    delete<TTable extends AnyDynamoTable>(table: TTable, key: TableKeyInput<TTable>): Promise<void>;
+    update<TTable extends AnyDynamoTable>(table: TTable, key: TableKeyInput<TTable>, updates: Partial<TableItem<TTable>>): Promise<TableItem<TTable>>;
+}
+/**
+ * Extract the item type from a DynamoTable
+ * Works with both the DynamoTable class and AnyDynamoTable interface
+ */
+type TableItem<T extends AnyDynamoTable> = T extends DynamoTable<infer TSchema, any, any, any> ? z.infer<TSchema> : T extends {
+    schema: infer TSchema extends z.ZodTypeAny;
+} ? z.infer<TSchema> : never;
+/**
+ * Extract key input type from a DynamoTable
+ * Works with both the DynamoTable class and AnyDynamoTable interface
+ */
+type TableKeyInput<T extends AnyDynamoTable> = T extends DynamoTable<infer TSchema, infer TPk, infer TSk, any> ? TSk extends keyof z.infer<TSchema> ? Pick<z.infer<TSchema>, TPk | TSk> : Pick<z.infer<TSchema>, TPk> : T extends {
+    schema: infer TSchema extends z.ZodTypeAny;
+    pk: infer TPk;
+    sk: infer TSk;
+} ? TSk extends keyof z.infer<TSchema> ? Pick<z.infer<TSchema>, (TPk & keyof z.infer<TSchema>) | TSk> : Pick<z.infer<TSchema>, TPk & keyof z.infer<TSchema>> : never;
+/**
+ * Query builder for type-safe DynamoDB queries
+ */
+interface QueryBuilder<TTable extends AnyDynamoTable> {
+    filter(fn: (q: FilterBuilder<TTable>) => FilterCondition): QueryBuilder<TTable>;
+    useIndex(indexName: keyof TableIndexes<TTable>): QueryBuilder<TTable>;
+    take(limit: number): QueryBuilder<TTable>;
+    startFrom(key: TableKeyInput<TTable>): QueryBuilder<TTable>;
+    sortAscending(): QueryBuilder<TTable>;
+    sortDescending(): QueryBuilder<TTable>;
+    execute(): Promise<TableItem<TTable>[]>;
+}
+/**
+ * Filter builder for query conditions
+ */
+interface FilterBuilder<TTable extends AnyDynamoTable> {
+    eq<K extends keyof TableItem<TTable>>(field: FieldRef<K & string, TableItem<TTable>[K]>, value: TableItem<TTable>[K]): FilterCondition;
+    ne<K extends keyof TableItem<TTable>>(field: FieldRef<K & string, TableItem<TTable>[K]>, value: TableItem<TTable>[K]): FilterCondition;
+    gt<K extends keyof TableItem<TTable>>(field: FieldRef<K & string, TableItem<TTable>[K]>, value: TableItem<TTable>[K]): FilterCondition;
+    gte<K extends keyof TableItem<TTable>>(field: FieldRef<K & string, TableItem<TTable>[K]>, value: TableItem<TTable>[K]): FilterCondition;
+    lt<K extends keyof TableItem<TTable>>(field: FieldRef<K & string, TableItem<TTable>[K]>, value: TableItem<TTable>[K]): FilterCondition;
+    lte<K extends keyof TableItem<TTable>>(field: FieldRef<K & string, TableItem<TTable>[K]>, value: TableItem<TTable>[K]): FilterCondition;
+    between<K extends keyof TableItem<TTable>>(field: FieldRef<K & string, TableItem<TTable>[K]>, lower: TableItem<TTable>[K], upper: TableItem<TTable>[K]): FilterCondition;
+    beginsWith<K extends keyof TableItem<TTable>>(field: FieldRef<K & string, string>, prefix: string): FilterCondition;
+    contains<K extends keyof TableItem<TTable>>(field: FieldRef<K & string, string>, substring: string): FilterCondition;
+    and(...conditions: FilterCondition[]): FilterCondition;
+    or(...conditions: FilterCondition[]): FilterCondition;
+    not(condition: FilterCondition): FilterCondition;
+}
+/**
+ * Extract indexes from a DynamoTable
+ */
+type TableIndexes<T extends AnyDynamoTable> = T extends DynamoTable<any, any, any, infer TIndexes> ? TIndexes : T extends {
+    indexes: infer TIndexes;
+} ? TIndexes : never;
+/**
+ * Procedure types
+ */
+type ProcedureType = 'query' | 'mutation';
+/**
+ * Procedure definition
+ */
+interface ProcedureDefinition<TContext, TInput extends z.ZodTypeAny = z.ZodUndefined, TOutput = unknown> {
+    type: ProcedureType;
+    inputSchema?: TInput;
+    resolver: (opts: {
+        ctx: TContext & {
+            db: DatabaseContext;
+        };
+        input: z.infer<TInput>;
+    }) => Promise<TOutput> | TOutput;
+}
+/**
+ * Any procedure definition - used for generic constraints
+ * Uses 'any' for input/output to allow covariant assignment
+ */
+type AnyProcedureDefinition<TContext> = ProcedureDefinition<TContext, any, any>;
+/**
+ * Router definition
+ */
+type RouterDefinition<TContext> = {
+    [key: string]: AnyProcedureDefinition<TContext> | RouterDefinition<TContext>;
+};
+/**
+ * Dependency information extracted from a query
+ */
+interface QueryDependency {
+    tableName: string;
+    fieldName: string;
+    fieldValue: string;
+    indexName?: string;
+}
+/**
+ * Tracked query operation (for dependency extraction and stream processing)
+ */
+interface TrackedQueryOperation {
+    tableName: string;
+    filters: FilterCondition[];
+    indexName?: string;
+    /** Primary key field name for the table */
+    pkField: string;
+    /** Sort key field name for the table (if any) */
+    skField?: string;
+    /** Sort field for ordering results */
+    sortField?: string;
+    /** Sort direction */
+    sortOrder?: 'asc' | 'desc';
+    /** Maximum number of results */
+    limit?: number;
+}
+
+/**
+ * Procedure builder for creating type-safe procedures
+ */
+declare class ProcedureBuilder<TContext, TInput extends z.ZodType = z.ZodUndefined> {
+    private inputSchema?;
+    constructor(inputSchema?: TInput);
+    /**
+     * Define the input schema for the procedure
+     */
+    input<TNewInput extends z.ZodType>(schema: TNewInput): ProcedureBuilder<TContext, TNewInput>;
+    /**
+     * Define a query procedure (read-only operation)
+     */
+    query<TOutput>(resolver: (opts: {
+        ctx: TContext & {
+            db: DatabaseContext;
+        };
+        input: z.infer<TInput>;
+    }) => Promise<TOutput> | TOutput): ProcedureDefinition<TContext, TInput, TOutput>;
+    /**
+     * Define a mutation procedure (write operation)
+     */
+    mutation<TOutput>(resolver: (opts: {
+        ctx: TContext & {
+            db: DatabaseContext;
+        };
+        input: z.infer<TInput>;
+    }) => Promise<TOutput> | TOutput): ProcedureDefinition<TContext, TInput, TOutput>;
+}
+/**
+ * Check if a value is a procedure definition
+ */
+declare function isProcedure(value: unknown): value is ProcedureDefinition<any, any, any>;
+/**
+ * Execute a procedure with the given context and input
+ */
+declare function executeProcedure<TContext, TInput extends z.ZodType, TOutput>(procedure: ProcedureDefinition<TContext, TInput, TOutput>, ctx: TContext & {
+    db: DatabaseContext;
+}, rawInput: unknown): Promise<TOutput>;
+
+/**
+ * Router class for organizing procedures
+ */
+declare class Router<TContext, TRouter extends RouterDefinition<TContext>> {
+    readonly definition: TRouter;
+    constructor(definition: TRouter);
+    /**
+     * Get a procedure by its path (e.g., "todos.list")
+     */
+    getProcedure(path: string): ProcedureDefinition<TContext, any, any> | null;
+    /**
+     * Execute a procedure by its path
+     */
+    execute(path: string, ctx: TContext & {
+        db: DatabaseContext;
+    }, input: unknown): Promise<unknown>;
+    /**
+     * Get all procedure paths in the router
+     */
+    getProcedurePaths(): string[];
+    /**
+     * Check if a path is a query procedure
+     */
+    isQuery(path: string): boolean;
+    /**
+     * Check if a path is a mutation procedure
+     */
+    isMutation(path: string): boolean;
+}
+/**
+ * Create a router from a definition
+ */
+declare function createRouter<TContext, TRouter extends RouterDefinition<TContext>>(definition: TRouter): Router<TContext, TRouter>;
+/**
+ * Merge multiple routers into one
+ */
+declare function mergeRouters<TContext>(...routers: Router<TContext, any>[]): Router<TContext, RouterDefinition<TContext>>;
+
+/**
+ * ReactiveBuilder - The main builder returned by initReactive
+ */
+interface ReactiveBuilder<TContext> {
+    /**
+     * Create a new procedure builder
+     */
+    procedure: ProcedureBuilder<TContext>;
+    /**
+     * Create a router from procedure definitions
+     */
+    router<TRouter extends RouterDefinition<TContext>>(definition: TRouter): Router<TContext, TRouter>;
+}
+/**
+ * Initialize the reactive system with a context type
+ *
+ * @example
+ * ```ts
+ * const t = initReactive<{ userId: string }>();
+ *
+ * export const appRouter = t.router({
+ *   todos: {
+ *     list: t.procedure
+ *       .input(z.object({ taskListId: z.string() }))
+ *       .query(({ ctx, input }) => {
+ *         return ctx.db
+ *           .query(TodoTable)
+ *           .filter((q) => q.eq(TodoTable.field.taskListId, input.taskListId))
+ *           .take(50);
+ *       }),
+ *   }
+ * });
+ * ```
+ */
+declare function initReactive<TContext = Record<string, unknown>>(): ReactiveBuilder<TContext>;
+/**
+ * Type helper to infer the router type
+ */
+type InferRouterType<T> = T extends Router<infer TContext, infer TRouter> ? {
+    context: TContext;
+    router: TRouter;
+} : never;
+/**
+ * Type helper to get procedure input type
+ */
+type InferProcedureInput<T> = T extends {
+    inputSchema: infer TSchema;
+} ? TSchema extends z.ZodType ? z.infer<TSchema> : undefined : undefined;
+/**
+ * Type helper to get procedure output type
+ */
+type InferProcedureOutput<T> = T extends {
+    resolver: (...args: any) => infer TOutput;
+} ? Awaited<TOutput> : unknown;
+
+/**
+ * Extract dependencies from a tracked query operation
+ */
+declare function extractDependencies(operation: TrackedQueryOperation): QueryDependency[];
+/**
+ * Create a dependency key for the inverted index
+ * Format: "TableName#FieldName#FieldValue"
+ */
+declare function createDependencyKey(dependency: QueryDependency): string;
+/**
+ * Parse a dependency key back into its components
+ */
+declare function parseDependencyKey(key: string): QueryDependency | null;
+/**
+ * Extract affected dependency keys from a DynamoDB stream record
+ * This finds all keys that might be affected by a change
+ */
+declare function extractAffectedKeys(tableName: string, item: Record<string, unknown>): string[];
+/**
+ * Convert a TrackedQueryOperation to QueryMetadata for storage.
+ * Normalizes filter operators for evaluation.
+ */
+declare function operationToQueryMetadata(operation: TrackedQueryOperation): QueryMetadata;
+/**
+ * DependencyTracker - Tracks query operations during procedure execution
+ */
+declare class DependencyTracker {
+    private operations;
+    /**
+     * Track a query operation
+     */
+    track(operation: TrackedQueryOperation): void;
+    /**
+     * Get all tracked operations
+     */
+    getOperations(): TrackedQueryOperation[];
+    /**
+     * Extract all dependencies from tracked operations
+     */
+    extractAll(): QueryDependency[];
+    /**
+     * Get all dependency keys for the inverted index
+     */
+    getDependencyKeys(): string[];
+    /**
+     * Get query metadata for the first tracked operation.
+     * Used for storing subscription state.
+     */
+    getQueryMetadata(): QueryMetadata | null;
+    /**
+     * Get the primary key field from the first operation
+     */
+    getPkField(): string | null;
+    /**
+     * Get the sort key field from the first operation
+     */
+    getSkField(): string | undefined;
+    /**
+     * Clear tracked operations
+     */
+    clear(): void;
+}
+
+/**
+ * Configuration for creating a database context
+ */
+interface DbContextConfig {
+    client?: DynamoDBClient;
+    region?: string;
+    endpoint?: string;
+}
+/**
+ * Creates a database context for procedure execution
+ */
+declare function createDbContext(config: DbContextConfig, dependencyTracker?: DependencyTracker): DatabaseContext;
+
+/**
+ * Query execution function type
+ */
+type QueryExecutor<TTable extends AnyDynamoTable> = (operation: TrackedQueryOperation, options: QueryOptions) => Promise<TableItem<TTable>[]>;
+/**
+ * Query options
+ */
+interface QueryOptions {
+    limit?: number;
+    startKey?: Record<string, unknown>;
+    ascending: boolean;
+}
+/**
+ * Implementation of QueryBuilder
+ */
+declare class QueryBuilderImpl<TTable extends AnyDynamoTable> implements QueryBuilder<TTable> {
+    private table;
+    private filters;
+    private indexName?;
+    private limit?;
+    private startKey?;
+    private ascending;
+    private executor;
+    private operationTracker?;
+    constructor(table: TTable, executor: QueryExecutor<TTable>, operationTracker?: (op: TrackedQueryOperation) => void);
+    filter(fn: (q: FilterBuilder<TTable>) => FilterCondition): QueryBuilder<TTable>;
+    useIndex(indexName: string): QueryBuilder<TTable>;
+    take(limit: number): QueryBuilder<TTable>;
+    startFrom(key: TableKeyInput<TTable>): QueryBuilder<TTable>;
+    sortAscending(): QueryBuilder<TTable>;
+    sortDescending(): QueryBuilder<TTable>;
+    execute(): Promise<TableItem<TTable>[]>;
+    /**
+     * Get the current operation without executing
+     * Used for dependency extraction
+     */
+    getOperation(): TrackedQueryOperation;
+}
+/**
+ * Create a filter builder instance
+ */
+declare function createFilterBuilder<TTable extends AnyDynamoTable>(): FilterBuilder<TTable>;
+
+/**
+ * PartiQL statement with parameters
+ */
+interface PartiQLStatement {
+    statement: string;
+    parameters: unknown[];
+}
+/**
+ * Build a PartiQL SELECT statement from a query operation
+ */
+declare function buildSelectStatement(operation: TrackedQueryOperation): PartiQLStatement;
+/**
+ * Build a PartiQL INSERT statement
+ */
+declare function buildInsertStatement(tableName: string, item: Record<string, unknown>): PartiQLStatement;
+/**
+ * Build a PartiQL UPDATE statement
+ */
+declare function buildUpdateStatement(tableName: string, key: Record<string, unknown>, updates: Record<string, unknown>): PartiQLStatement;
+/**
+ * Build a PartiQL DELETE statement
+ */
+declare function buildDeleteStatement(tableName: string, key: Record<string, unknown>): PartiQLStatement;
+/**
+ * Build a PartiQL GET statement (for single item by key)
+ */
+declare function buildGetStatement(tableName: string, key: Record<string, unknown>): PartiQLStatement;
+
+/**
+ * Generate JSON patches between two objects
+ * Uses RFC 6902 JSON Patch format
+ */
+declare function generatePatches(oldValue: unknown, newValue: unknown): JsonPatch[];
+/**
+ * Apply JSON patches to an object
+ * Returns the patched result
+ */
+declare function applyPatches<T>(document: T, patches: JsonPatch[]): T;
+/**
+ * Check if there are any changes between two values
+ */
+declare function hasChanges(oldValue: unknown, newValue: unknown): boolean;
+/**
+ * Create a minimal patch that only includes necessary operations
+ * Optimizes the patch by removing redundant operations
+ */
+declare function optimizePatches(patches: JsonPatch[]): JsonPatch[];
+/**
+ * Batch multiple patch sets into a single set
+ */
+declare function batchPatches(patchSets: JsonPatch[][]): JsonPatch[];
+
+/**
+ * Request types for the reactive handler
+ */
+interface SubscribeRequest {
+    type: 'subscribe';
+    subscriptionId: string;
+    path: string;
+    input: unknown;
+}
+interface UnsubscribeRequest {
+    type: 'unsubscribe';
+    subscriptionId: string;
+}
+interface CallRequest {
+    type: 'call';
+    path: string;
+    input: unknown;
+}
+type ReactiveRequest = SubscribeRequest | UnsubscribeRequest | CallRequest;
+/**
+ * Response types for the reactive handler
+ */
+interface SnapshotResponse {
+    type: 'snapshot';
+    subscriptionId: string;
+    data: unknown;
+}
+interface PatchResponse {
+    type: 'patch';
+    subscriptionId: string;
+    patches: unknown[];
+}
+interface ResultResponse {
+    type: 'result';
+    data: unknown;
+}
+interface ErrorResponse {
+    type: 'error';
+    message: string;
+    subscriptionId?: string;
+}
+type ReactiveResponse = SnapshotResponse | PatchResponse | ResultResponse | ErrorResponse;
+/**
+ * Configuration for the reactive handler
+ */
+interface ReactiveHandlerConfig<TContext> {
+    router: Router<TContext, any>;
+    dbConfig?: DbContextConfig;
+    getContext: (connectionId: string) => Promise<TContext>;
+    ttlSeconds?: number;
+    /** Table names (uses defaults if not provided) */
+    connectionsTableName?: string;
+    dependenciesTableName?: string;
+    queriesTableName?: string;
+}
+/**
+ * Create a reactive handler for Next.js API routes or other HTTP servers.
+ * This handler is used for subscribe/call requests and stores queryMetadata
+ * for the stream handler to use later.
+ */
+declare function createReactiveHandler<TContext>(config: ReactiveHandlerConfig<TContext>): {
+    handleRequest: (connectionId: string, request: ReactiveRequest) => Promise<ReactiveResponse>;
+    registerConnection: (connectionId: string, context?: Record<string, unknown>) => Promise<void>;
+    unregisterConnection: (connectionId: string) => Promise<void>;
+};
+
+/**
+ * Configuration for the stream handler.
+ * NOTE: Router is no longer required - stream processing uses stored query metadata.
+ */
+interface StreamHandlerConfig {
+    dbConfig?: DbContextConfig;
+    apiGatewayEndpoint: string;
+    connectionsTableName?: string;
+    dependenciesTableName?: string;
+    queriesTableName?: string;
+}
+/**
+ * Create a DynamoDB stream handler for AWS Lambda.
+ * Uses stored query metadata to re-execute queries WITHOUT router code.
+ */
+declare function createStreamHandler(config: StreamHandlerConfig): {
+    handler: (event: DynamoDBStreamEvent) => Promise<void>;
+};
+/**
+ * WebSocket connection handler for $connect
+ */
+declare function createConnectHandler(config: Pick<StreamHandlerConfig, 'dbConfig' | 'connectionsTableName'>): (event: {
+    requestContext: {
+        connectionId: string;
+        authorizer?: Record<string, unknown>;
+    };
+}) => Promise<{
+    statusCode: number;
+}>;
+/**
+ * WebSocket disconnection handler for $disconnect
+ */
+declare function createDisconnectHandler(config: Pick<StreamHandlerConfig, 'dbConfig' | 'connectionsTableName' | 'queriesTableName' | 'dependenciesTableName'>): (event: {
+    requestContext: {
+        connectionId: string;
+    };
+}) => Promise<{
+    statusCode: number;
+}>;
+
+/**
+ * Configuration for creating a reactive harness
+ */
+interface ReactiveHarnessConfig<TContext> {
+    /**
+     * Function to get the context for a connection
+     * This is called on each request to build the procedure context
+     */
+    getContext?: (connectionId: string) => Promise<TContext>;
+    /**
+     * Optional database configuration
+     */
+    dbConfig?: DbContextConfig;
+}
+/**
+ * The reactive harness object containing all configuration needed for the engine
+ */
+interface ReactiveHarness<TContext> {
+    getContext: (connectionId: string) => Promise<TContext>;
+    dbConfig?: DbContextConfig;
+}
+/**
+ * Create a reactive harness that encapsulates the router and context configuration.
+ *
+ * This is the only export needed from user code for the ReactiveEngine.
+ * The engine will use this harness to automatically create all WebSocket handlers.
+ *
+ * @example
+ * ```typescript
+ * // harness.ts - This is all you need in your handlers directory
+ * import { createReactiveHarness } from 'dynamodb-reactive/server';
+ * import { appRouter } from './router';
+ *
+ * export default createReactiveHarness({
+ *   getContext: async (connectionId) => ({
+ *     connectionId,
+ *   }),
+ * });
+ * ```
+ */
+declare function createReactiveHarness<TContext>(config: ReactiveHarnessConfig<TContext>): ReactiveHarness<TContext>;
+
+/**
+ * Lambda handler implementations for the reactive WebSocket system.
+ *
+ * These handlers process WebSocket events and DynamoDB stream events
+ * WITHOUT requiring user router code at runtime.
+ *
+ * Stream processing uses stored query metadata to evaluate changes
+ * directly, rather than re-executing queries through a router.
+ */
+
+/**
+ * Create all Lambda handlers.
+ * No user code required - all configuration comes from environment variables.
+ * The stream handler uses stored query metadata (PartiQL), not router code.
+ */
+declare function createLambdaHandlers(): {
+    connectHandler: (event: APIGatewayProxyEvent) => Promise<APIGatewayProxyResult>;
+    disconnectHandler: (event: APIGatewayProxyEvent) => Promise<APIGatewayProxyResult>;
+    messageHandler: (event: APIGatewayProxyEvent) => Promise<APIGatewayProxyResult>;
+    streamHandler: (event: DynamoDBStreamEvent) => Promise<void>;
+};
+
+/**
+ * Filter evaluator for evaluating FilterCondition against DynamoDB records.
+ * Used by the stream handler to determine if a record matches a subscription's query.
+ */
+
+/**
+ * Evaluate a filter condition against a record.
+ * Returns true if the record matches the filter.
+ */
+declare function evaluateFilter(filter: FilterCondition, record: Record<string, unknown>): boolean;
+/**
+ * Evaluate multiple filter conditions (all must match - AND logic).
+ */
+declare function evaluateFilters(filters: FilterCondition[], record: Record<string, unknown>): boolean;
+/**
+ * Sort records by a field.
+ */
+declare function sortRecords(records: Record<string, unknown>[], sortField?: string, sortOrder?: 'asc' | 'desc'): Record<string, unknown>[];
+/**
+ * Find the primary key value(s) from a record.
+ * Used to identify records for update/removal.
+ */
+declare function getRecordKey(record: Record<string, unknown>, pkField: string, skField?: string): string;
+
+export { AnyDynamoTable, type AnyProcedureDefinition, type CallRequest, type DatabaseContext, type DbContextConfig, DependencyTracker, type ErrorResponse, type FilterBuilder, FilterCondition, type InferProcedureInput, type InferProcedureOutput, type InferRouterType, type PartiQLStatement, type PatchResponse, ProcedureBuilder, type ProcedureContext, type ProcedureDefinition, type ProcedureType, type QueryBuilder, QueryBuilderImpl, type QueryDependency, type ReactiveBuilder, type ReactiveHandlerConfig, type ReactiveHarness, type ReactiveHarnessConfig, type ReactiveRequest, type ReactiveResponse, type ResultResponse, Router, type RouterDefinition, type SnapshotResponse, type StreamHandlerConfig, type SubscribeRequest, type TableItem, type TableKeyInput, type TrackedQueryOperation, type UnsubscribeRequest, applyPatches, batchPatches, buildDeleteStatement, buildGetStatement, buildInsertStatement, buildSelectStatement, buildUpdateStatement, createConnectHandler, createDbContext, createDependencyKey, createDisconnectHandler, createFilterBuilder, createLambdaHandlers, createReactiveHandler, createReactiveHarness, createRouter, createStreamHandler, evaluateFilter, evaluateFilters, executeProcedure, extractAffectedKeys, extractDependencies, generatePatches, getRecordKey, hasChanges, initReactive, isProcedure, mergeRouters, operationToQueryMetadata, optimizePatches, parseDependencyKey, sortRecords };