dynamodb-reactive 0.1.22 → 0.2.1

package/dist/index.d.cts

@@ -0,0 +1,157 @@
+export { D as DynamoTable } from './table-BijJ73pX.js';
+import { a as FilterCondition } from './types-LMLk8JVC.js';
+export { A as AnyDynamoTable, C as ConnectionEntry, b as DependencyEntry, D as DynamoTableConfig, F as FieldRef, I as IndexDefinition, J as JsonPatch, P as PendingDelivery, c as QueryEntry, Q as QueryMetadata, S as SupportedSchema } from './types-LMLk8JVC.js';
+import { z } from 'zod';
+
+declare const FilterConditionSchema: z.ZodType<FilterCondition>;
+declare const QueryMetadataSchema: z.ZodObject<{
+    planVersion: z.ZodLiteral<1>;
+    tableName: z.ZodString;
+    indexName: z.ZodOptional<z.ZodString>;
+    indexPkField: z.ZodOptional<z.ZodString>;
+    indexSkField: z.ZodOptional<z.ZodString>;
+    filterConditions: z.ZodArray<z.ZodType<FilterCondition, unknown, z.core.$ZodTypeInternals<FilterCondition, unknown>>>;
+    sortField: z.ZodOptional<z.ZodString>;
+    sortOrder: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+declare const PendingDeliverySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    generation: z.ZodNumber;
+    fromVersion: z.ZodNumber;
+    toVersion: z.ZodNumber;
+    messageId: z.ZodString;
+    type: z.ZodLiteral<"patch">;
+    patches: z.ZodArray<z.ZodObject<{
+        op: z.ZodEnum<{
+            add: "add";
+            remove: "remove";
+            replace: "replace";
+            move: "move";
+            copy: "copy";
+            test: "test";
+        }>;
+        path: z.ZodString;
+        value: z.ZodOptional<z.ZodUnknown>;
+        from: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    generation: z.ZodNumber;
+    fromVersion: z.ZodNumber;
+    toVersion: z.ZodNumber;
+    messageId: z.ZodString;
+    type: z.ZodLiteral<"resync">;
+}, z.core.$strict>], "type">;
+/**
+ * System table schemas for the reactive engine
+ */
+declare const SystemSchemas: {
+    /**
+     * ReactiveConnectionsV2 - Tracks active WebSocket connections
+     */
+    connections: z.ZodObject<{
+        connectionId: z.ZodString;
+        status: z.ZodEnum<{
+            open: "open";
+            closed: "closed";
+        }>;
+        context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        authorizerContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        requestIdentity: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        connectedAt: z.ZodNumber;
+        ttl: z.ZodNumber;
+    }, z.core.$strip>;
+    /**
+     * ReactiveDependenciesV2 - The inverted index for O(1) lookups
+     */
+    dependencies: z.ZodObject<{
+        pk: z.ZodString;
+        sk: z.ZodString;
+        connectionId: z.ZodString;
+        subscriptionId: z.ZodString;
+        tableName: z.ZodString;
+        fieldName: z.ZodString;
+        fieldValue: z.ZodString;
+        generation: z.ZodNumber;
+        registrationId: z.ZodString;
+        ttl: z.ZodNumber;
+    }, z.core.$strip>;
+    /**
+     * ReactiveConnectionQueriesV2 - Stores subscription state for diffing
+     */
+    queries: z.ZodObject<{
+        pk: z.ZodString;
+        sk: z.ZodString;
+        connectionId: z.ZodString;
+        subscriptionId: z.ZodString;
+        status: z.ZodEnum<{
+            registering: "registering";
+            active: "active";
+            cancelled: "cancelled";
+            faulted: "faulted";
+        }>;
+        generation: z.ZodNumber;
+        registrationId: z.ZodString;
+        queryMetadata: z.ZodObject<{
+            planVersion: z.ZodLiteral<1>;
+            tableName: z.ZodString;
+            indexName: z.ZodOptional<z.ZodString>;
+            indexPkField: z.ZodOptional<z.ZodString>;
+            indexSkField: z.ZodOptional<z.ZodString>;
+            filterConditions: z.ZodArray<z.ZodType<FilterCondition, unknown, z.core.$ZodTypeInternals<FilterCondition, unknown>>>;
+            sortField: z.ZodOptional<z.ZodString>;
+            sortOrder: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        lastResult: z.ZodArray<z.ZodUnknown>;
+        dependencies: z.ZodArray<z.ZodString>;
+        version: z.ZodNumber;
+        pendingDelivery: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            generation: z.ZodNumber;
+            fromVersion: z.ZodNumber;
+            toVersion: z.ZodNumber;
+            messageId: z.ZodString;
+            type: z.ZodLiteral<"patch">;
+            patches: z.ZodArray<z.ZodObject<{
+                op: z.ZodEnum<{
+                    add: "add";
+                    remove: "remove";
+                    replace: "replace";
+                    move: "move";
+                    copy: "copy";
+                    test: "test";
+                }>;
+                path: z.ZodString;
+                value: z.ZodOptional<z.ZodUnknown>;
+                from: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            generation: z.ZodNumber;
+            fromVersion: z.ZodNumber;
+            toVersion: z.ZodNumber;
+            messageId: z.ZodString;
+            type: z.ZodLiteral<"resync">;
+        }, z.core.$strict>], "type">>;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+        ttl: z.ZodNumber;
+    }, z.core.$strip>;
+};
+/** Storage/protocol generation used by all reactive system tables. */
+declare const SYSTEM_TABLE_PROTOCOL_VERSION: 2;
+/**
+ * Versioned system table names. The V2 suffix intentionally prevents state
+ * written by the incompatible 0.1.x dependency protocol from being reused.
+ */
+declare const SystemTableNames: {
+    readonly connections: "ReactiveConnectionsV2";
+    readonly dependencies: "ReactiveDependenciesV2";
+    readonly queries: "ReactiveConnectionQueriesV2";
+};
+
+export { FilterCondition, FilterConditionSchema, PendingDeliverySchema, QueryMetadataSchema, SYSTEM_TABLE_PROTOCOL_VERSION, SystemSchemas, SystemTableNames };

package/dist/index.d.ts

@@ -1,66 +1,70 @@
-import { D as DynamoTable } from './table-tN3D4Tm-.js';
-export { I as InferSchema, T as TableFields, a as TableIndexes, b as TablePk, c as TableSk } from './table-tN3D4Tm-.js';
-import { S as SupportedSchema, I as IndexDefinition } from './types-ISMJfyIv.js';
-export { A as AnyDynamoTable, C as ConnectionEntry, b as DependencyEntry, D as DynamoTableConfig, F as FieldRef, a as FilterCondition, c as InferSupportedSchema, J as JsonPatch, d as QueryEntry, Q as QueryMetadata, e as SubscriptionMessage } from './types-ISMJfyIv.js';
+export { D as DynamoTable } from './table-BijJ73pX.js';
+import { a as FilterCondition } from './types-LMLk8JVC.js';
+export { A as AnyDynamoTable, C as ConnectionEntry, b as DependencyEntry, D as DynamoTableConfig, F as FieldRef, I as IndexDefinition, J as JsonPatch, P as PendingDelivery, c as QueryEntry, Q as QueryMetadata, S as SupportedSchema } from './types-LMLk8JVC.js';
 import { z } from 'zod';
 
-/**
- * Helper function to define a schema with type inference
- * This provides a cleaner API for defining tables
- *
- * Supports both ZodObject and ZodDiscriminatedUnion schemas.
- *
- * @example
- * ```ts
- * // Simple schema
- * const TodoTable = defineSchema({
- *   tableName: 'prod-todo-table',
- *   schema: z.object({
- *     id: z.string(),
- *     taskListId: z.string(),
- *     text: z.string(),
- *     isDone: z.boolean(),
- *   }),
- *   pk: 'id',
- *   indexes: {
- *     byTaskId: { name: 'gsi_by_task_id', pk: 'taskListId' }
- *   }
- * });
- *
- * // Discriminated union for single-table design
- * const MultiEntityTable = defineSchema({
- *   tableName: 'prod-entities',
- *   schema: z.discriminatedUnion('entityType', [
- *     z.object({ PK: z.string(), SK: z.string(), entityType: z.literal('USER'), name: z.string() }),
- *     z.object({ PK: z.string(), SK: z.string(), entityType: z.literal('ITEM'), title: z.string() }),
- *   ]),
- *   pk: 'PK',
- *   sk: 'SK',
- * });
- * ```
- */
-declare function defineSchema<TSchema extends SupportedSchema, TPk extends keyof z.infer<TSchema> & string, TSk extends (keyof z.infer<TSchema> & string) | undefined = undefined, TIndexes extends Record<string, IndexDefinition> = Record<string, IndexDefinition>>(config: {
-    tableName: string;
-    schema: TSchema;
-    pk: TPk;
-    sk?: TSk;
-    indexes?: TIndexes;
-}): DynamoTable<TSchema, TPk, TSk, TIndexes>;
+declare const FilterConditionSchema: z.ZodType<FilterCondition>;
+declare const QueryMetadataSchema: z.ZodObject<{
+    planVersion: z.ZodLiteral<1>;
+    tableName: z.ZodString;
+    indexName: z.ZodOptional<z.ZodString>;
+    indexPkField: z.ZodOptional<z.ZodString>;
+    indexSkField: z.ZodOptional<z.ZodString>;
+    filterConditions: z.ZodArray<z.ZodType<FilterCondition, unknown, z.core.$ZodTypeInternals<FilterCondition, unknown>>>;
+    sortField: z.ZodOptional<z.ZodString>;
+    sortOrder: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+declare const PendingDeliverySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    generation: z.ZodNumber;
+    fromVersion: z.ZodNumber;
+    toVersion: z.ZodNumber;
+    messageId: z.ZodString;
+    type: z.ZodLiteral<"patch">;
+    patches: z.ZodArray<z.ZodObject<{
+        op: z.ZodEnum<{
+            add: "add";
+            remove: "remove";
+            replace: "replace";
+            move: "move";
+            copy: "copy";
+            test: "test";
+        }>;
+        path: z.ZodString;
+        value: z.ZodOptional<z.ZodUnknown>;
+        from: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    generation: z.ZodNumber;
+    fromVersion: z.ZodNumber;
+    toVersion: z.ZodNumber;
+    messageId: z.ZodString;
+    type: z.ZodLiteral<"resync">;
+}, z.core.$strict>], "type">;
 /**
  * System table schemas for the reactive engine
  */
 declare const SystemSchemas: {
     /**
-     * ReactiveConnections - Tracks active WebSocket connections
+     * ReactiveConnectionsV2 - Tracks active WebSocket connections
      */
     connections: z.ZodObject<{
         connectionId: z.ZodString;
+        status: z.ZodEnum<{
+            open: "open";
+            closed: "closed";
+        }>;
         context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        authorizerContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        requestIdentity: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         connectedAt: z.ZodNumber;
         ttl: z.ZodNumber;
     }, z.core.$strip>;
     /**
-     * ReactiveDependencies - The inverted index for O(1) lookups
+     * ReactiveDependenciesV2 - The inverted index for O(1) lookups
      */
     dependencies: z.ZodObject<{
         pk: z.ZodString;
@@ -70,41 +74,84 @@ declare const SystemSchemas: {
         tableName: z.ZodString;
         fieldName: z.ZodString;
         fieldValue: z.ZodString;
+        generation: z.ZodNumber;
+        registrationId: z.ZodString;
         ttl: z.ZodNumber;
     }, z.core.$strip>;
     /**
-     * ReactiveConnectionQueries - Stores subscription state for diffing
+     * ReactiveConnectionQueriesV2 - Stores subscription state for diffing
      */
     queries: z.ZodObject<{
         pk: z.ZodString;
         sk: z.ZodString;
         connectionId: z.ZodString;
         subscriptionId: z.ZodString;
+        status: z.ZodEnum<{
+            registering: "registering";
+            active: "active";
+            cancelled: "cancelled";
+            faulted: "faulted";
+        }>;
+        generation: z.ZodNumber;
+        registrationId: z.ZodString;
         queryMetadata: z.ZodObject<{
+            planVersion: z.ZodLiteral<1>;
             tableName: z.ZodString;
             indexName: z.ZodOptional<z.ZodString>;
-            filterConditions: z.ZodArray<z.ZodUnknown>;
+            indexPkField: z.ZodOptional<z.ZodString>;
+            indexSkField: z.ZodOptional<z.ZodString>;
+            filterConditions: z.ZodArray<z.ZodType<FilterCondition, unknown, z.core.$ZodTypeInternals<FilterCondition, unknown>>>;
             sortField: z.ZodOptional<z.ZodString>;
             sortOrder: z.ZodOptional<z.ZodEnum<{
                 asc: "asc";
                 desc: "desc";
             }>>;
             limit: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>;
+        }, z.core.$strict>;
         lastResult: z.ZodArray<z.ZodUnknown>;
         dependencies: z.ZodArray<z.ZodString>;
+        version: z.ZodNumber;
+        pendingDelivery: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            generation: z.ZodNumber;
+            fromVersion: z.ZodNumber;
+            toVersion: z.ZodNumber;
+            messageId: z.ZodString;
+            type: z.ZodLiteral<"patch">;
+            patches: z.ZodArray<z.ZodObject<{
+                op: z.ZodEnum<{
+                    add: "add";
+                    remove: "remove";
+                    replace: "replace";
+                    move: "move";
+                    copy: "copy";
+                    test: "test";
+                }>;
+                path: z.ZodString;
+                value: z.ZodOptional<z.ZodUnknown>;
+                from: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            generation: z.ZodNumber;
+            fromVersion: z.ZodNumber;
+            toVersion: z.ZodNumber;
+            messageId: z.ZodString;
+            type: z.ZodLiteral<"resync">;
+        }, z.core.$strict>], "type">>;
         createdAt: z.ZodNumber;
         updatedAt: z.ZodNumber;
         ttl: z.ZodNumber;
     }, z.core.$strip>;
 };
+/** Storage/protocol generation used by all reactive system tables. */
+declare const SYSTEM_TABLE_PROTOCOL_VERSION: 2;
 /**
- * System table names
+ * Versioned system table names. The V2 suffix intentionally prevents state
+ * written by the incompatible 0.1.x dependency protocol from being reused.
  */
 declare const SystemTableNames: {
-    readonly connections: "ReactiveConnections";
-    readonly dependencies: "ReactiveDependencies";
-    readonly queries: "ReactiveConnectionQueries";
+    readonly connections: "ReactiveConnectionsV2";
+    readonly dependencies: "ReactiveDependenciesV2";
+    readonly queries: "ReactiveConnectionQueriesV2";
 };
 
-export { DynamoTable, IndexDefinition, SupportedSchema, SystemSchemas, SystemTableNames, defineSchema };
+export { FilterCondition, FilterConditionSchema, PendingDeliverySchema, QueryMetadataSchema, SYSTEM_TABLE_PROTOCOL_VERSION, SystemSchemas, SystemTableNames };

package/dist/index.js

@@ -1,3 +1,224 @@
-export { DynamoTable, SystemSchemas, SystemTableNames, defineSchema } from './chunk-ZAJA4KBE.js';
+import { z } from 'zod';
+
+// ../core/src/schema.ts
+var FilterConditionSchema = z.lazy(() => {
+  const comparison = z.object({
+    type: z.literal("comparison"),
+    operator: z.enum(["eq", "ne", "gt", "gte", "lt", "lte"]),
+    field: z.string().min(1),
+    value: z.unknown()
+  }).strict();
+  const queryFunction = z.union([
+    z.object({
+      type: z.literal("function"),
+      operator: z.literal("between"),
+      field: z.string().min(1),
+      value: z.unknown(),
+      value2: z.unknown()
+    }).strict(),
+    z.object({
+      type: z.literal("function"),
+      operator: z.enum(["beginsWith", "contains"]),
+      field: z.string().min(1),
+      value: z.unknown()
+    }).strict()
+  ]);
+  const logical = z.object({
+    type: z.literal("logical"),
+    operator: z.enum(["and", "or", "not"]),
+    conditions: z.array(FilterConditionSchema).min(1)
+  }).strict().superRefine((condition, context) => {
+    if (condition.operator === "not" && condition.conditions.length !== 1) {
+      context.addIssue({
+        code: "custom",
+        path: ["conditions"],
+        message: "not requires exactly one condition"
+      });
+    }
+  });
+  return z.union([comparison, queryFunction, logical]);
+});
+var QueryMetadataSchema = z.object({
+  planVersion: z.literal(1),
+  tableName: z.string().min(1),
+  indexName: z.string().min(1).optional(),
+  indexPkField: z.string().min(1).optional(),
+  indexSkField: z.string().min(1).optional(),
+  filterConditions: z.array(FilterConditionSchema),
+  sortField: z.string().min(1).optional(),
+  sortOrder: z.enum(["asc", "desc"]).optional(),
+  limit: z.number().int().positive().optional()
+}).strict().superRefine((metadata, context) => {
+  if (metadata.indexName && !metadata.indexPkField) {
+    context.addIssue({
+      code: "custom",
+      path: ["indexPkField"],
+      message: "Index metadata requires its partition key field"
+    });
+  }
+  if (!metadata.indexName && (metadata.indexPkField || metadata.indexSkField)) {
+    context.addIssue({
+      code: "custom",
+      path: ["indexName"],
+      message: "Index key fields require an index name"
+    });
+  }
+  if (Boolean(metadata.sortField) !== Boolean(metadata.sortOrder)) {
+    context.addIssue({
+      code: "custom",
+      path: ["sortOrder"],
+      message: "Sort field and order must be specified together"
+    });
+  }
+});
+var DeliveryVersionSchema = z.object({
+  generation: z.number().int().nonnegative(),
+  fromVersion: z.number().int().nonnegative(),
+  toVersion: z.number().int().positive(),
+  messageId: z.string().min(1)
+});
+var PendingDeliverySchema = z.discriminatedUnion("type", [
+  DeliveryVersionSchema.extend({
+    type: z.literal("patch"),
+    patches: z.array(
+      z.object({
+        op: z.enum(["add", "remove", "replace", "move", "copy", "test"]),
+        path: z.string(),
+        value: z.unknown().optional(),
+        from: z.string().optional()
+      })
+    )
+  }),
+  DeliveryVersionSchema.extend({
+    type: z.literal("resync")
+  }).strict()
+]);
+var SystemSchemas = {
+  /**
+   * ReactiveConnectionsV2 - Tracks active WebSocket connections
+   */
+  connections: z.object({
+    connectionId: z.string(),
+    status: z.enum(["open", "closed"]),
+    context: z.record(z.string(), z.unknown()).optional(),
+    authorizerContext: z.record(z.string(), z.unknown()).optional(),
+    requestIdentity: z.record(z.string(), z.unknown()).optional(),
+    connectedAt: z.number(),
+    ttl: z.number()
+  }),
+  /**
+   * ReactiveDependenciesV2 - The inverted index for O(1) lookups
+   */
+  dependencies: z.object({
+    pk: z.string(),
+    // Versioned encoded dependency key
+    sk: z.string(),
+    // ConnectionID#SubscriptionID
+    connectionId: z.string(),
+    subscriptionId: z.string(),
+    tableName: z.string(),
+    fieldName: z.string(),
+    fieldValue: z.string(),
+    generation: z.number().int().nonnegative(),
+    registrationId: z.string().min(1),
+    ttl: z.number()
+  }),
+  /**
+   * ReactiveConnectionQueriesV2 - Stores subscription state for diffing
+   */
+  queries: z.object({
+    pk: z.string(),
+    // ConnectionID
+    sk: z.string(),
+    // SubscriptionID
+    connectionId: z.string(),
+    subscriptionId: z.string(),
+    status: z.enum(["registering", "active", "cancelled", "faulted"]),
+    generation: z.number().int().nonnegative(),
+    registrationId: z.string().min(1),
+    queryMetadata: QueryMetadataSchema,
+    lastResult: z.array(z.unknown()),
+    dependencies: z.array(z.string()),
+    version: z.number().int().nonnegative(),
+    pendingDelivery: PendingDeliverySchema.optional(),
+    createdAt: z.number(),
+    updatedAt: z.number(),
+    ttl: z.number()
+  })
+};
+var SYSTEM_TABLE_PROTOCOL_VERSION = 2;
+var SystemTableNames = {
+  connections: "ReactiveConnectionsV2",
+  dependencies: "ReactiveDependenciesV2",
+  queries: "ReactiveConnectionQueriesV2"
+};
+
+// ../core/src/table.ts
+function getSchemaFields(schema) {
+  const fields = /* @__PURE__ */ new Set();
+  if ("options" in schema && Array.isArray(schema.options)) {
+    for (const option of schema.options) {
+      if ("shape" in option && typeof option.shape === "object") {
+        for (const key of Object.keys(option.shape)) {
+          fields.add(key);
+        }
+      }
+    }
+  } else if ("shape" in schema && typeof schema.shape === "object") {
+    for (const key of Object.keys(schema.shape)) {
+      fields.add(key);
+    }
+  }
+  return fields;
+}
+var DynamoTable = class {
+  tableName;
+  schema;
+  pk;
+  sk;
+  indexes;
+  field;
+  constructor(config) {
+    this.tableName = config.tableName;
+    this.schema = config.schema;
+    this.pk = config.pk;
+    this.sk = config.sk;
+    this.indexes = config.indexes ?? {};
+    this.field = this.createFieldRefs();
+  }
+  createFieldRefs() {
+    const fields = getSchemaFields(this.schema);
+    const refs = {};
+    for (const key of fields) {
+      refs[key] = {
+        fieldName: key,
+        _type: void 0
+      };
+    }
+    return refs;
+  }
+  /**
+   * Validate an item against the schema
+   */
+  validate(item) {
+    return this.schema.parse(item);
+  }
+  /**
+   * Safely validate an item, returning a result object
+   */
+  safeParse(item) {
+    return this.schema.safeParse(item);
+  }
+  /**
+   * Get the list of field names in the schema
+   */
+  getFieldNames() {
+    return Array.from(
+      getSchemaFields(this.schema)
+    );
+  }
+};
+
+export { DynamoTable, FilterConditionSchema, PendingDeliverySchema, QueryMetadataSchema, SYSTEM_TABLE_PROTOCOL_VERSION, SystemSchemas, SystemTableNames };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}
+{"version":3,"sources":["../../core/src/schema.ts","../../core/src/table.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["import { z } from 'zod';\n\nimport type { FilterCondition } from './types.js';\n\nexport const FilterConditionSchema: z.ZodType<FilterCondition> = z.lazy(() => {\n  const comparison = z\n    .object({\n      type: z.literal('comparison'),\n      operator: z.enum(['eq', 'ne', 'gt', 'gte', 'lt', 'lte']),\n      field: z.string().min(1),\n      value: z.unknown(),\n    })\n    .strict();\n  const queryFunction = z.union([\n    z\n      .object({\n        type: z.literal('function'),\n        operator: z.literal('between'),\n        field: z.string().min(1),\n        value: z.unknown(),\n        value2: z.unknown(),\n      })\n      .strict(),\n    z\n      .object({\n        type: z.literal('function'),\n        operator: z.enum(['beginsWith', 'contains']),\n        field: z.string().min(1),\n        value: z.unknown(),\n      })\n      .strict(),\n  ]);\n  const logical = z\n    .object({\n      type: z.literal('logical'),\n      operator: z.enum(['and', 'or', 'not']),\n      conditions: z.array(FilterConditionSchema).min(1),\n    })\n    .strict()\n    .superRefine((condition, context) => {\n      if (condition.operator === 'not' && condition.conditions.length !== 1) {\n        context.addIssue({\n          code: 'custom',\n          path: ['conditions'],\n          message: 'not requires exactly one condition',\n        });\n      }\n    });\n  return z.union([comparison, queryFunction, logical]);\n});\n\nexport const QueryMetadataSchema = z\n  .object({\n    planVersion: z.literal(1),\n    tableName: z.string().min(1),\n    indexName: z.string().min(1).optional(),\n    indexPkField: z.string().min(1).optional(),\n    indexSkField: z.string().min(1).optional(),\n    filterConditions: z.array(FilterConditionSchema),\n    sortField: z.string().min(1).optional(),\n    sortOrder: z.enum(['asc', 'desc']).optional(),\n    limit: z.number().int().positive().optional(),\n  })\n  .strict()\n  .superRefine((metadata, context) => {\n    if (metadata.indexName && !metadata.indexPkField) {\n      context.addIssue({\n        code: 'custom',\n        path: ['indexPkField'],\n        message: 'Index metadata requires its partition key field',\n      });\n    }\n    if (!metadata.indexName && (metadata.indexPkField || metadata.indexSkField)) {\n      context.addIssue({\n        code: 'custom',\n        path: ['indexName'],\n        message: 'Index key fields require an index name',\n      });\n    }\n    if (Boolean(metadata.sortField) !== Boolean(metadata.sortOrder)) {\n      context.addIssue({\n        code: 'custom',\n        path: ['sortOrder'],\n        message: 'Sort field and order must be specified together',\n      });\n    }\n  });\n\nconst DeliveryVersionSchema = z.object({\n  generation: z.number().int().nonnegative(),\n  fromVersion: z.number().int().nonnegative(),\n  toVersion: z.number().int().positive(),\n  messageId: z.string().min(1),\n});\n\nexport const PendingDeliverySchema = z.discriminatedUnion('type', [\n  DeliveryVersionSchema.extend({\n    type: z.literal('patch'),\n    patches: z.array(\n      z.object({\n        op: z.enum(['add', 'remove', 'replace', 'move', 'copy', 'test']),\n        path: z.string(),\n        value: z.unknown().optional(),\n        from: z.string().optional(),\n      }),\n    ),\n  }),\n  DeliveryVersionSchema.extend({\n    type: z.literal('resync'),\n  }).strict(),\n]);\n\n/**\n * System table schemas for the reactive engine\n */\nexport const SystemSchemas = {\n  /**\n   * ReactiveConnectionsV2 - Tracks active WebSocket connections\n   */\n  connections: z.object({\n    connectionId: z.string(),\n    status: z.enum(['open', 'closed']),\n    context: z.record(z.string(), z.unknown()).optional(),\n    authorizerContext: z.record(z.string(), z.unknown()).optional(),\n    requestIdentity: z.record(z.string(), z.unknown()).optional(),\n    connectedAt: z.number(),\n    ttl: z.number(),\n  }),\n\n  /**\n   * ReactiveDependenciesV2 - The inverted index for O(1) lookups\n   */\n  dependencies: z.object({\n    pk: z.string(), // Versioned encoded dependency key\n    sk: z.string(), // ConnectionID#SubscriptionID\n    connectionId: z.string(),\n    subscriptionId: z.string(),\n    tableName: z.string(),\n    fieldName: z.string(),\n    fieldValue: z.string(),\n    generation: z.number().int().nonnegative(),\n    registrationId: z.string().min(1),\n    ttl: z.number(),\n  }),\n\n  /**\n   * ReactiveConnectionQueriesV2 - Stores subscription state for diffing\n   */\n  queries: z.object({\n    pk: z.string(), // ConnectionID\n    sk: z.string(), // SubscriptionID\n    connectionId: z.string(),\n    subscriptionId: z.string(),\n    status: z.enum(['registering', 'active', 'cancelled', 'faulted']),\n    generation: z.number().int().nonnegative(),\n    registrationId: z.string().min(1),\n    queryMetadata: QueryMetadataSchema,\n    lastResult: z.array(z.unknown()),\n    dependencies: z.array(z.string()),\n    version: z.number().int().nonnegative(),\n    pendingDelivery: PendingDeliverySchema.optional(),\n    createdAt: z.number(),\n    updatedAt: z.number(),\n    ttl: z.number(),\n  }),\n};\n\n/** Storage/protocol generation used by all reactive system tables. */\nexport const SYSTEM_TABLE_PROTOCOL_VERSION = 2 as const;\n\n/**\n * Versioned system table names. The V2 suffix intentionally prevents state\n * written by the incompatible 0.1.x dependency protocol from being reused.\n */\nexport const SystemTableNames = {\n  connections: 'ReactiveConnectionsV2',\n  dependencies: 'ReactiveDependenciesV2',\n  queries: 'ReactiveConnectionQueriesV2',\n} as const;\n","import type { z } from 'zod';\n\nimport type {\n  DynamoTableConfig,\n  FieldRef,\n  IndexDefinition,\n  SupportedSchema,\n} from './types.js';\n\n/**\n * Extract all field names from a schema (handles both ZodObject and ZodDiscriminatedUnion)\n */\nfunction getSchemaFields(schema: SupportedSchema): Set<string> {\n  const fields = new Set<string>();\n\n  // Check if it's a discriminated union by looking for 'options' property\n  if ('options' in schema && Array.isArray(schema.options)) {\n    // It's a discriminated union - collect fields from all options\n    for (const option of schema.options) {\n      if ('shape' in option && typeof option.shape === 'object') {\n        for (const key of Object.keys(option.shape)) {\n          fields.add(key);\n        }\n      }\n    }\n  } else if ('shape' in schema && typeof schema.shape === 'object') {\n    // It's a regular ZodObject\n    for (const key of Object.keys(schema.shape)) {\n      fields.add(key);\n    }\n  }\n\n  return fields;\n}\n\n/**\n * Creates field references for type-safe query building\n */\ntype FieldRefs<TSchema extends SupportedSchema> = {\n  [K in keyof z.infer<TSchema>]: FieldRef<K & string, z.infer<TSchema>[K]>;\n};\n\n/**\n * DynamoTable - Defines a DynamoDB table with type-safe schema\n *\n * Supports both ZodObject and ZodDiscriminatedUnion schemas for single-table design patterns.\n *\n * @example\n * ```ts\n * // Simple schema\n * const TodoTable = new DynamoTable({\n *   tableName: 'prod-todo-table',\n *   schema: z.object({\n *     PK: z.string(),\n *     SK: z.string(),\n *     text: z.string(),\n *     isDone: z.boolean(),\n *   }),\n *   pk: 'PK',\n *   sk: 'SK',\n * });\n *\n * // Discriminated union for single-table design\n * const MultiEntityTable = new DynamoTable({\n *   tableName: 'prod-entities',\n *   schema: z.discriminatedUnion('entityType', [\n *     z.object({ PK: z.string(), SK: z.string(), entityType: z.literal('USER'), name: z.string() }),\n *     z.object({ PK: z.string(), SK: z.string(), entityType: z.literal('ITEM'), title: z.string() }),\n *   ]),\n *   pk: 'PK',\n *   sk: 'SK',\n * });\n * ```\n */\nexport class DynamoTable<\n  TSchema extends SupportedSchema,\n  TPk extends keyof z.infer<TSchema>,\n  TSk extends keyof z.infer<TSchema> | undefined = undefined,\n  TIndexes extends Record<string, IndexDefinition> = Record<\n    string,\n    IndexDefinition\n  >,\n> {\n  public readonly tableName: string;\n  public readonly schema: TSchema;\n  public readonly pk: TPk;\n  public readonly sk: TSk;\n  public readonly indexes: TIndexes;\n  public readonly field: FieldRefs<TSchema>;\n\n  constructor(config: DynamoTableConfig<TSchema, TPk, TSk, TIndexes>) {\n    this.tableName = config.tableName;\n    this.schema = config.schema;\n    this.pk = config.pk;\n    this.sk = config.sk as TSk;\n    this.indexes = (config.indexes ?? {}) as TIndexes;\n\n    // Create field references for query building\n    this.field = this.createFieldRefs();\n  }\n\n  private createFieldRefs(): FieldRefs<TSchema> {\n    const fields = getSchemaFields(this.schema);\n    const refs: Record<string, FieldRef<string, unknown>> = {};\n\n    for (const key of fields) {\n      refs[key] = {\n        fieldName: key,\n        _type: undefined as unknown,\n      };\n    }\n\n    return refs as FieldRefs<TSchema>;\n  }\n\n  /**\n   * Validate an item against the schema\n   */\n  validate(item: unknown): z.infer<TSchema> {\n    return this.schema.parse(item) as z.infer<TSchema>;\n  }\n\n  /**\n   * Safely validate an item, returning a result object\n   */\n  safeParse(item: unknown): z.ZodSafeParseResult<z.infer<TSchema>> {\n    return this.schema.safeParse(item) as z.ZodSafeParseResult<\n      z.infer<TSchema>\n    >;\n  }\n\n  /**\n   * Get the list of field names in the schema\n   */\n  getFieldNames(): (keyof z.infer<TSchema>)[] {\n    return Array.from(\n      getSchemaFields(this.schema),\n    ) as (keyof z.infer<TSchema>)[];\n  }\n\n}\n"]}