dynamodb-reactive 0.1.10 → 0.1.12

package/dist/server.js

@@ -1,10 +1,331 @@
 import { SystemTableNames } from './chunk-L4NOAOXX.js';
+import { __commonJS, __toESM } from './chunk-5WRI5ZAA.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 jsonpatch from 'fast-json-patch';
 import { ApiGatewayManagementApiClient, PostToConnectionCommand, GoneException } from '@aws-sdk/client-apigatewaymanagementapi';
 
+// ../../node_modules/.pnpm/ag-common@0.0.864_jiti@2.6.1_postcss@8.5.6/node_modules/ag-common/dist/common/helpers/array.js
+var require_array = __commonJS({
+  "../../node_modules/.pnpm/ag-common@0.0.864_jiti@2.6.1_postcss@8.5.6/node_modules/ag-common/dist/common/helpers/array.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.insertElementAtIndex = exports$1.distinct = exports$1.notEmpty = exports$1.partition = exports$1.chunk = exports$1.take = exports$1.flat = exports$1.arrayToObject = void 0;
+    exports$1.distinctBy = distinctBy;
+    exports$1.findLastIndex = findLastIndex;
+    var arrayToObject = (arr, keyF, valueF) => {
+      const ret = {};
+      if (!arr || !keyF) {
+        return ret;
+      }
+      arr.forEach((v) => {
+        const k = keyF(v);
+        ret[k] = valueF(v);
+      });
+      return ret;
+    };
+    exports$1.arrayToObject = arrayToObject;
+    var flat = (arr) => [].concat(...arr);
+    exports$1.flat = flat;
+    var take = (array, num) => {
+      const safeNum = Math.max(0, Math.min(num, array.length));
+      const part = array.slice(0, safeNum);
+      const rest = array.slice(safeNum);
+      return { part, rest };
+    };
+    exports$1.take = take;
+    var chunk = (array, max) => {
+      const rows = [];
+      let row = [];
+      for (const k in array) {
+        const item = array[k];
+        row.push(item);
+        if (row.length >= max) {
+          rows.push(row);
+          row = [];
+        }
+      }
+      if (row.length > 0) {
+        rows.push(row);
+      }
+      return rows;
+    };
+    exports$1.chunk = chunk;
+    var partition = (array, func) => !array.length ? null : [array.filter((r) => func(r)), array.filter((r) => !func(r))];
+    exports$1.partition = partition;
+    var notEmpty = (value) => value !== null && value !== void 0 && value !== false && value !== "";
+    exports$1.notEmpty = notEmpty;
+    function distinctBy(data, key, ignoreEmpty) {
+      if (!data || data.length === 0) {
+        return data;
+      }
+      const hashSet = /* @__PURE__ */ new Set();
+      return data.filter((x) => {
+        let keyVal;
+        if (typeof key === "string") {
+          keyVal = x[key];
+        } else {
+          keyVal = key(x);
+        }
+        if (!keyVal && ignoreEmpty) {
+          return false;
+        }
+        if (!hashSet.has(keyVal)) {
+          hashSet.add(keyVal);
+          return true;
+        }
+        return false;
+      });
+    }
+    var distinct = (arr) => [
+      ...new Set(arr)
+    ];
+    exports$1.distinct = distinct;
+    function findLastIndex(arr, predicate) {
+      for (let i = arr.length - 1; i >= 0; i--) {
+        if (predicate(arr[i], i, arr)) {
+          return i;
+        }
+      }
+      return -1;
+    }
+    var insertElementAtIndex = (arr, element, index) => [...arr.slice(0, index), element, ...arr.slice(index)];
+    exports$1.insertElementAtIndex = insertElementAtIndex;
+  }
+});
+
+// ../../node_modules/.pnpm/ag-common@0.0.864_jiti@2.6.1_postcss@8.5.6/node_modules/ag-common/dist/common/helpers/string/redact.js
+var require_redact = __commonJS({
+  "../../node_modules/.pnpm/ag-common@0.0.864_jiti@2.6.1_postcss@8.5.6/node_modules/ag-common/dist/common/helpers/string/redact.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.redactString = redactString;
+    exports$1.redactObject = redactObject;
+    function redactString(str) {
+      let ret = str;
+      ret = ret || "";
+      const repl = "$1<redacted>$2";
+      ret = ret.replace(/(\b)grant_type.+?(\b)/gm, repl);
+      ret = ret.replace(/(\b)Bearer .+?(\b)/gm, repl);
+      ret = ret.replace(/(eyJ[\w-_.]*\.[\w-_.]*\.[\w-_.]*)/gim, "<redacted>");
+      ret = ret.replace(/(\b)(sk_live_|sk_test_|pk_live_|pk_test_)[\w-]+/gi, "$1<redacted>");
+      ret = ret.replace(/(\b)(AKIA[0-9A-Z]{16})/gi, "$1<redacted>");
+      ret = ret.replace(/(aws_secret_access_key["\s]*[:=]["\s]*)([0-9a-zA-Z/+]{40})/gi, "$1<redacted>");
+      ret = ret.replace(/(\b)(AIza[0-9A-Za-z\\-_]{35})/gi, "$1<redacted>");
+      ret = ret.replace(/(\b)(ya29\.[0-9A-Za-z\\-_]+)/gi, "$1<redacted>");
+      ret = ret.replace(/(\b)(glpat-[a-zA-Z0-9\\-_]{20})/gi, "$1<redacted>");
+      ret = ret.replace(/(\b)(ghp_[a-zA-Z0-9]{36})/gi, "$1<redacted>");
+      ret = ret.replace(/(\b)(github_pat_[a-zA-Z0-9]{22}_[a-zA-Z0-9]{59})/gi, "$1<redacted>");
+      ret = ret.replace(/(password["\s]*[:=]["\s]*)([^",\s}]+)/gi, "$1<redacted>");
+      ret = ret.replace(/(passwd["\s]*[:=]["\s]*)([^",\s}]+)/gi, "$1<redacted>");
+      ret = ret.replace(/(pwd["\s]*[:=]["\s]*)([^",\s}]+)/gi, "$1<redacted>");
+      ret = ret.replace(/(secret["\s]*[:=]["\s]*)([^",\s}]+)/gi, "$1<redacted>");
+      ret = ret.replace(/(token["\s]*[:=]["\s]*)([^",\s}]+)/gi, "$1<redacted>");
+      ret = ret.replace(/(^|[^a-zA-Z])(api_?key|private_?key|secret_?key)["\s]*[:=]["\s]*([^",\s}]+)/gi, "$1$2<redacted>");
+      ret = ret.replace(/(auth["\s]*[:=]["\s]*)([^",\s}]+)/gi, "$1<redacted>");
+      ret = ret.replace(/(mongodb:\/\/[^:]+:)([^@]+)(@)/gi, "$1<redacted>$3");
+      ret = ret.replace(/(mysql:\/\/[^:]+:)([^@]+)(@)/gi, "$1<redacted>$3");
+      ret = ret.replace(/(postgresql:\/\/[^:]+:)([^@]+)(@)/gi, "$1<redacted>$3");
+      ret = ret.replace(/(redis:\/\/[^:]+:)([^@]+)(@)/gi, "$1<redacted>$3");
+      ret = ret.replace(/(\b)([3-6]\d{3}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{3,4})(\b)/g, "$1<redacted>$3");
+      ret = ret.replace(/(\b)(\d{3}[-\s]?\d{2}[-\s]?\d{4})(\b)/g, "$1<redacted>$3");
+      ret = ret.replace(/(-----BEGIN [A-Z\s]+PRIVATE KEY-----)([\s\S]*?)(-----END [A-Z\s]+PRIVATE KEY-----)/gi, "$1\n<redacted>\n$3");
+      ret = ret.replace(/(sessionid["\s]*[:=]["\s]*)([a-zA-Z0-9]{32,})/gi, "$1<redacted>");
+      ret = ret.replace(/(session["\s]*[:=]["\s]*)([a-zA-Z0-9]{32,})/gi, "$1<redacted>");
+      ret = ret.replace(/(csrftoken["\s]*[:=]["\s]*)([a-zA-Z0-9]{32,})/gi, "$1<redacted>");
+      ret = ret.replace(/(DATABASE_URL["\s]*[:=]["\s]*)([^",\s}]+)/gi, "$1<redacted>");
+      ret = ret.replace(/(REDIS_URL["\s]*[:=]["\s]*)([^",\s}]+)/gi, "$1<redacted>");
+      ret = ret.replace(/(SMTP_PASSWORD["\s]*[:=]["\s]*)([^",\s}]+)/gi, "$1<redacted>");
+      ret = ret.replace(/(ENCRYPTION_KEY["\s]*[:=]["\s]*)([^",\s}]+)/gi, "$1<redacted>");
+      ret = ret.replace(/\b([a-zA-Z0-9+/=_-]{20,})\b/g, (match) => {
+        if (match.endsWith("==") && match.length > 30) {
+          return "<redacted>";
+        }
+        if (getShannonEntropy(match) > 4.5) {
+          return "<redacted>";
+        }
+        return match;
+      });
+      return ret;
+    }
+    function getShannonEntropy(str) {
+      var _a;
+      const len = str.length;
+      if (len === 0)
+        return 0;
+      const frequencies = /* @__PURE__ */ new Map();
+      for (const char of str) {
+        frequencies.set(char, ((_a = frequencies.get(char)) !== null && _a !== void 0 ? _a : 0) + 1);
+      }
+      let entropy = 0;
+      for (const count of frequencies.values()) {
+        const p = count / len;
+        entropy -= p * Math.log2(p);
+      }
+      return entropy;
+    }
+    function redactObject(ob) {
+      if (typeof ob === "string") {
+        return redactString(ob);
+      } else if (typeof ob === "object") {
+        try {
+          return JSON.parse(redactString(JSON.stringify(ob)));
+        } catch (e) {
+          return ob;
+        }
+      }
+      return ob;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/ag-common@0.0.864_jiti@2.6.1_postcss@8.5.6/node_modules/ag-common/dist/common/helpers/log.js
+var require_log = __commonJS({
+  "../../node_modules/.pnpm/ag-common@0.0.864_jiti@2.6.1_postcss@8.5.6/node_modules/ag-common/dist/common/helpers/log.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.fatal = exports$1.error = exports$1.trace = exports$1.warn = exports$1.info = exports$1.debug = exports$1.SetLogLevel = exports$1.SetLogShim = exports$1.GetLogLevel = void 0;
+    var array_1 = require_array();
+    var redact_1 = require_redact();
+    var GetLogLevel = (l) => ["TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL"].findIndex((s) => s === l);
+    exports$1.GetLogLevel = GetLogLevel;
+    var logShim;
+    var SetLogShim = (ls) => {
+      logShim = ls;
+    };
+    exports$1.SetLogShim = SetLogShim;
+    var userLogLevel;
+    var SetLogLevel = (l) => {
+      const lu = (l !== null && l !== void 0 ? l : "INFO").toUpperCase();
+      if ((0, exports$1.GetLogLevel)(lu) === -1) {
+        return;
+      }
+      userLogLevel = lu;
+    };
+    exports$1.SetLogLevel = SetLogLevel;
+    function logprocess(type, args) {
+      if (!userLogLevel) {
+        (0, exports$1.SetLogLevel)(process.env.LOG_LEVEL);
+      }
+      const min = (0, exports$1.GetLogLevel)(userLogLevel !== null && userLogLevel !== void 0 ? userLogLevel : "WARN");
+      const typesLogLevel = (0, exports$1.GetLogLevel)(type);
+      if (typesLogLevel < min) {
+        return;
+      }
+      const datetime = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-GB");
+      const log = [
+        `[${datetime}]`,
+        type,
+        ...args.filter(array_1.notEmpty).map((s) => {
+          if (s instanceof Error) {
+            return (0, redact_1.redactObject)({
+              message: s.message,
+              name: s.name,
+              stack: s.stack
+            });
+          }
+          return (0, redact_1.redactObject)(s);
+        })
+      ];
+      if (logShim) {
+        logShim(...log);
+        return;
+      }
+      switch (type) {
+        case "TRACE": {
+          console.trace(...log);
+          break;
+        }
+        case "DEBUG": {
+          console.debug(...log);
+          break;
+        }
+        case "INFO": {
+          console.log(...log);
+          break;
+        }
+        case "WARN": {
+          console.warn(...log);
+          break;
+        }
+        case "ERROR": {
+          console.error(...log);
+          break;
+        }
+        case "FATAL": {
+          console.error(...log);
+          break;
+        }
+        default: {
+          console.log(...log);
+          break;
+        }
+      }
+    }
+    function printStackTrace(...args) {
+      var _a;
+      const callstack = [];
+      let isCallstackPopulated = false;
+      try {
+        throw new Error("Test");
+      } catch (e) {
+        const er = e;
+        if (er.stack) {
+          const lines = er.stack.split("\n");
+          for (let i = 0, len = lines.length; i < len; i += 1) {
+            callstack.push(` ${lines[i]} `);
+          }
+          callstack.shift();
+          isCallstackPopulated = true;
+        } else if (window.opera && er.message) {
+          const lines = er.message.split("\n");
+          for (let i = 0, len = lines.length; i < len; i += 1) {
+            if (lines[i].match(/^\s*[A-Za-z0-9\-_$]+\(/)) {
+              let entry = lines[i];
+              if (lines[i + 1]) {
+                entry += ` at ${lines[i + 1]}`;
+                i += 1;
+              }
+              callstack.push(entry);
+            }
+          }
+          callstack.shift();
+          isCallstackPopulated = true;
+        }
+      }
+      if (!isCallstackPopulated) {
+        let currentFunction = args.callee.caller;
+        while (currentFunction) {
+          const fn = currentFunction.toString();
+          const fname = (_a = fn.substring(fn.indexOf("function") + 8, fn.indexOf("("))) !== null && _a !== void 0 ? _a : "anonymous";
+          callstack.push(fname);
+          currentFunction = currentFunction.caller;
+        }
+      }
+      return callstack.join("\n");
+    }
+    var debug3 = (...args) => logprocess("DEBUG", args);
+    exports$1.debug = debug3;
+    var info3 = (...args) => logprocess("INFO", args);
+    exports$1.info = info3;
+    var warn4 = (...args) => logprocess("WARN", args);
+    exports$1.warn = warn4;
+    var trace = (...args) => {
+      args.push(printStackTrace());
+      logprocess("TRACE", args);
+    };
+    exports$1.trace = trace;
+    var error = (...args) => {
+      args.push(printStackTrace());
+      logprocess("ERROR", args);
+    };
+    exports$1.error = error;
+    var fatal = (...args) => {
+      args.push(printStackTrace());
+      logprocess("FATAL", args);
+    };
+    exports$1.fatal = fatal;
+  }
+});
+
 // ../server/src/procedure.ts
 var ProcedureBuilder = class _ProcedureBuilder {
   inputSchema;
@@ -562,7 +883,8 @@ function extractAffectedKeys(tableName, 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++) {
+        const maxPrefixLen = Math.min(fieldValue.length, 10);
+        for (let i = 1; i <= maxPrefixLen; i++) {
           keys.push(
             `${tableName}#${fieldName}#prefix:${fieldValue.substring(0, i)}`
           );
@@ -740,6 +1062,7 @@ function batchPatches(patchSets) {
   const allPatches = patchSets.flat();
   return optimizePatches(allPatches);
 }
+var import_log = __toESM(require_log());
 function createReactiveHandler(config) {
   const ttlSeconds = config.ttlSeconds ?? 3600;
   const prefix = config.tablePrefix ? `${config.tablePrefix}-` : "";
@@ -755,6 +1078,11 @@ function createReactiveHandler(config) {
   async function handleRequest(request, headers) {
     try {
       const connectionId = request.connectionId;
+      (0, import_log.debug)("[reactive-handler] handleRequest:", {
+        type: request.type,
+        connectionId,
+        path: "path" in request ? request.path : void 0
+      });
       const ctx = await config.getContext({ connectionId, headers });
       const dependencyTracker = new DependencyTracker();
       const db = createDbContext(config.dbConfig ?? {}, dependencyTracker);
@@ -795,7 +1123,7 @@ function createReactiveHandler(config) {
     const queryMetadata = dependencyTracker.getQueryMetadata();
     const dependencyKeys = dependencyTracker.getDependencyKeys();
     if (!queryMetadata) {
-      console.warn("No query metadata captured for subscription");
+      (0, import_log.warn)("[reactive-handler] No query metadata captured for subscription");
     }
     const now = Date.now();
     const ttl = Math.floor(now / 1e3) + ttlSeconds;
@@ -834,11 +1162,13 @@ function createReactiveHandler(config) {
         })
       );
     }
-    console.log("Subscription created:", {
+    (0, import_log.debug)("[reactive-handler] Subscription created:", {
       connectionId,
       subscriptionId: request.subscriptionId,
-      queryMetadata: queryMetadata?.tableName,
-      dependencies: dependencyKeys
+      tableName: queryMetadata?.tableName,
+      filterConditions: queryMetadata?.filterConditions,
+      dependencies: dependencyKeys,
+      resultCount: Array.isArray(result) ? result.length : 1
     });
     return {
       type: "snapshot",
@@ -870,7 +1200,7 @@ function createReactiveHandler(config) {
         Key: { pk: connectionId, sk: request.subscriptionId }
       })
     );
-    console.log("Subscription removed:", {
+    (0, import_log.debug)("[reactive-handler] Subscription removed:", {
       connectionId,
       subscriptionId: request.subscriptionId
     });
@@ -905,7 +1235,7 @@ function createReactiveHandler(config) {
         Item: connectionEntry
       })
     );
-    console.log("Connection registered:", connectionEntry);
+    (0, import_log.debug)("[reactive-handler] Connection registered:", connectionEntry);
   }
   async function unregisterConnection(connectionId) {
     await docClient.send(
@@ -914,7 +1244,7 @@ function createReactiveHandler(config) {
         Key: { connectionId }
       })
     );
-    console.log("Connection unregistered:", connectionId);
+    (0, import_log.debug)("[reactive-handler] Connection unregistered:", connectionId);
   }
   async function query(path, input, headers) {
     const ctx = await config.getContext({ connectionId: "query", headers });
@@ -946,6 +1276,7 @@ function createReactiveHandler(config) {
     createCaller
   };
 }
+var import_log2 = __toESM(require_log());
 function createStreamHandler(config) {
   const connectionsTable = config.connectionsTableName ?? SystemTableNames.connections;
   const dependenciesTable = config.dependenciesTableName ?? SystemTableNames.dependencies;
@@ -958,6 +1289,11 @@ function createStreamHandler(config) {
     endpoint: config.apiGatewayEndpoint
   });
   async function handler(event) {
+    (0, import_log2.debug)(
+      "[stream-handler] Processing stream event with",
+      event.Records.length,
+      "records"
+    );
     const affectedSubscriptions = /* @__PURE__ */ new Map();
     for (const record of event.Records) {
       if (!record.dynamodb) continue;
@@ -976,8 +1312,15 @@ function createStreamHandler(config) {
           affectedKeys.add(key);
         }
       }
+      (0, import_log2.debug)("[stream-handler] Affected keys:", Array.from(affectedKeys));
       for (const key of affectedKeys) {
         const subscriptions = await findAffectedSubscriptions(key);
+        (0, import_log2.debug)(
+          "[stream-handler] Found",
+          subscriptions.length,
+          "subscriptions for key:",
+          key
+        );
         for (const sub of subscriptions) {
           const connId = sub.connectionId;
           const subId = sub.subscriptionId;
@@ -988,6 +1331,10 @@ function createStreamHandler(config) {
         }
       }
     }
+    (0, import_log2.debug)(
+      "[stream-handler] Total affected subscriptions:",
+      affectedSubscriptions.size
+    );
     const sendPromises = [];
     for (const [connectionId, subscriptionIds] of affectedSubscriptions) {
       for (const subscriptionId of subscriptionIds) {
@@ -1018,34 +1365,51 @@ function createStreamHandler(config) {
         subscriptionId: item.subscriptionId
       }));
     } catch (error) {
-      console.error("Error finding affected subscriptions:", error);
+      (0, import_log2.error)("[stream-handler] Error finding affected subscriptions:", error);
       return [];
     }
   }
   async function processSubscription(connectionId, subscriptionId) {
+    (0, import_log2.debug)("[stream-handler] Processing subscription:", {
+      connectionId,
+      subscriptionId
+    });
     try {
       const queryState = await getQueryState(connectionId, subscriptionId);
       if (!queryState) {
-        console.warn(
-          `Subscription not found: ${connectionId}/${subscriptionId}`
+        (0, import_log2.warn)(
+          "[stream-handler] Subscription not found:",
+          connectionId,
+          subscriptionId
         );
         return;
       }
+      (0, import_log2.debug)("[stream-handler] Query metadata:", {
+        tableName: queryState.queryMetadata.tableName,
+        filterConditions: queryState.queryMetadata.filterConditions,
+        lastResultCount: queryState.lastResult?.length
+      });
       const newResult = await executeQueryFromMetadata(
         queryState.queryMetadata
       );
+      (0, import_log2.debug)("[stream-handler] New result count:", newResult.length);
       if (!hasChanges(queryState.lastResult, newResult)) {
+        (0, import_log2.debug)("[stream-handler] No changes detected, skipping patch");
         return;
       }
       const patches = generatePatches(queryState.lastResult, newResult);
+      (0, import_log2.debug)("[stream-handler] Generated", patches.length, "patches");
       await updateQueryState(connectionId, subscriptionId, newResult);
       await sendPatch(connectionId, subscriptionId, patches);
+      (0, import_log2.debug)("[stream-handler] Patch sent successfully");
     } catch (error) {
       if (error instanceof GoneException) {
         await cleanupConnection(connectionId);
       } else {
-        console.error(
-          `Error processing subscription ${connectionId}/${subscriptionId}:`,
+        (0, import_log2.error)(
+          "[stream-handler] Error processing subscription:",
+          connectionId,
+          subscriptionId,
           error
         );
       }
@@ -1064,7 +1428,7 @@ function createStreamHandler(config) {
       );
       return response.Item ?? null;
     } catch (error) {
-      console.error("Error getting query state:", error);
+      (0, import_log2.error)("[stream-handler] Error getting query state:", error);
       return null;
     }
   }
@@ -1084,8 +1448,8 @@ function createStreamHandler(config) {
         (item) => unmarshall(item)
       );
     } catch (error) {
-      console.error("Error executing query from metadata:", error);
-      console.error("Statement:", statement);
+      (0, import_log2.error)("[stream-handler] Error executing query from metadata:", error);
+      (0, import_log2.error)("[stream-handler] Statement:", statement);
       return [];
     }
   }
@@ -1177,7 +1541,7 @@ function createStreamHandler(config) {
         })
       );
     } catch (error) {
-      console.error("Error updating query state:", error);
+      (0, import_log2.error)("[stream-handler] Error updating query state:", error);
     }
   }
   async function sendPatch(connectionId, subscriptionId, patches) {
@@ -1197,11 +1561,11 @@ function createStreamHandler(config) {
       if (error instanceof GoneException) {
         throw error;
       }
-      console.error(`Error sending patch to ${connectionId}:`, error);
+      (0, import_log2.error)("[stream-handler] Error sending patch to", connectionId, error);
     }
   }
   async function cleanupConnection(connectionId) {
-    console.log("Cleaning up disconnected connection:", connectionId);
+    (0, import_log2.info)("[stream-handler] Cleaning up disconnected connection:", connectionId);
     try {
       const queriesResponse = await docClient.send(
         new QueryCommand({
@@ -1244,11 +1608,14 @@ function createStreamHandler(config) {
           }
         })
       );
-      console.log(
-        `Cleaned up connection ${connectionId}: ${subscriptions.length} subscriptions removed`
+      (0, import_log2.info)(
+        "[stream-handler] Cleaned up connection:",
+        connectionId,
+        subscriptions.length,
+        "subscriptions removed"
       );
     } catch (error) {
-      console.error("Error cleaning up connection:", error);
+      (0, import_log2.error)("[stream-handler] Error cleaning up connection:", error);
     }
   }
   return { handler };
@@ -1271,10 +1638,10 @@ function createConnectHandler(config) {
           }
         })
       );
-      console.log("Connection established:", connectionId);
+      (0, import_log2.debug)("[stream-handler] Connection established:", connectionId);
       return { statusCode: 200 };
     } catch (error) {
-      console.error("Error creating connection:", error);
+      (0, import_log2.error)("[stream-handler] Error creating connection:", error);
       return { statusCode: 500 };
     }
   };
@@ -1294,14 +1661,15 @@ function createDisconnectHandler(config) {
           Key: { connectionId }
         })
       );
-      console.log("Connection removed:", connectionId);
+      (0, import_log2.debug)("[stream-handler] Connection removed:", connectionId);
       return { statusCode: 200 };
     } catch (error) {
-      console.error("Error removing connection:", error);
+      (0, import_log2.error)("[stream-handler] Error removing connection:", error);
       return { statusCode: 500 };
     }
   };
 }
+var import_log3 = __toESM(require_log());
 function createLambdaHandlers() {
   const connectionsTable = process.env.CONNECTIONS_TABLE ?? SystemTableNames.connections;
   const dependenciesTable = process.env.DEPENDENCIES_TABLE ?? SystemTableNames.dependencies;
@@ -1331,26 +1699,54 @@ function createLambdaHandlers() {
           Item: connectionEntry
         })
       );
-      console.log("Connection established:", connectionId);
+      (0, import_log3.info)("Connection established:", connectionId);
       return { statusCode: 200, body: "Connected" };
     } catch (error) {
-      console.error("Error creating connection:", error);
+      (0, import_log3.error)("Error creating connection:", error);
       return { statusCode: 500, body: "Failed to connect" };
     }
   }
   async function disconnectHandler(event) {
     const connectionId = event.requestContext.connectionId;
     try {
+      const subsResponse = await docClient.send(
+        new QueryCommand({
+          TableName: queriesTable,
+          KeyConditionExpression: "pk = :pk",
+          ExpressionAttributeValues: { ":pk": connectionId }
+        })
+      );
+      const subscriptions = subsResponse.Items ?? [];
+      for (const sub of subscriptions) {
+        for (const depKey of sub.dependencies ?? []) {
+          await docClient.send(
+            new DeleteCommand({
+              TableName: dependenciesTable,
+              Key: { pk: depKey, sk: `${connectionId}#${sub.sk}` }
+            })
+          );
+        }
+        await docClient.send(
+          new DeleteCommand({
+            TableName: queriesTable,
+            Key: { pk: connectionId, sk: sub.sk }
+          })
+        );
+      }
       await docClient.send(
         new DeleteCommand({
           TableName: connectionsTable,
           Key: { connectionId }
         })
       );
-      console.log("Connection removed:", connectionId);
+      (0, import_log3.info)(
+        "Connection removed:",
+        connectionId,
+        `(${subscriptions.length} subscriptions cleaned up)`
+      );
       return { statusCode: 200, body: "Disconnected" };
     } catch (error) {
-      console.error("Error removing connection:", error);
+      (0, import_log3.error)("Error removing connection:", error);
       return { statusCode: 500, body: "Failed to disconnect" };
     }
   }
@@ -1416,11 +1812,14 @@ function createLambdaHandlers() {
       );
       return { statusCode: 200, body: "OK" };
     } catch (error) {
-      console.error("Error handling message:", error);
+      (0, import_log3.error)("Error handling message:", error);
       return { statusCode: 500, body: "Internal server error" };
     }
   }
   async function streamHandler(event) {
+    (0, import_log3.info)(
+      `[stream] Processing ${event.Records.length} records from DynamoDB stream`
+    );
     const affectedSubscriptions = /* @__PURE__ */ new Map();
     for (const record of event.Records) {
       if (!record.dynamodb) continue;
@@ -1454,6 +1853,7 @@ function createLambdaHandlers() {
         }
       }
     }
+    (0, import_log3.info)(`[stream] Found ${affectedSubscriptions.size} affected connections`);
     const sendPromises = [];
     for (const [connectionId, subscriptions] of affectedSubscriptions) {
       for (const [subscriptionId] of subscriptions) {
@@ -1461,6 +1861,7 @@ function createLambdaHandlers() {
       }
     }
     await Promise.allSettled(sendPromises);
+    (0, import_log3.info)("[stream] Processing complete");
   }
   function extractTableName(record) {
     const arn = record.eventSourceARN;
@@ -1484,7 +1885,7 @@ function createLambdaHandlers() {
         subscriptionId: item.subscriptionId
       }));
     } catch (error) {
-      console.error("Error finding affected subscriptions:", error);
+      (0, import_log3.error)("Error finding affected subscriptions:", error);
       return [];
     }
   }
@@ -1498,9 +1899,7 @@ function createLambdaHandlers() {
       );
       const queryState = response.Item;
       if (!queryState) {
-        console.warn(
-          `Subscription not found: ${connectionId}/${subscriptionId}`
-        );
+        (0, import_log3.warn)(`Subscription not found: ${connectionId}/${subscriptionId}`);
         return;
       }
       const newResult = await executeQueryFromMetadata(
@@ -1525,7 +1924,7 @@ function createLambdaHandlers() {
       if (error instanceof GoneException) {
         await cleanupConnection(connectionId);
       } else {
-        console.error(
+        (0, import_log3.error)(
           `Error processing subscription ${connectionId}/${subscriptionId}:`,
           error
         );
@@ -1549,8 +1948,8 @@ function createLambdaHandlers() {
         (item) => unmarshall(item)
       );
     } catch (error) {
-      console.error("Error executing query from metadata:", error);
-      console.error("Statement:", statement);
+      (0, import_log3.error)("Error executing query from metadata:", error);
+      (0, import_log3.error)("Statement:", statement);
       return [];
     }
   }
@@ -1638,11 +2037,11 @@ function createLambdaHandlers() {
       if (error instanceof GoneException) {
         throw error;
       }
-      console.error(`Error sending patch to ${connectionId}:`, error);
+      (0, import_log3.error)(`Error sending patch to ${connectionId}:`, error);
     }
   }
   async function cleanupConnection(connectionId) {
-    console.log("Cleaning up disconnected connection:", connectionId);
+    (0, import_log3.info)("Cleaning up disconnected connection:", connectionId);
     try {
       await docClient.send(
         new DeleteCommand({
@@ -1651,7 +2050,7 @@ function createLambdaHandlers() {
         })
       );
     } catch (error) {
-      console.error("Error cleaning up connection:", error);
+      (0, import_log3.error)("Error cleaning up connection:", error);
     }
   }
   return {