dynamodb-reactive 0.1.1 → 0.1.4

package/dist/server.js

@@ -2,7 +2,7 @@ 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 jsonpatch from 'fast-json-patch';
 import { ApiGatewayManagementApiClient, PostToConnectionCommand, GoneException } from '@aws-sdk/client-apigatewaymanagementapi';
 
 // ../server/src/procedure.ts
@@ -683,6 +683,7 @@ var DependencyTracker = class {
     this.operations = [];
   }
 };
+var { applyPatch, compare } = jsonpatch;
 function generatePatches(oldValue, newValue) {
   const operations = compare(
     oldValue,
@@ -741,31 +742,35 @@ function batchPatches(patchSets) {
 }
 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 prefix = config.tablePrefix ? `${config.tablePrefix}-` : "";
+  const connectionsTable = `${prefix}${SystemTableNames.connections}`;
+  const dependenciesTable = `${prefix}${SystemTableNames.dependencies}`;
+  const queriesTable = `${prefix}${SystemTableNames.queries}`;
   const ddbClient = new DynamoDBClient({
     region: config.dbConfig?.region ?? process.env.AWS_REGION
   });
-  const docClient = DynamoDBDocumentClient.from(ddbClient);
-  async function handleRequest(connectionId, request) {
+  const docClient = DynamoDBDocumentClient.from(ddbClient, {
+    marshallOptions: { removeUndefinedValues: true }
+  });
+  async function handleRequest(request, headers) {
     try {
-      const ctx = await config.getContext(connectionId);
+      const connectionId = request.connectionId;
+      const ctx = await config.getContext({ connectionId, headers });
       const dependencyTracker = new DependencyTracker();
       const db = createDbContext(config.dbConfig ?? {}, dependencyTracker);
       const fullCtx = { ...ctx, db };
       switch (request.type) {
         case "subscribe":
-          return handleSubscribe(
+          return await handleSubscribe(
             connectionId,
             request,
             fullCtx,
             dependencyTracker
           );
         case "unsubscribe":
-          return handleUnsubscribe(connectionId, request);
+          return await handleUnsubscribe(connectionId, request);
         case "call":
-          return handleCall(request, fullCtx);
+          return await handleCall(request, fullCtx);
         default:
           return {
             type: "error",
@@ -776,6 +781,7 @@ function createReactiveHandler(config) {
       return {
         type: "error",
         message: error instanceof Error ? error.message : "Unknown error",
+        code: error.code,
         subscriptionId: "subscriptionId" in request ? request.subscriptionId : void 0
       };
     }
@@ -910,13 +916,38 @@ function createReactiveHandler(config) {
     );
     console.log("Connection unregistered:", connectionId);
   }
+  async function query(path, input, headers) {
+    const ctx = await config.getContext({ connectionId: "query", headers });
+    const dependencyTracker = new DependencyTracker();
+    const db = createDbContext(config.dbConfig ?? {}, dependencyTracker);
+    const fullCtx = { ...ctx, db };
+    return config.router.execute(path, fullCtx, input);
+  }
+  function createCaller() {
+    function buildProxy(path = []) {
+      return new Proxy(() => {
+      }, {
+        get(_target, prop) {
+          return buildProxy([...path, prop]);
+        },
+        apply(_target, _thisArg, args) {
+          const procedurePath = path.join(".");
+          return query(procedurePath, args[0]);
+        }
+      });
+    }
+    return buildProxy();
+  }
   return {
     handleRequest,
     registerConnection,
-    unregisterConnection
+    unregisterConnection,
+    query,
+    createCaller
   };
 }
 function createStreamHandler(config) {
+  const connectionsTable = config.connectionsTableName ?? SystemTableNames.connections;
   const dependenciesTable = config.dependenciesTableName ?? SystemTableNames.dependencies;
   const queriesTable = config.queriesTableName ?? SystemTableNames.queries;
   const ddbClient = new DynamoDBClient({
@@ -1083,6 +1114,7 @@ function createStreamHandler(config) {
           return `"${field}" <= ${escapedValue}`;
         case "between":
           return `"${field}" BETWEEN ${escapedValue} AND ${escapeValue(value2)}`;
+        case void 0:
         default:
           return "";
       }
@@ -1094,6 +1126,7 @@ function createStreamHandler(config) {
           return `begins_with("${field}", ${escapedValue})`;
         case "contains":
           return `contains("${field}", ${escapedValue})`;
+        case void 0:
         default:
           return "";
       }
@@ -1108,6 +1141,7 @@ function createStreamHandler(config) {
           return `(${subclauses.join(" OR ")})`;
         case "not":
           return subclauses.length > 0 ? `NOT (${subclauses[0]})` : "";
+        case void 0:
         default:
           return "";
       }
@@ -1168,6 +1202,54 @@ function createStreamHandler(config) {
   }
   async function cleanupConnection(connectionId) {
     console.log("Cleaning up disconnected connection:", connectionId);
+    try {
+      const queriesResponse = await docClient.send(
+        new QueryCommand({
+          TableName: queriesTable,
+          KeyConditionExpression: "pk = :pk",
+          ExpressionAttributeValues: {
+            ":pk": connectionId
+          }
+        })
+      );
+      const subscriptions = queriesResponse.Items ?? [];
+      for (const sub of subscriptions) {
+        const deps = sub.dependencies ?? [];
+        for (const depKey of deps) {
+          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(
+        `Cleaned up connection ${connectionId}: ${subscriptions.length} subscriptions removed`
+      );
+    } catch (error) {
+      console.error("Error cleaning up connection:", error);
+    }
   }
   return { handler };
 }
@@ -1287,6 +1369,13 @@ function createLambdaHandlers() {
       const { type, subscriptionId } = body;
       let response;
       switch (type) {
+        case "init": {
+          response = {
+            type: "connected",
+            connectionId
+          };
+          break;
+        }
         case "unsubscribe": {
           const subResponse = await docClient.send(
             new GetCommand({
@@ -1416,7 +1505,9 @@ function createLambdaHandlers() {
         );
         return;
       }
-      const newResult = await executeQueryFromMetadata(queryState.queryMetadata);
+      const newResult = await executeQueryFromMetadata(
+        queryState.queryMetadata
+      );
       if (!hasChanges(queryState.lastResult, newResult)) {
         return;
       }
@@ -1490,6 +1581,7 @@ function createLambdaHandlers() {
           return `"${field}" <= ${escapedValue}`;
         case "between":
           return `"${field}" BETWEEN ${escapedValue} AND ${escapeValue(value2)}`;
+        case void 0:
         default:
           return "";
       }
@@ -1501,6 +1593,7 @@ function createLambdaHandlers() {
           return `begins_with("${field}", ${escapedValue})`;
         case "contains":
           return `contains("${field}", ${escapedValue})`;
+        case void 0:
         default:
           return "";
       }
@@ -1515,6 +1608,7 @@ function createLambdaHandlers() {
           return `(${subclauses.join(" OR ")})`;
         case "not":
           return subclauses.length > 0 ? `NOT (${subclauses[0]})` : "";
+        case void 0:
         default:
           return "";
       }