dynamodb-reactive 0.1.0 → 0.1.1

package/dist/server.js

@@ -1,18 +1,1689 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+import { SystemTableNames } from './chunk-HZ6JHAJJ.js';
+import { DynamoDBClient, ExecuteStatementCommand } from '@aws-sdk/client-dynamodb';
+import { UpdateCommand, DeleteCommand, PutCommand, GetCommand, DynamoDBDocumentClient, QueryCommand } from '@aws-sdk/lib-dynamodb';
+import { unmarshall } from '@aws-sdk/util-dynamodb';
+import { compare, applyPatch } from 'fast-json-patch';
+import { ApiGatewayManagementApiClient, PostToConnectionCommand, GoneException } from '@aws-sdk/client-apigatewaymanagementapi';
+
+// ../server/src/procedure.ts
+var ProcedureBuilder = class _ProcedureBuilder {
+  inputSchema;
+  constructor(inputSchema) {
+    this.inputSchema = inputSchema;
+  }
+  /**
+   * Define the input schema for the procedure
+   */
+  input(schema) {
+    return new _ProcedureBuilder(schema);
+  }
+  /**
+   * Define a query procedure (read-only operation)
+   */
+  query(resolver) {
+    return {
+      type: "query",
+      inputSchema: this.inputSchema,
+      resolver
+    };
+  }
+  /**
+   * Define a mutation procedure (write operation)
+   */
+  mutation(resolver) {
+    return {
+      type: "mutation",
+      inputSchema: this.inputSchema,
+      resolver
+    };
+  }
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("@dynamodb-reactive/server"), exports);
+function isProcedure(value) {
+  return typeof value === "object" && value !== null && "type" in value && "resolver" in value && (value.type === "query" || value.type === "mutation");
+}
+async function executeProcedure(procedure, ctx, rawInput) {
+  let input;
+  if (procedure.inputSchema) {
+    const parseResult = procedure.inputSchema.safeParse(rawInput);
+    if (!parseResult.success) {
+      throw new Error(`Invalid input: ${parseResult.error.message}`);
+    }
+    input = parseResult.data;
+  } else {
+    input = rawInput;
+  }
+  return procedure.resolver({ ctx, input });
+}
+
+// ../server/src/router.ts
+var Router = class {
+  definition;
+  constructor(definition) {
+    this.definition = definition;
+  }
+  /**
+   * Get a procedure by its path (e.g., "todos.list")
+   */
+  getProcedure(path) {
+    const parts = path.split(".");
+    let current = this.definition;
+    for (const part of parts) {
+      if (typeof current !== "object" || current === null) {
+        return null;
+      }
+      current = current[part];
+    }
+    if (isProcedure(current)) {
+      return current;
+    }
+    return null;
+  }
+  /**
+   * Execute a procedure by its path
+   */
+  async execute(path, ctx, input) {
+    const procedure = this.getProcedure(path);
+    if (!procedure) {
+      throw new Error(`Procedure not found: ${path}`);
+    }
+    return executeProcedure(procedure, ctx, input);
+  }
+  /**
+   * Get all procedure paths in the router
+   */
+  getProcedurePaths() {
+    const paths = [];
+    function traverse(obj, prefix) {
+      if (typeof obj !== "object" || obj === null) return;
+      for (const [key, value] of Object.entries(obj)) {
+        const path = prefix ? `${prefix}.${key}` : key;
+        if (isProcedure(value)) {
+          paths.push(path);
+        } else {
+          traverse(value, path);
+        }
+      }
+    }
+    traverse(this.definition, "");
+    return paths;
+  }
+  /**
+   * Check if a path is a query procedure
+   */
+  isQuery(path) {
+    const procedure = this.getProcedure(path);
+    return procedure?.type === "query";
+  }
+  /**
+   * Check if a path is a mutation procedure
+   */
+  isMutation(path) {
+    const procedure = this.getProcedure(path);
+    return procedure?.type === "mutation";
+  }
+};
+function createRouter(definition) {
+  return new Router(definition);
+}
+function mergeRouters(...routers) {
+  const merged = {};
+  for (const router of routers) {
+    Object.assign(merged, router.definition);
+  }
+  return new Router(merged);
+}
+
+// ../server/src/reactive.ts
+function initReactive() {
+  return {
+    procedure: new ProcedureBuilder(),
+    router(definition) {
+      return createRouter(definition);
+    }
+  };
+}
+
+// ../server/src/partiql-builder.ts
+function conditionToPartiQL(condition, parameters) {
+  switch (condition.type) {
+    case "comparison": {
+      parameters.push(condition.value);
+      return `"${condition.field}" ${condition.operator} ?`;
+    }
+    case "function": {
+      if (condition.operator === "BETWEEN") {
+        parameters.push(condition.value);
+        parameters.push(condition.value2);
+        return `"${condition.field}" BETWEEN ? AND ?`;
+      }
+      if (condition.operator === "begins_with") {
+        parameters.push(condition.value);
+        return `begins_with("${condition.field}", ?)`;
+      }
+      if (condition.operator === "contains") {
+        parameters.push(condition.value);
+        return `contains("${condition.field}", ?)`;
+      }
+      throw new Error(`Unknown function operator: ${condition.operator}`);
+    }
+    case "logical": {
+      if (!condition.conditions || condition.conditions.length === 0) {
+        throw new Error(
+          "Logical condition requires at least one sub-condition"
+        );
+      }
+      if (condition.operator === "NOT") {
+        const subClause = conditionToPartiQL(
+          condition.conditions[0],
+          parameters
+        );
+        return `NOT (${subClause})`;
+      }
+      const subClauses = condition.conditions.map(
+        (c) => conditionToPartiQL(c, parameters)
+      );
+      return `(${subClauses.join(` ${condition.operator} `)})`;
+    }
+    default:
+      throw new Error(`Unknown condition type: ${condition.type}`);
+  }
+}
+function buildSelectStatement(operation) {
+  const parameters = [];
+  let statement = `SELECT * FROM "${operation.tableName}"`;
+  if (operation.indexName) {
+    statement += `."${operation.indexName}"`;
+  }
+  if (operation.filters.length > 0) {
+    const whereClauses = operation.filters.map(
+      (f) => conditionToPartiQL(f, parameters)
+    );
+    statement += ` WHERE ${whereClauses.join(" AND ")}`;
+  }
+  return { statement, parameters };
+}
+function buildInsertStatement(tableName, item) {
+  const parameters = [item];
+  const statement = `INSERT INTO "${tableName}" VALUE ?`;
+  return { statement, parameters };
+}
+function buildUpdateStatement(tableName, key, updates) {
+  const parameters = [];
+  const setClauses = [];
+  for (const [field, value] of Object.entries(updates)) {
+    if (field in key) continue;
+    setClauses.push(`"${field}" = ?`);
+    parameters.push(value);
+  }
+  if (setClauses.length === 0) {
+    throw new Error("No fields to update");
+  }
+  let statement = `UPDATE "${tableName}" SET ${setClauses.join(", ")}`;
+  const whereClauses = Object.entries(key).map(([field, value]) => {
+    parameters.push(value);
+    return `"${field}" = ?`;
+  });
+  statement += ` WHERE ${whereClauses.join(" AND ")}`;
+  return { statement, parameters };
+}
+function buildDeleteStatement(tableName, key) {
+  const parameters = [];
+  const whereClauses = Object.entries(key).map(([field, value]) => {
+    parameters.push(value);
+    return `"${field}" = ?`;
+  });
+  const statement = `DELETE FROM "${tableName}" WHERE ${whereClauses.join(" AND ")}`;
+  return { statement, parameters };
+}
+function buildGetStatement(tableName, key) {
+  const parameters = [];
+  const whereClauses = Object.entries(key).map(([field, value]) => {
+    parameters.push(value);
+    return `"${field}" = ?`;
+  });
+  const statement = `SELECT * FROM "${tableName}" WHERE ${whereClauses.join(" AND ")}`;
+  return { statement, parameters };
+}
+
+// ../server/src/query-builder.ts
+function createCondition(type, operator, field, value, value2) {
+  return { type, operator, field, value, value2 };
+}
+var FilterBuilderImpl = class {
+  eq(field, value) {
+    return createCondition("comparison", "=", field.fieldName, value);
+  }
+  ne(field, value) {
+    return createCondition("comparison", "<>", field.fieldName, value);
+  }
+  gt(field, value) {
+    return createCondition("comparison", ">", field.fieldName, value);
+  }
+  gte(field, value) {
+    return createCondition("comparison", ">=", field.fieldName, value);
+  }
+  lt(field, value) {
+    return createCondition("comparison", "<", field.fieldName, value);
+  }
+  lte(field, value) {
+    return createCondition("comparison", "<=", field.fieldName, value);
+  }
+  between(field, lower, upper) {
+    return createCondition(
+      "function",
+      "BETWEEN",
+      field.fieldName,
+      lower,
+      upper
+    );
+  }
+  beginsWith(field, prefix) {
+    return createCondition("function", "begins_with", field.fieldName, prefix);
+  }
+  contains(field, substring) {
+    return createCondition("function", "contains", field.fieldName, substring);
+  }
+  and(...conditions) {
+    return { type: "logical", operator: "AND", conditions };
+  }
+  or(...conditions) {
+    return { type: "logical", operator: "OR", conditions };
+  }
+  not(condition) {
+    return { type: "logical", operator: "NOT", conditions: [condition] };
+  }
+};
+var QueryBuilderImpl = class {
+  table;
+  filters = [];
+  indexName;
+  limit;
+  startKey;
+  ascending = true;
+  executor;
+  operationTracker;
+  constructor(table, executor, operationTracker) {
+    this.table = table;
+    this.executor = executor;
+    this.operationTracker = operationTracker;
+  }
+  filter(fn) {
+    const builder = new FilterBuilderImpl();
+    const condition = fn(builder);
+    this.filters.push(condition);
+    return this;
+  }
+  useIndex(indexName) {
+    this.indexName = indexName;
+    return this;
+  }
+  take(limit) {
+    this.limit = limit;
+    return this;
+  }
+  startFrom(key) {
+    this.startKey = key;
+    return this;
+  }
+  sortAscending() {
+    this.ascending = true;
+    return this;
+  }
+  sortDescending() {
+    this.ascending = false;
+    return this;
+  }
+  async execute() {
+    const operation = {
+      tableName: this.table.tableName,
+      filters: this.filters,
+      indexName: this.indexName,
+      pkField: this.table.pk,
+      skField: this.table.sk,
+      sortField: this.table.sk,
+      // Default sort by SK if available
+      sortOrder: this.ascending ? "asc" : "desc",
+      limit: this.limit
+    };
+    if (this.operationTracker) {
+      this.operationTracker(operation);
+    }
+    const options = {
+      limit: this.limit,
+      startKey: this.startKey,
+      ascending: this.ascending
+    };
+    return this.executor(operation, options);
+  }
+  /**
+   * Get the current operation without executing
+   * Used for dependency extraction
+   */
+  getOperation() {
+    return {
+      tableName: this.table.tableName,
+      filters: this.filters,
+      indexName: this.indexName,
+      pkField: this.table.pk,
+      skField: this.table.sk,
+      sortField: this.table.sk,
+      sortOrder: this.ascending ? "asc" : "desc",
+      limit: this.limit
+    };
+  }
+};
+function createFilterBuilder() {
+  return new FilterBuilderImpl();
+}
+
+// ../server/src/db-context.ts
+function createDocClient(config) {
+  const client = config.client ?? new DynamoDBClient({
+    region: config.region ?? process.env.AWS_REGION ?? "us-east-1",
+    endpoint: config.endpoint
+  });
+  return DynamoDBDocumentClient.from(client, {
+    marshallOptions: {
+      removeUndefinedValues: true,
+      convertEmptyValues: false
+    },
+    unmarshallOptions: {
+      wrapNumbers: false
+    }
+  });
+}
+function toAttributeValue(value) {
+  if (typeof value === "string") return { S: value };
+  if (typeof value === "number") return { N: String(value) };
+  if (typeof value === "boolean") return { BOOL: value };
+  if (value === null || value === void 0) return { NULL: true };
+  if (Array.isArray(value)) {
+    return { L: value.map(toAttributeValue) };
+  }
+  if (typeof value === "object") {
+    const m = {};
+    for (const [k, v] of Object.entries(value)) {
+      m[k] = toAttributeValue(v);
+    }
+    return { M: m };
+  }
+  return { S: String(value) };
+}
+async function executePartiQL(docClient, statement) {
+  const command = new ExecuteStatementCommand({
+    Statement: statement.statement,
+    Parameters: statement.parameters.map(toAttributeValue)
+  });
+  const response = await docClient.send(command);
+  return (response.Items ?? []).map(
+    (item) => unmarshall(item)
+  );
+}
+function createDbContext(config, dependencyTracker) {
+  const docClient = createDocClient(config);
+  async function executeQuery(operation, options) {
+    const statement = buildSelectStatement(operation);
+    const items = await executePartiQL(docClient, statement);
+    if (options.limit && items.length > options.limit) {
+      return items.slice(0, options.limit);
+    }
+    return items;
+  }
+  return {
+    query(table) {
+      return new QueryBuilderImpl(
+        table,
+        executeQuery,
+        dependencyTracker?.track.bind(dependencyTracker)
+      );
+    },
+    async get(table, key) {
+      const command = new GetCommand({
+        TableName: table.tableName,
+        Key: key
+      });
+      const response = await docClient.send(command);
+      return response.Item ?? null;
+    },
+    async put(table, item) {
+      table.validate(item);
+      const command = new PutCommand({
+        TableName: table.tableName,
+        Item: item
+      });
+      await docClient.send(command);
+    },
+    async delete(table, key) {
+      const command = new DeleteCommand({
+        TableName: table.tableName,
+        Key: key
+      });
+      await docClient.send(command);
+    },
+    async update(table, key, updates) {
+      const updateExpressions = [];
+      const expressionAttributeNames = {};
+      const expressionAttributeValues = {};
+      let i = 0;
+      for (const [field, value] of Object.entries(updates)) {
+        if (field in key) continue;
+        const nameKey = `#f${i}`;
+        const valueKey = `:v${i}`;
+        updateExpressions.push(`${nameKey} = ${valueKey}`);
+        expressionAttributeNames[nameKey] = field;
+        expressionAttributeValues[valueKey] = value;
+        i++;
+      }
+      if (updateExpressions.length === 0) {
+        const current = await this.get(table, key);
+        if (!current) {
+          throw new Error("Item not found");
+        }
+        return current;
+      }
+      const command = new UpdateCommand({
+        TableName: table.tableName,
+        Key: key,
+        UpdateExpression: `SET ${updateExpressions.join(", ")}`,
+        ExpressionAttributeNames: expressionAttributeNames,
+        ExpressionAttributeValues: expressionAttributeValues,
+        ReturnValues: "ALL_NEW"
+      });
+      const response = await docClient.send(command);
+      return response.Attributes;
+    }
+  };
+}
+
+// ../server/src/dependency-extractor.ts
+function extractFromCondition(tableName, condition, indexName) {
+  const dependencies = [];
+  switch (condition.type) {
+    case "comparison": {
+      if (condition.operator === "=" && condition.field && condition.value !== void 0) {
+        dependencies.push({
+          tableName,
+          fieldName: condition.field,
+          fieldValue: String(condition.value),
+          indexName
+        });
+      }
+      break;
+    }
+    case "function": {
+      if (condition.operator === "begins_with" && condition.field && condition.value) {
+        dependencies.push({
+          tableName,
+          fieldName: condition.field,
+          fieldValue: `prefix:${String(condition.value)}`,
+          indexName
+        });
+      }
+      break;
+    }
+    case "logical": {
+      if (condition.conditions) {
+        for (const subCondition of condition.conditions) {
+          dependencies.push(
+            ...extractFromCondition(tableName, subCondition, indexName)
+          );
+        }
+      }
+      break;
+    }
+  }
+  return dependencies;
+}
+function extractDependencies(operation) {
+  const dependencies = [];
+  for (const filter of operation.filters) {
+    dependencies.push(
+      ...extractFromCondition(operation.tableName, filter, operation.indexName)
+    );
+  }
+  return dependencies;
+}
+function createDependencyKey(dependency) {
+  return `${dependency.tableName}#${dependency.fieldName}#${dependency.fieldValue}`;
+}
+function parseDependencyKey(key) {
+  const parts = key.split("#");
+  if (parts.length < 3) return null;
+  return {
+    tableName: parts[0],
+    fieldName: parts[1],
+    fieldValue: parts.slice(2).join("#")
+    // Handle values that contain #
+  };
+}
+function extractAffectedKeys(tableName, item) {
+  const keys = [];
+  for (const [fieldName, fieldValue] of Object.entries(item)) {
+    if (fieldValue !== null && fieldValue !== void 0) {
+      keys.push(`${tableName}#${fieldName}#${String(fieldValue)}`);
+      if (typeof fieldValue === "string") {
+        for (let i = 1; i <= fieldValue.length; i++) {
+          keys.push(
+            `${tableName}#${fieldName}#prefix:${fieldValue.substring(0, i)}`
+          );
+        }
+      }
+    }
+  }
+  return keys;
+}
+function operationToQueryMetadata(operation) {
+  const normalizeFilters = (filters) => {
+    return filters.map((f) => normalizeFilter(f));
+  };
+  const normalizeFilter = (filter) => {
+    if (filter.type === "comparison") {
+      const operatorMap = {
+        "=": "eq",
+        "<>": "ne",
+        ">": "gt",
+        ">=": "gte",
+        "<": "lt",
+        "<=": "lte"
+      };
+      return {
+        ...filter,
+        operator: operatorMap[filter.operator ?? ""] ?? filter.operator
+      };
+    }
+    if (filter.type === "function") {
+      const operatorMap = {
+        begins_with: "beginsWith",
+        BETWEEN: "between"
+      };
+      return {
+        ...filter,
+        operator: operatorMap[filter.operator ?? ""] ?? filter.operator
+      };
+    }
+    if (filter.type === "logical" && filter.conditions) {
+      const operatorMap = {
+        AND: "and",
+        OR: "or",
+        NOT: "not"
+      };
+      return {
+        ...filter,
+        operator: operatorMap[filter.operator ?? ""] ?? filter.operator,
+        conditions: normalizeFilters(filter.conditions)
+      };
+    }
+    return filter;
+  };
+  return {
+    tableName: operation.tableName,
+    indexName: operation.indexName,
+    filterConditions: normalizeFilters(operation.filters),
+    sortField: operation.sortField,
+    sortOrder: operation.sortOrder,
+    limit: operation.limit
+  };
+}
+var DependencyTracker = class {
+  operations = [];
+  /**
+   * Track a query operation
+   */
+  track(operation) {
+    this.operations.push(operation);
+  }
+  /**
+   * Get all tracked operations
+   */
+  getOperations() {
+    return [...this.operations];
+  }
+  /**
+   * Extract all dependencies from tracked operations
+   */
+  extractAll() {
+    const dependencies = [];
+    for (const operation of this.operations) {
+      dependencies.push(...extractDependencies(operation));
+    }
+    return dependencies;
+  }
+  /**
+   * Get all dependency keys for the inverted index
+   */
+  getDependencyKeys() {
+    return this.extractAll().map(createDependencyKey);
+  }
+  /**
+   * Get query metadata for the first tracked operation.
+   * Used for storing subscription state.
+   */
+  getQueryMetadata() {
+    if (this.operations.length === 0) return null;
+    return operationToQueryMetadata(this.operations[0]);
+  }
+  /**
+   * Get the primary key field from the first operation
+   */
+  getPkField() {
+    if (this.operations.length === 0) return null;
+    return this.operations[0].pkField;
+  }
+  /**
+   * Get the sort key field from the first operation
+   */
+  getSkField() {
+    if (this.operations.length === 0) return void 0;
+    return this.operations[0].skField;
+  }
+  /**
+   * Clear tracked operations
+   */
+  clear() {
+    this.operations = [];
+  }
+};
+function generatePatches(oldValue, newValue) {
+  const operations = compare(
+    oldValue,
+    newValue
+  );
+  return operations.map((op) => ({
+    op: op.op,
+    path: op.path,
+    value: "value" in op ? op.value : void 0,
+    from: "from" in op ? op.from : void 0
+  }));
+}
+function applyPatches(document, patches) {
+  const operations = patches.map((patch) => {
+    const op = {
+      op: patch.op,
+      path: patch.path
+    };
+    if ("value" in patch && patch.value !== void 0) {
+      op.value = patch.value;
+    }
+    if ("from" in patch && patch.from !== void 0) {
+      op.from = patch.from;
+    }
+    return op;
+  });
+  const result = applyPatch(
+    structuredClone(document),
+    operations,
+    true,
+    // Validate operations
+    false
+    // Don't mutate the original
+  );
+  return result.newDocument;
+}
+function hasChanges(oldValue, newValue) {
+  const patches = generatePatches(oldValue, newValue);
+  return patches.length > 0;
+}
+function optimizePatches(patches) {
+  const seen = /* @__PURE__ */ new Set();
+  const optimized = [];
+  for (let i = patches.length - 1; i >= 0; i--) {
+    const patch = patches[i];
+    if (!seen.has(patch.path)) {
+      seen.add(patch.path);
+      optimized.unshift(patch);
+    }
+  }
+  return optimized;
+}
+function batchPatches(patchSets) {
+  const allPatches = patchSets.flat();
+  return optimizePatches(allPatches);
+}
+function createReactiveHandler(config) {
+  const ttlSeconds = config.ttlSeconds ?? 3600;
+  const connectionsTable = config.connectionsTableName ?? SystemTableNames.connections;
+  const dependenciesTable = config.dependenciesTableName ?? SystemTableNames.dependencies;
+  const queriesTable = config.queriesTableName ?? SystemTableNames.queries;
+  const ddbClient = new DynamoDBClient({
+    region: config.dbConfig?.region ?? process.env.AWS_REGION
+  });
+  const docClient = DynamoDBDocumentClient.from(ddbClient);
+  async function handleRequest(connectionId, request) {
+    try {
+      const ctx = await config.getContext(connectionId);
+      const dependencyTracker = new DependencyTracker();
+      const db = createDbContext(config.dbConfig ?? {}, dependencyTracker);
+      const fullCtx = { ...ctx, db };
+      switch (request.type) {
+        case "subscribe":
+          return handleSubscribe(
+            connectionId,
+            request,
+            fullCtx,
+            dependencyTracker
+          );
+        case "unsubscribe":
+          return handleUnsubscribe(connectionId, request);
+        case "call":
+          return handleCall(request, fullCtx);
+        default:
+          return {
+            type: "error",
+            message: `Unknown request type: ${request.type}`
+          };
+      }
+    } catch (error) {
+      return {
+        type: "error",
+        message: error instanceof Error ? error.message : "Unknown error",
+        subscriptionId: "subscriptionId" in request ? request.subscriptionId : void 0
+      };
+    }
+  }
+  async function handleSubscribe(connectionId, request, ctx, dependencyTracker) {
+    const result = await config.router.execute(
+      request.path,
+      ctx,
+      request.input
+    );
+    const queryMetadata = dependencyTracker.getQueryMetadata();
+    const dependencyKeys = dependencyTracker.getDependencyKeys();
+    if (!queryMetadata) {
+      console.warn("No query metadata captured for subscription");
+    }
+    const now = Date.now();
+    const ttl = Math.floor(now / 1e3) + ttlSeconds;
+    const queryEntry = {
+      pk: connectionId,
+      sk: request.subscriptionId,
+      connectionId,
+      subscriptionId: request.subscriptionId,
+      queryMetadata: queryMetadata ?? {
+        tableName: "",
+        filterConditions: []
+      },
+      lastResult: Array.isArray(result) ? result : [result],
+      dependencies: dependencyKeys,
+      createdAt: now,
+      updatedAt: now,
+      ttl
+    };
+    await docClient.send(
+      new PutCommand({
+        TableName: queriesTable,
+        Item: queryEntry
+      })
+    );
+    for (const key of dependencyKeys) {
+      await docClient.send(
+        new PutCommand({
+          TableName: dependenciesTable,
+          Item: {
+            pk: key,
+            sk: `${connectionId}#${request.subscriptionId}`,
+            connectionId,
+            subscriptionId: request.subscriptionId,
+            ttl
+          }
+        })
+      );
+    }
+    console.log("Subscription created:", {
+      connectionId,
+      subscriptionId: request.subscriptionId,
+      queryMetadata: queryMetadata?.tableName,
+      dependencies: dependencyKeys
+    });
+    return {
+      type: "snapshot",
+      subscriptionId: request.subscriptionId,
+      data: result
+    };
+  }
+  async function handleUnsubscribe(connectionId, request) {
+    const subResponse = await docClient.send(
+      new GetCommand({
+        TableName: queriesTable,
+        Key: { pk: connectionId, sk: request.subscriptionId }
+      })
+    );
+    if (subResponse.Item) {
+      const queryEntry = subResponse.Item;
+      for (const key of queryEntry.dependencies ?? []) {
+        await docClient.send(
+          new DeleteCommand({
+            TableName: dependenciesTable,
+            Key: { pk: key, sk: `${connectionId}#${request.subscriptionId}` }
+          })
+        );
+      }
+    }
+    await docClient.send(
+      new DeleteCommand({
+        TableName: queriesTable,
+        Key: { pk: connectionId, sk: request.subscriptionId }
+      })
+    );
+    console.log("Subscription removed:", {
+      connectionId,
+      subscriptionId: request.subscriptionId
+    });
+    return {
+      type: "result",
+      data: { success: true }
+    };
+  }
+  async function handleCall(request, ctx) {
+    const result = await config.router.execute(
+      request.path,
+      ctx,
+      request.input
+    );
+    return {
+      type: "result",
+      data: result
+    };
+  }
+  async function registerConnection(connectionId, context) {
+    const now = Date.now();
+    const ttl = Math.floor(now / 1e3) + ttlSeconds;
+    const connectionEntry = {
+      connectionId,
+      context,
+      connectedAt: now,
+      ttl
+    };
+    await docClient.send(
+      new PutCommand({
+        TableName: connectionsTable,
+        Item: connectionEntry
+      })
+    );
+    console.log("Connection registered:", connectionEntry);
+  }
+  async function unregisterConnection(connectionId) {
+    await docClient.send(
+      new DeleteCommand({
+        TableName: connectionsTable,
+        Key: { connectionId }
+      })
+    );
+    console.log("Connection unregistered:", connectionId);
+  }
+  return {
+    handleRequest,
+    registerConnection,
+    unregisterConnection
+  };
+}
+function createStreamHandler(config) {
+  const dependenciesTable = config.dependenciesTableName ?? SystemTableNames.dependencies;
+  const queriesTable = config.queriesTableName ?? SystemTableNames.queries;
+  const ddbClient = new DynamoDBClient({
+    region: config.dbConfig?.region ?? process.env.AWS_REGION
+  });
+  const docClient = DynamoDBDocumentClient.from(ddbClient);
+  const apiClient = new ApiGatewayManagementApiClient({
+    endpoint: config.apiGatewayEndpoint
+  });
+  async function handler(event) {
+    const affectedSubscriptions = /* @__PURE__ */ new Map();
+    for (const record of event.Records) {
+      if (!record.dynamodb) continue;
+      const tableName = extractTableName(record);
+      if (!tableName) continue;
+      const newImage = record.dynamodb.NewImage ? unmarshall(record.dynamodb.NewImage) : null;
+      const oldImage = record.dynamodb.OldImage ? unmarshall(record.dynamodb.OldImage) : null;
+      const affectedKeys = /* @__PURE__ */ new Set();
+      if (newImage) {
+        for (const key of extractAffectedKeys(tableName, newImage)) {
+          affectedKeys.add(key);
+        }
+      }
+      if (oldImage) {
+        for (const key of extractAffectedKeys(tableName, oldImage)) {
+          affectedKeys.add(key);
+        }
+      }
+      for (const key of affectedKeys) {
+        const subscriptions = await findAffectedSubscriptions(key);
+        for (const sub of subscriptions) {
+          const connId = sub.connectionId;
+          const subId = sub.subscriptionId;
+          if (!affectedSubscriptions.has(connId)) {
+            affectedSubscriptions.set(connId, /* @__PURE__ */ new Set());
+          }
+          affectedSubscriptions.get(connId).add(subId);
+        }
+      }
+    }
+    const sendPromises = [];
+    for (const [connectionId, subscriptionIds] of affectedSubscriptions) {
+      for (const subscriptionId of subscriptionIds) {
+        sendPromises.push(processSubscription(connectionId, subscriptionId));
+      }
+    }
+    await Promise.allSettled(sendPromises);
+  }
+  function extractTableName(record) {
+    const arn = record.eventSourceARN;
+    if (!arn) return null;
+    const match = arn.match(/table\/([^/]+)/);
+    return match ? match[1] : null;
+  }
+  async function findAffectedSubscriptions(dependencyKey) {
+    try {
+      const response = await docClient.send(
+        new QueryCommand({
+          TableName: dependenciesTable,
+          KeyConditionExpression: "pk = :pk",
+          ExpressionAttributeValues: {
+            ":pk": dependencyKey
+          }
+        })
+      );
+      return (response.Items ?? []).map((item) => ({
+        connectionId: item.connectionId,
+        subscriptionId: item.subscriptionId
+      }));
+    } catch (error) {
+      console.error("Error finding affected subscriptions:", error);
+      return [];
+    }
+  }
+  async function processSubscription(connectionId, subscriptionId) {
+    try {
+      const queryState = await getQueryState(connectionId, subscriptionId);
+      if (!queryState) {
+        console.warn(
+          `Subscription not found: ${connectionId}/${subscriptionId}`
+        );
+        return;
+      }
+      const newResult = await executeQueryFromMetadata(
+        queryState.queryMetadata
+      );
+      if (!hasChanges(queryState.lastResult, newResult)) {
+        return;
+      }
+      const patches = generatePatches(queryState.lastResult, newResult);
+      await updateQueryState(connectionId, subscriptionId, newResult);
+      await sendPatch(connectionId, subscriptionId, patches);
+    } catch (error) {
+      if (error instanceof GoneException) {
+        await cleanupConnection(connectionId);
+      } else {
+        console.error(
+          `Error processing subscription ${connectionId}/${subscriptionId}:`,
+          error
+        );
+      }
+    }
+  }
+  async function getQueryState(connectionId, subscriptionId) {
+    try {
+      const response = await docClient.send(
+        new GetCommand({
+          TableName: queriesTable,
+          Key: {
+            pk: connectionId,
+            sk: subscriptionId
+          }
+        })
+      );
+      return response.Item ?? null;
+    } catch (error) {
+      console.error("Error getting query state:", error);
+      return null;
+    }
+  }
+  async function executeQueryFromMetadata(metadata) {
+    const { tableName, filterConditions, sortOrder, limit } = metadata;
+    const whereClause = buildWhereClause(filterConditions);
+    const orderClause = sortOrder === "desc" ? "ORDER BY SK DESC" : "";
+    const limitClause = limit ? `LIMIT ${limit}` : "";
+    const statement = `SELECT * FROM "${tableName}" ${whereClause} ${orderClause} ${limitClause}`.trim();
+    try {
+      const result = await ddbClient.send(
+        new ExecuteStatementCommand({
+          Statement: statement
+        })
+      );
+      return (result.Items ?? []).map(
+        (item) => unmarshall(item)
+      );
+    } catch (error) {
+      console.error("Error executing query from metadata:", error);
+      console.error("Statement:", statement);
+      return [];
+    }
+  }
+  function buildWhereClause(conditions) {
+    if (conditions.length === 0) return "";
+    const clauses = conditions.map((c) => buildConditionClause(c)).filter(Boolean);
+    if (clauses.length === 0) return "";
+    return `WHERE ${clauses.join(" AND ")}`;
+  }
+  function buildConditionClause(condition) {
+    const { type, operator, field, value, value2, conditions } = condition;
+    if (type === "comparison" && field) {
+      const escapedValue = escapeValue(value);
+      switch (operator) {
+        case "eq":
+          return `"${field}" = ${escapedValue}`;
+        case "ne":
+          return `"${field}" <> ${escapedValue}`;
+        case "gt":
+          return `"${field}" > ${escapedValue}`;
+        case "gte":
+          return `"${field}" >= ${escapedValue}`;
+        case "lt":
+          return `"${field}" < ${escapedValue}`;
+        case "lte":
+          return `"${field}" <= ${escapedValue}`;
+        case "between":
+          return `"${field}" BETWEEN ${escapedValue} AND ${escapeValue(value2)}`;
+        default:
+          return "";
+      }
+    }
+    if (type === "function" && field) {
+      const escapedValue = escapeValue(value);
+      switch (operator) {
+        case "beginsWith":
+          return `begins_with("${field}", ${escapedValue})`;
+        case "contains":
+          return `contains("${field}", ${escapedValue})`;
+        default:
+          return "";
+      }
+    }
+    if (type === "logical" && conditions) {
+      const subclauses = conditions.map((c) => buildConditionClause(c)).filter(Boolean);
+      if (subclauses.length === 0) return "";
+      switch (operator) {
+        case "and":
+          return `(${subclauses.join(" AND ")})`;
+        case "or":
+          return `(${subclauses.join(" OR ")})`;
+        case "not":
+          return subclauses.length > 0 ? `NOT (${subclauses[0]})` : "";
+        default:
+          return "";
+      }
+    }
+    return "";
+  }
+  function escapeValue(value) {
+    if (value === null || value === void 0) return "NULL";
+    if (typeof value === "string") return `'${value.replace(/'/g, "''")}'`;
+    if (typeof value === "number") return String(value);
+    if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+    return `'${String(value).replace(/'/g, "''")}'`;
+  }
+  async function updateQueryState(connectionId, subscriptionId, newResult) {
+    try {
+      const existing = await getQueryState(connectionId, subscriptionId);
+      if (!existing) return;
+      await docClient.send(
+        new GetCommand({
+          TableName: queriesTable,
+          Key: { pk: connectionId, sk: subscriptionId }
+        })
+      );
+      const { PutCommand: PutCommand4 } = await import('@aws-sdk/lib-dynamodb');
+      await docClient.send(
+        new PutCommand4({
+          TableName: queriesTable,
+          Item: {
+            ...existing,
+            lastResult: newResult,
+            updatedAt: Date.now()
+          }
+        })
+      );
+    } catch (error) {
+      console.error("Error updating query state:", error);
+    }
+  }
+  async function sendPatch(connectionId, subscriptionId, patches) {
+    const message = JSON.stringify({
+      type: "patch",
+      subscriptionId,
+      patches
+    });
+    try {
+      await apiClient.send(
+        new PostToConnectionCommand({
+          ConnectionId: connectionId,
+          Data: Buffer.from(message)
+        })
+      );
+    } catch (error) {
+      if (error instanceof GoneException) {
+        throw error;
+      }
+      console.error(`Error sending patch to ${connectionId}:`, error);
+    }
+  }
+  async function cleanupConnection(connectionId) {
+    console.log("Cleaning up disconnected connection:", connectionId);
+  }
+  return { handler };
+}
+function createConnectHandler(config) {
+  const connectionsTable = config.connectionsTableName ?? SystemTableNames.connections;
+  const ddbClient = new DynamoDBClient({
+    region: config.dbConfig?.region ?? process.env.AWS_REGION
+  });
+  const docClient = DynamoDBDocumentClient.from(ddbClient);
+  return async function handler(event) {
+    const connectionId = event.requestContext.connectionId;
+    try {
+      await docClient.send(
+        new QueryCommand({
+          TableName: connectionsTable,
+          KeyConditionExpression: "connectionId = :cid",
+          ExpressionAttributeValues: {
+            ":cid": connectionId
+          }
+        })
+      );
+      console.log("Connection established:", connectionId);
+      return { statusCode: 200 };
+    } catch (error) {
+      console.error("Error creating connection:", error);
+      return { statusCode: 500 };
+    }
+  };
+}
+function createDisconnectHandler(config) {
+  const connectionsTable = config.connectionsTableName ?? SystemTableNames.connections;
+  const ddbClient = new DynamoDBClient({
+    region: config.dbConfig?.region ?? process.env.AWS_REGION
+  });
+  const docClient = DynamoDBDocumentClient.from(ddbClient);
+  return async function handler(event) {
+    const connectionId = event.requestContext.connectionId;
+    try {
+      await docClient.send(
+        new DeleteCommand({
+          TableName: connectionsTable,
+          Key: { connectionId }
+        })
+      );
+      console.log("Connection removed:", connectionId);
+      return { statusCode: 200 };
+    } catch (error) {
+      console.error("Error removing connection:", error);
+      return { statusCode: 500 };
+    }
+  };
+}
+
+// ../server/src/harness.ts
+function createReactiveHarness(config) {
+  return {
+    getContext: config.getContext ?? (async () => ({})),
+    dbConfig: config.dbConfig
+  };
+}
+function createLambdaHandlers() {
+  const connectionsTable = process.env.CONNECTIONS_TABLE ?? SystemTableNames.connections;
+  const dependenciesTable = process.env.DEPENDENCIES_TABLE ?? SystemTableNames.dependencies;
+  const queriesTable = process.env.QUERIES_TABLE ?? SystemTableNames.queries;
+  const wsEndpoint = process.env.WEBSOCKET_ENDPOINT ?? "";
+  const ddbClient = new DynamoDBClient({
+    region: process.env.AWS_REGION
+  });
+  const docClient = DynamoDBDocumentClient.from(ddbClient);
+  const getApiClient = () => new ApiGatewayManagementApiClient({
+    endpoint: wsEndpoint
+  });
+  async function connectHandler(event) {
+    const connectionId = event.requestContext.connectionId;
+    const now = Date.now();
+    const ttl = Math.floor(now / 1e3) + 3600;
+    try {
+      const connectionEntry = {
+        connectionId,
+        context: event.requestContext.authorizer,
+        connectedAt: now,
+        ttl
+      };
+      await docClient.send(
+        new PutCommand({
+          TableName: connectionsTable,
+          Item: connectionEntry
+        })
+      );
+      console.log("Connection established:", connectionId);
+      return { statusCode: 200, body: "Connected" };
+    } catch (error) {
+      console.error("Error creating connection:", error);
+      return { statusCode: 500, body: "Failed to connect" };
+    }
+  }
+  async function disconnectHandler(event) {
+    const connectionId = event.requestContext.connectionId;
+    try {
+      await docClient.send(
+        new DeleteCommand({
+          TableName: connectionsTable,
+          Key: { connectionId }
+        })
+      );
+      console.log("Connection removed:", connectionId);
+      return { statusCode: 200, body: "Disconnected" };
+    } catch (error) {
+      console.error("Error removing connection:", error);
+      return { statusCode: 500, body: "Failed to disconnect" };
+    }
+  }
+  async function messageHandler(event) {
+    const connectionId = event.requestContext.connectionId;
+    try {
+      const body = JSON.parse(event.body ?? "{}");
+      const { type, subscriptionId } = body;
+      let response;
+      switch (type) {
+        case "unsubscribe": {
+          const subResponse = await docClient.send(
+            new GetCommand({
+              TableName: queriesTable,
+              Key: { pk: connectionId, sk: subscriptionId }
+            })
+          );
+          if (subResponse.Item) {
+            const queryEntry = subResponse.Item;
+            for (const key of queryEntry.dependencies ?? []) {
+              await docClient.send(
+                new DeleteCommand({
+                  TableName: dependenciesTable,
+                  Key: { pk: key, sk: `${connectionId}#${subscriptionId}` }
+                })
+              );
+            }
+          }
+          await docClient.send(
+            new DeleteCommand({
+              TableName: queriesTable,
+              Key: { pk: connectionId, sk: subscriptionId }
+            })
+          );
+          response = { type: "result", data: { success: true } };
+          break;
+        }
+        default:
+          response = {
+            type: "error",
+            message: `Message type '${type}' should be handled by the app API route`
+          };
+      }
+      const apiClient = getApiClient();
+      await apiClient.send(
+        new PostToConnectionCommand({
+          ConnectionId: connectionId,
+          Data: Buffer.from(JSON.stringify(response))
+        })
+      );
+      return { statusCode: 200, body: "OK" };
+    } catch (error) {
+      console.error("Error handling message:", error);
+      return { statusCode: 500, body: "Internal server error" };
+    }
+  }
+  async function streamHandler(event) {
+    const affectedSubscriptions = /* @__PURE__ */ new Map();
+    for (const record of event.Records) {
+      if (!record.dynamodb) continue;
+      const tableName = extractTableName(record);
+      if (!tableName) continue;
+      const newImage = record.dynamodb.NewImage ? unmarshall(record.dynamodb.NewImage) : null;
+      const oldImage = record.dynamodb.OldImage ? unmarshall(record.dynamodb.OldImage) : null;
+      const affectedKeys = /* @__PURE__ */ new Set();
+      if (newImage) {
+        for (const key of extractAffectedKeys(tableName, newImage)) {
+          affectedKeys.add(key);
+        }
+      }
+      if (oldImage) {
+        for (const key of extractAffectedKeys(tableName, oldImage)) {
+          affectedKeys.add(key);
+        }
+      }
+      for (const key of affectedKeys) {
+        const subscriptions = await findAffectedSubscriptions(key);
+        for (const sub of subscriptions) {
+          const connId = sub.connectionId;
+          const subId = sub.subscriptionId;
+          if (!affectedSubscriptions.has(connId)) {
+            affectedSubscriptions.set(connId, /* @__PURE__ */ new Map());
+          }
+          const connSubs = affectedSubscriptions.get(connId);
+          if (!connSubs.has(subId)) {
+            connSubs.set(subId, { oldImage, newImage });
+          }
+        }
+      }
+    }
+    const sendPromises = [];
+    for (const [connectionId, subscriptions] of affectedSubscriptions) {
+      for (const [subscriptionId] of subscriptions) {
+        sendPromises.push(processSubscription(connectionId, subscriptionId));
+      }
+    }
+    await Promise.allSettled(sendPromises);
+  }
+  function extractTableName(record) {
+    const arn = record.eventSourceARN;
+    if (!arn) return null;
+    const match = arn.match(/table\/([^/]+)/);
+    return match ? match[1] : null;
+  }
+  async function findAffectedSubscriptions(dependencyKey) {
+    try {
+      const response = await docClient.send(
+        new QueryCommand({
+          TableName: dependenciesTable,
+          KeyConditionExpression: "pk = :pk",
+          ExpressionAttributeValues: {
+            ":pk": dependencyKey
+          }
+        })
+      );
+      return (response.Items ?? []).map((item) => ({
+        connectionId: item.connectionId,
+        subscriptionId: item.subscriptionId
+      }));
+    } catch (error) {
+      console.error("Error finding affected subscriptions:", error);
+      return [];
+    }
+  }
+  async function processSubscription(connectionId, subscriptionId) {
+    try {
+      const response = await docClient.send(
+        new GetCommand({
+          TableName: queriesTable,
+          Key: { pk: connectionId, sk: subscriptionId }
+        })
+      );
+      const queryState = response.Item;
+      if (!queryState) {
+        console.warn(
+          `Subscription not found: ${connectionId}/${subscriptionId}`
+        );
+        return;
+      }
+      const newResult = await executeQueryFromMetadata(queryState.queryMetadata);
+      if (!hasChanges(queryState.lastResult, newResult)) {
+        return;
+      }
+      const patches = generatePatches(queryState.lastResult, newResult);
+      await docClient.send(
+        new PutCommand({
+          TableName: queriesTable,
+          Item: {
+            ...queryState,
+            lastResult: newResult,
+            updatedAt: Date.now()
+          }
+        })
+      );
+      await sendPatch(connectionId, subscriptionId, patches);
+    } catch (error) {
+      if (error instanceof GoneException) {
+        await cleanupConnection(connectionId);
+      } else {
+        console.error(
+          `Error processing subscription ${connectionId}/${subscriptionId}:`,
+          error
+        );
+      }
+    }
+  }
+  async function executeQueryFromMetadata(metadata) {
+    const { tableName, filterConditions, sortOrder, limit } = metadata;
+    const whereClause = buildWhereClause(filterConditions);
+    const orderClause = sortOrder === "desc" ? "ORDER BY SK DESC" : "";
+    const limitClause = limit ? `LIMIT ${limit}` : "";
+    const statement = `SELECT * FROM "${tableName}" ${whereClause} ${orderClause} ${limitClause}`.trim();
+    try {
+      const { ExecuteStatementCommand: ExecuteStatementCommand3 } = await import('@aws-sdk/client-dynamodb');
+      const result = await ddbClient.send(
+        new ExecuteStatementCommand3({
+          Statement: statement
+        })
+      );
+      return (result.Items ?? []).map(
+        (item) => unmarshall(item)
+      );
+    } catch (error) {
+      console.error("Error executing query from metadata:", error);
+      console.error("Statement:", statement);
+      return [];
+    }
+  }
+  function buildWhereClause(conditions) {
+    if (conditions.length === 0) return "";
+    const clauses = conditions.map((c) => buildConditionClause(c)).filter(Boolean);
+    if (clauses.length === 0) return "";
+    return `WHERE ${clauses.join(" AND ")}`;
+  }
+  function buildConditionClause(condition) {
+    const { type, operator, field, value, value2, conditions } = condition;
+    if (type === "comparison" && field) {
+      const escapedValue = escapeValue(value);
+      switch (operator) {
+        case "eq":
+          return `"${field}" = ${escapedValue}`;
+        case "ne":
+          return `"${field}" <> ${escapedValue}`;
+        case "gt":
+          return `"${field}" > ${escapedValue}`;
+        case "gte":
+          return `"${field}" >= ${escapedValue}`;
+        case "lt":
+          return `"${field}" < ${escapedValue}`;
+        case "lte":
+          return `"${field}" <= ${escapedValue}`;
+        case "between":
+          return `"${field}" BETWEEN ${escapedValue} AND ${escapeValue(value2)}`;
+        default:
+          return "";
+      }
+    }
+    if (type === "function" && field) {
+      const escapedValue = escapeValue(value);
+      switch (operator) {
+        case "beginsWith":
+          return `begins_with("${field}", ${escapedValue})`;
+        case "contains":
+          return `contains("${field}", ${escapedValue})`;
+        default:
+          return "";
+      }
+    }
+    if (type === "logical" && conditions) {
+      const subclauses = conditions.map((c) => buildConditionClause(c)).filter(Boolean);
+      if (subclauses.length === 0) return "";
+      switch (operator) {
+        case "and":
+          return `(${subclauses.join(" AND ")})`;
+        case "or":
+          return `(${subclauses.join(" OR ")})`;
+        case "not":
+          return subclauses.length > 0 ? `NOT (${subclauses[0]})` : "";
+        default:
+          return "";
+      }
+    }
+    return "";
+  }
+  function escapeValue(value) {
+    if (value === null || value === void 0) return "NULL";
+    if (typeof value === "string") return `'${value.replace(/'/g, "''")}'`;
+    if (typeof value === "number") return String(value);
+    if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+    return `'${String(value).replace(/'/g, "''")}'`;
+  }
+  async function sendPatch(connectionId, subscriptionId, patches) {
+    const message = JSON.stringify({
+      type: "patch",
+      subscriptionId,
+      patches
+    });
+    try {
+      const apiClient = getApiClient();
+      await apiClient.send(
+        new PostToConnectionCommand({
+          ConnectionId: connectionId,
+          Data: Buffer.from(message)
+        })
+      );
+    } catch (error) {
+      if (error instanceof GoneException) {
+        throw error;
+      }
+      console.error(`Error sending patch to ${connectionId}:`, error);
+    }
+  }
+  async function cleanupConnection(connectionId) {
+    console.log("Cleaning up disconnected connection:", connectionId);
+    try {
+      await docClient.send(
+        new DeleteCommand({
+          TableName: connectionsTable,
+          Key: { connectionId }
+        })
+      );
+    } catch (error) {
+      console.error("Error cleaning up connection:", error);
+    }
+  }
+  return {
+    connectHandler,
+    disconnectHandler,
+    messageHandler,
+    streamHandler
+  };
+}
+
+// ../server/src/filter-evaluator.ts
+function evaluateFilter(filter, record) {
+  switch (filter.type) {
+    case "comparison":
+      return evaluateComparison(filter, record);
+    case "logical":
+      return evaluateLogical(filter, record);
+    case "function":
+      return evaluateFunction(filter, record);
+    default:
+      console.warn(`Unknown filter type: ${filter.type}`);
+      return false;
+  }
+}
+function evaluateFilters(filters, record) {
+  if (filters.length === 0) return true;
+  return filters.every((filter) => evaluateFilter(filter, record));
+}
+function evaluateComparison(filter, record) {
+  const { operator, field, value, value2 } = filter;
+  if (!field || !operator) return false;
+  const fieldValue = getFieldValue(record, field);
+  switch (operator) {
+    case "eq":
+      return fieldValue === value;
+    case "ne":
+      return fieldValue !== value;
+    case "gt":
+      return compareValues(fieldValue, value) > 0;
+    case "gte":
+      return compareValues(fieldValue, value) >= 0;
+    case "lt":
+      return compareValues(fieldValue, value) < 0;
+    case "lte":
+      return compareValues(fieldValue, value) <= 0;
+    case "between":
+      return compareValues(fieldValue, value) >= 0 && compareValues(fieldValue, value2) <= 0;
+    default:
+      console.warn(`Unknown comparison operator: ${operator}`);
+      return false;
+  }
+}
+function evaluateLogical(filter, record) {
+  const { operator, conditions } = filter;
+  if (!operator || !conditions) return false;
+  switch (operator) {
+    case "and":
+      return conditions.every((c) => evaluateFilter(c, record));
+    case "or":
+      return conditions.some((c) => evaluateFilter(c, record));
+    case "not":
+      return conditions.length > 0 && !evaluateFilter(conditions[0], record);
+    default:
+      console.warn(`Unknown logical operator: ${operator}`);
+      return false;
+  }
+}
+function evaluateFunction(filter, record) {
+  const { operator, field, value } = filter;
+  if (!field || !operator) return false;
+  const fieldValue = getFieldValue(record, field);
+  switch (operator) {
+    case "beginsWith":
+      return typeof fieldValue === "string" && typeof value === "string" && fieldValue.startsWith(value);
+    case "contains":
+      return typeof fieldValue === "string" && typeof value === "string" && fieldValue.includes(value);
+    default:
+      console.warn(`Unknown function operator: ${operator}`);
+      return false;
+  }
+}
+function getFieldValue(record, field) {
+  const parts = field.split(".");
+  let value = record;
+  for (const part of parts) {
+    if (value === null || value === void 0) return void 0;
+    if (typeof value !== "object") return void 0;
+    value = value[part];
+  }
+  return value;
+}
+function compareValues(a, b) {
+  if (a === null || a === void 0) {
+    return b === null || b === void 0 ? 0 : -1;
+  }
+  if (b === null || b === void 0) {
+    return 1;
+  }
+  if (typeof a === "number" && typeof b === "number") {
+    return a - b;
+  }
+  if (typeof a === "string" && typeof b === "string") {
+    return a.localeCompare(b);
+  }
+  if (typeof a === "boolean" && typeof b === "boolean") {
+    return a === b ? 0 : a ? 1 : -1;
+  }
+  return String(a).localeCompare(String(b));
+}
+function sortRecords(records, sortField, sortOrder = "asc") {
+  if (!sortField) return records;
+  return [...records].sort((a, b) => {
+    const aValue = getFieldValue(a, sortField);
+    const bValue = getFieldValue(b, sortField);
+    const comparison = compareValues(aValue, bValue);
+    return sortOrder === "desc" ? -comparison : comparison;
+  });
+}
+function getRecordKey(record, pkField, skField) {
+  const pk = record[pkField];
+  const sk = skField ? record[skField] : void 0;
+  return sk !== void 0 ? `${pk}#${sk}` : String(pk);
+}
+
+export { DependencyTracker, ProcedureBuilder, QueryBuilderImpl, Router, 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 };
+//# sourceMappingURL=server.js.map
 //# sourceMappingURL=server.js.map