@venturekit/runtime 0.0.0-dev.20260307234057

package/dist/ws.js

@@ -0,0 +1,277 @@
+"use strict";
+/**
+ * WebSocket Connection Store
+ *
+ * DynamoDB-backed connection management for API Gateway WebSocket APIs.
+ *
+ * Authentication:
+ *   Two-phase auth — the client connects without credentials, then sends
+ *   an { action: "auth", token: "<jwt>" } message over the encrypted channel.
+ *   The connection is stored as unauthenticated on $connect and upgraded
+ *   to authenticated via connectionStore.authenticate().
+ *   This avoids leaking JWTs in query strings, server logs, and access logs.
+ *
+ * Multi-tenancy:
+ *   If enabled, each connection stores a tenantId alongside userId.
+ *   Use sendToTenant() to broadcast within a tenant boundary.
+ *
+ * API:
+ *   connectionStore.save(connectionId)                        — $connect (unauthenticated)
+ *   connectionStore.authenticate(connectionId, metadata)      — after JWT verification
+ *   connectionStore.remove(connectionId)                      — $disconnect
+ *   connectionStore.get(connectionId)                         — single connection
+ *   connectionStore.getAll()                                  — all connections
+ *   connectionStore.getByUser(userId)                         — by user (GSI)
+ *   connectionStore.getByTenant(tenantId)                     — by tenant (GSI)
+ *   connectionStore.postToConnection(domain, stage, id, data) — send to one
+ *   connectionStore.sendToUser(domain, stage, userId, data)   — send to all user sessions
+ *   connectionStore.sendToTenant(domain, stage, tenantId, data) — broadcast within tenant
+ *   connectionStore.broadcast(domain, stage, data)            — broadcast to all
+ *
+ * Environment variables:
+ *   CONNECTIONS_TABLE — DynamoDB table name (required)
+ *
+ * DynamoDB table schema:
+ *   Partition key: connectionId (String)
+ *   TTL attribute: ttl
+ *   GSI: userId-index  (partition key: userId)
+ *   GSI: tenantId-index (partition key: tenantId) — only if multi-tenancy enabled
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectionStore = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
+const client_apigatewaymanagementapi_1 = require("@aws-sdk/client-apigatewaymanagementapi");
+const DEFAULT_TTL_SECONDS = 7200; // 2 hours
+const AUTH_GRACE_PERIOD_SECONDS = 30; // unauthenticated connections expire quickly
+function getTableName() {
+    const table = process.env.CONNECTIONS_TABLE;
+    if (!table) {
+        throw new Error('CONNECTIONS_TABLE environment variable is not set');
+    }
+    return table;
+}
+let _ddb = null;
+function ddb() {
+    if (!_ddb) {
+        _ddb = lib_dynamodb_1.DynamoDBDocumentClient.from(new client_dynamodb_1.DynamoDBClient({}));
+    }
+    return _ddb;
+}
+function encode(data) {
+    return new TextEncoder().encode(JSON.stringify(data));
+}
+/**
+ * Deliver data to a list of connections in parallel.
+ * Removes stale connections automatically.
+ * Returns count of successful deliveries.
+ */
+async function deliverToMany(store, domainName, stage, connections, data) {
+    let delivered = 0;
+    const results = await Promise.allSettled(connections
+        .filter((c) => c.authenticated)
+        .map((c) => store.postToConnection(domainName, stage, c.connectionId, data)));
+    for (const result of results) {
+        if (result.status === 'fulfilled' && result.value)
+            delivered++;
+    }
+    return delivered;
+}
+/**
+ * WebSocket connection store backed by DynamoDB.
+ *
+ * Two-phase authentication flow:
+ *
+ * 1. $connect handler:
+ * ```typescript
+ * await connectionStore.save(connectionId);
+ * // Connection is unauthenticated, TTL = 30s
+ * ```
+ *
+ * 2. Client sends auth message over the encrypted WebSocket:
+ * ```json
+ * { "action": "auth", "token": "<jwt>" }
+ * ```
+ *
+ * 3. $default handler verifies JWT, then:
+ * ```typescript
+ * await connectionStore.authenticate(connectionId, { userId, tenantId, email });
+ * // Connection is now authenticated, TTL extended to 2h
+ * ```
+ */
+exports.connectionStore = {
+    /**
+     * Save a new connection on $connect.
+     * The connection is unauthenticated with a short TTL.
+     * The client must send an auth message to upgrade.
+     */
+    async save(connectionId) {
+        const now = Date.now();
+        await ddb().send(new lib_dynamodb_1.PutCommand({
+            TableName: getTableName(),
+            Item: {
+                connectionId,
+                authenticated: false,
+                connectedAt: now,
+                ttl: Math.floor(now / 1000) + AUTH_GRACE_PERIOD_SECONDS,
+            },
+        }));
+    },
+    /**
+     * Authenticate a connection after JWT verification.
+     * Updates the record with user metadata and extends the TTL.
+     *
+     * @param connectionId — the connection to authenticate
+     * @param metadata — must include userId, optionally tenantId, email, etc.
+     */
+    async authenticate(connectionId, metadata) {
+        const now = Date.now();
+        const { userId, tenantId, email, ...extra } = metadata;
+        const updateParts = [
+            'authenticated = :auth',
+            'userId = :uid',
+            'authenticatedAt = :authAt',
+            'ttl = :ttl',
+        ];
+        const values = {
+            ':auth': true,
+            ':uid': userId,
+            ':authAt': now,
+            ':ttl': Math.floor(now / 1000) + DEFAULT_TTL_SECONDS,
+        };
+        if (tenantId) {
+            updateParts.push('tenantId = :tid');
+            values[':tid'] = tenantId;
+        }
+        if (email) {
+            updateParts.push('email = :email');
+            values[':email'] = email;
+        }
+        // Store any extra metadata fields
+        let extraIdx = 0;
+        for (const [key, val] of Object.entries(extra)) {
+            const placeholder = `:extra${extraIdx}`;
+            updateParts.push(`#extra${extraIdx} = ${placeholder}`);
+            values[placeholder] = val;
+            extraIdx++;
+        }
+        const names = {};
+        for (let i = 0; i < extraIdx; i++) {
+            names[`#extra${i}`] = Object.keys(extra)[i];
+        }
+        await ddb().send(new lib_dynamodb_1.UpdateCommand({
+            TableName: getTableName(),
+            Key: { connectionId },
+            UpdateExpression: `SET ${updateParts.join(', ')}`,
+            ExpressionAttributeValues: values,
+            ...(extraIdx > 0 ? { ExpressionAttributeNames: names } : {}),
+        }));
+    },
+    /**
+     * Remove a connection on $disconnect.
+     */
+    async remove(connectionId) {
+        await ddb().send(new lib_dynamodb_1.DeleteCommand({
+            TableName: getTableName(),
+            Key: { connectionId },
+        }));
+    },
+    /**
+     * Get a single connection record.
+     */
+    async get(connectionId) {
+        const result = await ddb().send(new lib_dynamodb_1.GetCommand({
+            TableName: getTableName(),
+            Key: { connectionId },
+        }));
+        return result.Item ?? null;
+    },
+    /**
+     * Get all authenticated connections.
+     * For large-scale apps, prefer getByUser() or getByTenant().
+     */
+    async getAll() {
+        const result = await ddb().send(new lib_dynamodb_1.ScanCommand({
+            TableName: getTableName(),
+            FilterExpression: 'authenticated = :auth',
+            ExpressionAttributeValues: { ':auth': true },
+        }));
+        return (result.Items ?? []);
+    },
+    /**
+     * Get all connections for a specific user.
+     * A user can have multiple active connections (e.g. multiple tabs/devices).
+     * Requires GSI: userId-index (partition key: userId).
+     */
+    async getByUser(userId) {
+        const result = await ddb().send(new lib_dynamodb_1.QueryCommand({
+            TableName: getTableName(),
+            IndexName: 'userId-index',
+            KeyConditionExpression: 'userId = :uid',
+            ExpressionAttributeValues: { ':uid': userId },
+        }));
+        return (result.Items ?? []);
+    },
+    /**
+     * Get all connections for a specific tenant.
+     * Requires GSI: tenantId-index (partition key: tenantId).
+     */
+    async getByTenant(tenantId) {
+        const result = await ddb().send(new lib_dynamodb_1.QueryCommand({
+            TableName: getTableName(),
+            IndexName: 'tenantId-index',
+            KeyConditionExpression: 'tenantId = :tid',
+            ExpressionAttributeValues: { ':tid': tenantId },
+        }));
+        return (result.Items ?? []);
+    },
+    /**
+     * Send data to a specific connection via API Gateway Management API.
+     * Automatically cleans up stale connections (GoneException).
+     * Returns true if sent, false if the connection was stale and removed.
+     */
+    async postToConnection(domainName, stage, connectionId, data) {
+        const apigw = new client_apigatewaymanagementapi_1.ApiGatewayManagementApiClient({
+            endpoint: `https://${domainName}/${stage}`,
+        });
+        try {
+            await apigw.send(new client_apigatewaymanagementapi_1.PostToConnectionCommand({
+                ConnectionId: connectionId,
+                Data: encode(data),
+            }));
+            return true;
+        }
+        catch (err) {
+            if (err instanceof client_apigatewaymanagementapi_1.GoneException) {
+                await this.remove(connectionId);
+                return false;
+            }
+            throw err;
+        }
+    },
+    /**
+     * Send data to all connections belonging to a specific user.
+     * Returns the number of connections that received the message.
+     */
+    async sendToUser(domainName, stage, userId, data) {
+        const connections = await this.getByUser(userId);
+        return deliverToMany(this, domainName, stage, connections, data);
+    },
+    /**
+     * Send data to all connections within a specific tenant.
+     * Returns the number of connections that received the message.
+     */
+    async sendToTenant(domainName, stage, tenantId, data) {
+        const connections = await this.getByTenant(tenantId);
+        return deliverToMany(this, domainName, stage, connections, data);
+    },
+    /**
+     * Broadcast data to all authenticated connections.
+     * Returns the number of clients that received the message.
+     */
+    async broadcast(domainName, stage, data) {
+        const connections = await this.getAll();
+        return deliverToMany(this, domainName, stage, connections, data);
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ws.js","sourceRoot":"","sources":["../src/ws.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * WebSocket Connection Store\n * \n * DynamoDB-backed connection management for API Gateway WebSocket APIs.\n * \n * Authentication:\n *   Two-phase auth — the client connects without credentials, then sends\n *   an { action: \"auth\", token: \"<jwt>\" } message over the encrypted channel.\n *   The connection is stored as unauthenticated on $connect and upgraded\n *   to authenticated via connectionStore.authenticate().\n *   This avoids leaking JWTs in query strings, server logs, and access logs.\n * \n * Multi-tenancy:\n *   If enabled, each connection stores a tenantId alongside userId.\n *   Use sendToTenant() to broadcast within a tenant boundary.\n * \n * API:\n *   connectionStore.save(connectionId)                        — $connect (unauthenticated)\n *   connectionStore.authenticate(connectionId, metadata)      — after JWT verification\n *   connectionStore.remove(connectionId)                      — $disconnect\n *   connectionStore.get(connectionId)                         — single connection\n *   connectionStore.getAll()                                  — all connections\n *   connectionStore.getByUser(userId)                         — by user (GSI)\n *   connectionStore.getByTenant(tenantId)                     — by tenant (GSI)\n *   connectionStore.postToConnection(domain, stage, id, data) — send to one\n *   connectionStore.sendToUser(domain, stage, userId, data)   — send to all user sessions\n *   connectionStore.sendToTenant(domain, stage, tenantId, data) — broadcast within tenant\n *   connectionStore.broadcast(domain, stage, data)            — broadcast to all\n * \n * Environment variables:\n *   CONNECTIONS_TABLE — DynamoDB table name (required)\n * \n * DynamoDB table schema:\n *   Partition key: connectionId (String)\n *   TTL attribute: ttl\n *   GSI: userId-index  (partition key: userId)\n *   GSI: tenantId-index (partition key: tenantId) — only if multi-tenancy enabled\n */\n\nimport { DynamoDBClient } from '@aws-sdk/client-dynamodb';\nimport {\n  DynamoDBDocumentClient,\n  PutCommand,\n  GetCommand,\n  UpdateCommand,\n  DeleteCommand,\n  ScanCommand,\n  QueryCommand,\n} from '@aws-sdk/lib-dynamodb';\nimport {\n  ApiGatewayManagementApiClient,\n  PostToConnectionCommand,\n  GoneException,\n} from '@aws-sdk/client-apigatewaymanagementapi';\n\nexport interface ConnectionRecord {\n  connectionId: string;\n  authenticated: boolean;\n  userId?: string;\n  tenantId?: string;\n  email?: string;\n  connectedAt: number;\n  authenticatedAt?: number;\n  ttl: number;\n  [key: string]: unknown;\n}\n\nexport interface ConnectionMetadata {\n  userId: string;\n  tenantId?: string;\n  email?: string;\n  [key: string]: unknown;\n}\n\nconst DEFAULT_TTL_SECONDS = 7200; // 2 hours\nconst AUTH_GRACE_PERIOD_SECONDS = 30; // unauthenticated connections expire quickly\n\nfunction getTableName(): string {\n  const table = process.env.CONNECTIONS_TABLE;\n  if (!table) {\n    throw new Error('CONNECTIONS_TABLE environment variable is not set');\n  }\n  return table;\n}\n\nlet _ddb: DynamoDBDocumentClient | null = null;\n\nfunction ddb(): DynamoDBDocumentClient {\n  if (!_ddb) {\n    _ddb = DynamoDBDocumentClient.from(new DynamoDBClient({}));\n  }\n  return _ddb;\n}\n\nfunction encode(data: unknown): Uint8Array {\n  return new TextEncoder().encode(JSON.stringify(data));\n}\n\n/**\n * Deliver data to a list of connections in parallel.\n * Removes stale connections automatically.\n * Returns count of successful deliveries.\n */\nasync function deliverToMany(\n  store: typeof connectionStore,\n  domainName: string,\n  stage: string,\n  connections: ConnectionRecord[],\n  data: unknown,\n): Promise<number> {\n  let delivered = 0;\n  const results = await Promise.allSettled(\n    connections\n      .filter((c) => c.authenticated)\n      .map((c) => store.postToConnection(domainName, stage, c.connectionId, data)),\n  );\n  for (const result of results) {\n    if (result.status === 'fulfilled' && result.value) delivered++;\n  }\n  return delivered;\n}\n\n/**\n * WebSocket connection store backed by DynamoDB.\n * \n * Two-phase authentication flow:\n * \n * 1. $connect handler:\n * ```typescript\n * await connectionStore.save(connectionId);\n * // Connection is unauthenticated, TTL = 30s\n * ```\n * \n * 2. Client sends auth message over the encrypted WebSocket:\n * ```json\n * { \"action\": \"auth\", \"token\": \"<jwt>\" }\n * ```\n * \n * 3. $default handler verifies JWT, then:\n * ```typescript\n * await connectionStore.authenticate(connectionId, { userId, tenantId, email });\n * // Connection is now authenticated, TTL extended to 2h\n * ```\n */\nexport const connectionStore = {\n  /**\n   * Save a new connection on $connect.\n   * The connection is unauthenticated with a short TTL.\n   * The client must send an auth message to upgrade.\n   */\n  async save(connectionId: string): Promise<void> {\n    const now = Date.now();\n    await ddb().send(new PutCommand({\n      TableName: getTableName(),\n      Item: {\n        connectionId,\n        authenticated: false,\n        connectedAt: now,\n        ttl: Math.floor(now / 1000) + AUTH_GRACE_PERIOD_SECONDS,\n      },\n    }));\n  },\n\n  /**\n   * Authenticate a connection after JWT verification.\n   * Updates the record with user metadata and extends the TTL.\n   * \n   * @param connectionId — the connection to authenticate\n   * @param metadata — must include userId, optionally tenantId, email, etc.\n   */\n  async authenticate(connectionId: string, metadata: ConnectionMetadata): Promise<void> {\n    const now = Date.now();\n    const { userId, tenantId, email, ...extra } = metadata;\n\n    const updateParts = [\n      'authenticated = :auth',\n      'userId = :uid',\n      'authenticatedAt = :authAt',\n      'ttl = :ttl',\n    ];\n    const values: Record<string, unknown> = {\n      ':auth': true,\n      ':uid': userId,\n      ':authAt': now,\n      ':ttl': Math.floor(now / 1000) + DEFAULT_TTL_SECONDS,\n    };\n\n    if (tenantId) {\n      updateParts.push('tenantId = :tid');\n      values[':tid'] = tenantId;\n    }\n\n    if (email) {\n      updateParts.push('email = :email');\n      values[':email'] = email;\n    }\n\n    // Store any extra metadata fields\n    let extraIdx = 0;\n    for (const [key, val] of Object.entries(extra)) {\n      const placeholder = `:extra${extraIdx}`;\n      updateParts.push(`#extra${extraIdx} = ${placeholder}`);\n      values[placeholder] = val;\n      extraIdx++;\n    }\n\n    const names: Record<string, string> = {};\n    for (let i = 0; i < extraIdx; i++) {\n      names[`#extra${i}`] = Object.keys(extra)[i];\n    }\n\n    await ddb().send(new UpdateCommand({\n      TableName: getTableName(),\n      Key: { connectionId },\n      UpdateExpression: `SET ${updateParts.join(', ')}`,\n      ExpressionAttributeValues: values,\n      ...(extraIdx > 0 ? { ExpressionAttributeNames: names } : {}),\n    }));\n  },\n\n  /**\n   * Remove a connection on $disconnect.\n   */\n  async remove(connectionId: string): Promise<void> {\n    await ddb().send(new DeleteCommand({\n      TableName: getTableName(),\n      Key: { connectionId },\n    }));\n  },\n\n  /**\n   * Get a single connection record.\n   */\n  async get(connectionId: string): Promise<ConnectionRecord | null> {\n    const result = await ddb().send(new GetCommand({\n      TableName: getTableName(),\n      Key: { connectionId },\n    }));\n    return (result.Item as ConnectionRecord) ?? null;\n  },\n\n  /**\n   * Get all authenticated connections.\n   * For large-scale apps, prefer getByUser() or getByTenant().\n   */\n  async getAll(): Promise<ConnectionRecord[]> {\n    const result = await ddb().send(new ScanCommand({\n      TableName: getTableName(),\n      FilterExpression: 'authenticated = :auth',\n      ExpressionAttributeValues: { ':auth': true },\n    }));\n    return (result.Items ?? []) as ConnectionRecord[];\n  },\n\n  /**\n   * Get all connections for a specific user.\n   * A user can have multiple active connections (e.g. multiple tabs/devices).\n   * Requires GSI: userId-index (partition key: userId).\n   */\n  async getByUser(userId: string): Promise<ConnectionRecord[]> {\n    const result = await ddb().send(new QueryCommand({\n      TableName: getTableName(),\n      IndexName: 'userId-index',\n      KeyConditionExpression: 'userId = :uid',\n      ExpressionAttributeValues: { ':uid': userId },\n    }));\n    return (result.Items ?? []) as ConnectionRecord[];\n  },\n\n  /**\n   * Get all connections for a specific tenant.\n   * Requires GSI: tenantId-index (partition key: tenantId).\n   */\n  async getByTenant(tenantId: string): Promise<ConnectionRecord[]> {\n    const result = await ddb().send(new QueryCommand({\n      TableName: getTableName(),\n      IndexName: 'tenantId-index',\n      KeyConditionExpression: 'tenantId = :tid',\n      ExpressionAttributeValues: { ':tid': tenantId },\n    }));\n    return (result.Items ?? []) as ConnectionRecord[];\n  },\n\n  /**\n   * Send data to a specific connection via API Gateway Management API.\n   * Automatically cleans up stale connections (GoneException).\n   * Returns true if sent, false if the connection was stale and removed.\n   */\n  async postToConnection(\n    domainName: string,\n    stage: string,\n    connectionId: string,\n    data: unknown,\n  ): Promise<boolean> {\n    const apigw = new ApiGatewayManagementApiClient({\n      endpoint: `https://${domainName}/${stage}`,\n    });\n\n    try {\n      await apigw.send(new PostToConnectionCommand({\n        ConnectionId: connectionId,\n        Data: encode(data),\n      }));\n      return true;\n    } catch (err) {\n      if (err instanceof GoneException) {\n        await this.remove(connectionId);\n        return false;\n      }\n      throw err;\n    }\n  },\n\n  /**\n   * Send data to all connections belonging to a specific user.\n   * Returns the number of connections that received the message.\n   */\n  async sendToUser(\n    domainName: string,\n    stage: string,\n    userId: string,\n    data: unknown,\n  ): Promise<number> {\n    const connections = await this.getByUser(userId);\n    return deliverToMany(this, domainName, stage, connections, data);\n  },\n\n  /**\n   * Send data to all connections within a specific tenant.\n   * Returns the number of connections that received the message.\n   */\n  async sendToTenant(\n    domainName: string,\n    stage: string,\n    tenantId: string,\n    data: unknown,\n  ): Promise<number> {\n    const connections = await this.getByTenant(tenantId);\n    return deliverToMany(this, domainName, stage, connections, data);\n  },\n\n  /**\n   * Broadcast data to all authenticated connections.\n   * Returns the number of clients that received the message.\n   */\n  async broadcast(domainName: string, stage: string, data: unknown): Promise<number> {\n    const connections = await this.getAll();\n    return deliverToMany(this, domainName, stage, connections, data);\n  },\n};\n"]}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@venturekit/runtime",
+  "version": "0.0.0-dev.20260307234057",
+  "description": "VentureKit runtime utilities - handlers, context, middleware, logging",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/venturekit-dev/venturekit.private.git",
+    "directory": "packages/runtime"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "keywords": [
+    "venturekit",
+    "saas",
+    "lambda",
+    "runtime"
+  ],
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@venturekit/core": "0.0.0-dev.20260307234057",
+    "pino": "^9.0.0"
+  },
+  "peerDependencies": {
+    "@venturekit/data": "0.0.0-dev.20260307234057",
+    "@aws-sdk/client-dynamodb": "^3.500.0",
+    "@aws-sdk/lib-dynamodb": "^3.500.0",
+    "@aws-sdk/client-apigatewaymanagementapi": "^3.500.0"
+  },
+  "peerDependenciesMeta": {
+    "@venturekit/data": {
+      "optional": true
+    },
+    "@aws-sdk/client-dynamodb": {
+      "optional": true
+    },
+    "@aws-sdk/lib-dynamodb": {
+      "optional": true
+    },
+    "@aws-sdk/client-apigatewaymanagementapi": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@venturekit/data": "0.0.0-dev.20260307234057",
+    "@types/aws-lambda": "^8.10.131",
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist"
+  }
+}