@venturekit/runtime 0.0.0-dev.20260307234057

package/dist/middleware.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * VentureKit Middleware
+ *
+ * Composable middleware for request processing.
+ * Extensible for auth, tenancy, rate limiting, etc.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compose = compose;
+exports.loggingMiddleware = loggingMiddleware;
+exports.corsMiddleware = corsMiddleware;
+exports.timeoutMiddleware = timeoutMiddleware;
+exports.errorBoundaryMiddleware = errorBoundaryMiddleware;
+/**
+ * Compose multiple middleware into a single function
+ */
+function compose(middlewares) {
+    return async (ctx, finalHandler) => {
+        let index = -1;
+        const dispatch = async (i) => {
+            if (i <= index) {
+                throw new Error('next() called multiple times');
+            }
+            index = i;
+            if (i >= middlewares.length) {
+                return finalHandler();
+            }
+            const middleware = middlewares[i];
+            return middleware.fn(ctx, () => dispatch(i + 1));
+        };
+        return dispatch(0);
+    };
+}
+/**
+ * Logging middleware - logs request/response
+ */
+function loggingMiddleware(logger) {
+    return {
+        name: 'logging',
+        fn: async (ctx, next) => {
+            const start = Date.now();
+            logger.info('Request started', {
+                method: ctx.method,
+                path: ctx.path,
+                sourceIp: ctx.sourceIp,
+            });
+            try {
+                const response = await next();
+                const duration = Date.now() - start;
+                logger.info('Request completed', {
+                    method: ctx.method,
+                    path: ctx.path,
+                    statusCode: typeof response === 'object' ? response.statusCode : undefined,
+                    duration,
+                });
+                return response;
+            }
+            catch (error) {
+                const duration = Date.now() - start;
+                logger.error('Request failed', {
+                    method: ctx.method,
+                    path: ctx.path,
+                    duration,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                });
+                throw error;
+            }
+        },
+    };
+}
+/**
+ * CORS middleware - adds CORS headers
+ */
+function corsMiddleware(options) {
+    return {
+        name: 'cors',
+        fn: async (ctx, next) => {
+            const origin = ctx.rawEvent.headers?.origin || '';
+            const allowedOrigin = options.allowOrigins.includes('*')
+                ? '*'
+                : options.allowOrigins.includes(origin)
+                    ? origin
+                    : '';
+            // Handle preflight
+            if (ctx.method === 'OPTIONS') {
+                return {
+                    statusCode: 204,
+                    headers: {
+                        'Access-Control-Allow-Origin': allowedOrigin,
+                        'Access-Control-Allow-Methods': options.allowMethods.join(', '),
+                        'Access-Control-Allow-Headers': options.allowHeaders.join(', '),
+                        'Access-Control-Allow-Credentials': String(options.allowCredentials),
+                        'Access-Control-Max-Age': String(options.maxAge),
+                    },
+                    body: '',
+                };
+            }
+            const response = await next();
+            // Add CORS headers to response
+            if (typeof response !== 'object' || response === null) {
+                return response;
+            }
+            const resp = response;
+            const corsHeaders = {
+                'Access-Control-Allow-Origin': allowedOrigin,
+            };
+            if (options.allowCredentials) {
+                corsHeaders['Access-Control-Allow-Credentials'] = 'true';
+            }
+            resp.headers = { ...resp.headers, ...corsHeaders };
+            return resp;
+        },
+    };
+}
+/**
+ * Timeout middleware - enforces request timeout
+ */
+function timeoutMiddleware(timeoutMs) {
+    return {
+        name: 'timeout',
+        fn: async (ctx, next) => {
+            const timeoutPromise = new Promise((_, reject) => {
+                setTimeout(() => {
+                    reject(new Error(`Request timeout after ${timeoutMs}ms`));
+                }, timeoutMs);
+            });
+            return Promise.race([next(), timeoutPromise]);
+        },
+    };
+}
+/**
+ * Error boundary middleware - catches and formats errors
+ */
+function errorBoundaryMiddleware(errorHandler) {
+    return {
+        name: 'errorBoundary',
+        fn: async (ctx, next) => {
+            try {
+                return await next();
+            }
+            catch (error) {
+                return errorHandler(error, ctx);
+            }
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"middleware.js","sourceRoot":"","sources":["../src/middleware.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * VentureKit Middleware\n * \n * Composable middleware for request processing.\n * Extensible for auth, tenancy, rate limiting, etc.\n */\n\nimport type { APIGatewayProxyEventV2, APIGatewayProxyResultV2, APIGatewayProxyStructuredResultV2 } from 'aws-lambda';\nimport { RequestContext } from './context';\nimport { Logger } from './logger';\n\n/**\n * Middleware function signature\n */\nexport type MiddlewareFn = (\n  ctx: RequestContext,\n  next: () => Promise<APIGatewayProxyResultV2>\n) => Promise<APIGatewayProxyResultV2>;\n\n/**\n * Middleware with configuration\n */\nexport interface Middleware {\n  name: string;\n  fn: MiddlewareFn;\n}\n\n/**\n * Compose multiple middleware into a single function\n */\nexport function compose(middlewares: Middleware[]): MiddlewareFn {\n  return async (ctx: RequestContext, finalHandler: () => Promise<APIGatewayProxyResultV2>) => {\n    let index = -1;\n\n    const dispatch = async (i: number): Promise<APIGatewayProxyResultV2> => {\n      if (i <= index) {\n        throw new Error('next() called multiple times');\n      }\n      index = i;\n\n      if (i >= middlewares.length) {\n        return finalHandler();\n      }\n\n      const middleware = middlewares[i];\n      return middleware.fn(ctx, () => dispatch(i + 1));\n    };\n\n    return dispatch(0);\n  };\n}\n\n/**\n * Logging middleware - logs request/response\n */\nexport function loggingMiddleware(logger: Logger): Middleware {\n  return {\n    name: 'logging',\n    fn: async (ctx, next) => {\n      const start = Date.now();\n      \n      logger.info('Request started', {\n        method: ctx.method,\n        path: ctx.path,\n        sourceIp: ctx.sourceIp,\n      });\n\n      try {\n        const response = await next();\n        const duration = Date.now() - start;\n\n        logger.info('Request completed', {\n          method: ctx.method,\n          path: ctx.path,\n          statusCode: typeof response === 'object' ? (response as any).statusCode : undefined,\n          duration,\n        });\n\n        return response;\n      } catch (error) {\n        const duration = Date.now() - start;\n\n        logger.error('Request failed', {\n          method: ctx.method,\n          path: ctx.path,\n          duration,\n          error: error instanceof Error ? error.message : 'Unknown error',\n        });\n\n        throw error;\n      }\n    },\n  };\n}\n\n/**\n * CORS middleware - adds CORS headers\n */\nexport function corsMiddleware(options: {\n  allowOrigins: string[];\n  allowMethods: string[];\n  allowHeaders: string[];\n  allowCredentials: boolean;\n  maxAge: number;\n}): Middleware {\n  return {\n    name: 'cors',\n    fn: async (ctx, next) => {\n      const origin = ctx.rawEvent.headers?.origin || '';\n      const allowedOrigin = options.allowOrigins.includes('*')\n        ? '*'\n        : options.allowOrigins.includes(origin)\n          ? origin\n          : '';\n\n      // Handle preflight\n      if (ctx.method === 'OPTIONS') {\n        return {\n          statusCode: 204,\n          headers: {\n            'Access-Control-Allow-Origin': allowedOrigin,\n            'Access-Control-Allow-Methods': options.allowMethods.join(', '),\n            'Access-Control-Allow-Headers': options.allowHeaders.join(', '),\n            'Access-Control-Allow-Credentials': String(options.allowCredentials),\n            'Access-Control-Max-Age': String(options.maxAge),\n          },\n          body: '',\n        };\n      }\n\n      const response = await next();\n\n      // Add CORS headers to response\n      if (typeof response !== 'object' || response === null) {\n        return response;\n      }\n      const resp = response as APIGatewayProxyStructuredResultV2;\n      const corsHeaders: Record<string, string> = {\n        'Access-Control-Allow-Origin': allowedOrigin,\n      };\n      if (options.allowCredentials) {\n        corsHeaders['Access-Control-Allow-Credentials'] = 'true';\n      }\n      resp.headers = { ...resp.headers, ...corsHeaders };\n      return resp;\n    },\n  };\n}\n\n/**\n * Timeout middleware - enforces request timeout\n */\nexport function timeoutMiddleware(timeoutMs: number): Middleware {\n  return {\n    name: 'timeout',\n    fn: async (ctx, next) => {\n      const timeoutPromise = new Promise<never>((_, reject) => {\n        setTimeout(() => {\n          reject(new Error(`Request timeout after ${timeoutMs}ms`));\n        }, timeoutMs);\n      });\n\n      return Promise.race([next(), timeoutPromise]);\n    },\n  };\n}\n\n/**\n * Error boundary middleware - catches and formats errors\n */\nexport function errorBoundaryMiddleware(\n  errorHandler: (error: unknown, ctx: RequestContext) => APIGatewayProxyResultV2\n): Middleware {\n  return {\n    name: 'errorBoundary',\n    fn: async (ctx, next) => {\n      try {\n        return await next();\n      } catch (error) {\n        return errorHandler(error, ctx);\n      }\n    },\n  };\n}\n"]}

package/dist/response.d.ts

@@ -0,0 +1,75 @@
+/**
+ * VentureKit Response Utilities
+ *
+ * Standardized response formatting for API Gateway.
+ */
+import type { APIGatewayProxyResultV2 } from 'aws-lambda';
+import { VentureError } from './errors';
+/**
+ * Standard success response
+ */
+export interface SuccessResponse<T = unknown> {
+    data: T;
+    meta?: {
+        requestId?: string;
+        timestamp?: string;
+        pagination?: {
+            page: number;
+            pageSize: number;
+            total: number;
+            totalPages: number;
+        };
+    };
+}
+/**
+ * Standard error response
+ */
+export interface ErrorResponse {
+    error: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown>;
+    };
+    meta?: {
+        requestId?: string;
+        timestamp?: string;
+    };
+}
+/**
+ * Create a success response
+ */
+export declare function success<T>(data: T, options?: {
+    statusCode?: number;
+    headers?: Record<string, string>;
+    requestId?: string;
+}): APIGatewayProxyResultV2;
+/**
+ * Create a created response (201)
+ */
+export declare function created<T>(data: T, options?: {
+    headers?: Record<string, string>;
+    requestId?: string;
+}): APIGatewayProxyResultV2;
+/**
+ * Create a no content response (204)
+ */
+export declare function noContent(options?: {
+    requestId?: string;
+}): APIGatewayProxyResultV2;
+/**
+ * Create an error response from a VentureError
+ */
+export declare function error(err: VentureError, options?: {
+    requestId?: string;
+}): APIGatewayProxyResultV2;
+/**
+ * Convert any error to an API Gateway response
+ */
+export declare function errorResponse(err: unknown, options?: {
+    requestId?: string;
+    logError?: boolean;
+}): APIGatewayProxyResultV2;
+/**
+ * Create a redirect response
+ */
+export declare function redirect(location: string, permanent?: boolean): APIGatewayProxyResultV2;

package/dist/response.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * VentureKit Response Utilities
+ *
+ * Standardized response formatting for API Gateway.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.success = success;
+exports.created = created;
+exports.noContent = noContent;
+exports.error = error;
+exports.errorResponse = errorResponse;
+exports.redirect = redirect;
+const errors_1 = require("./errors");
+/**
+ * Create a success response
+ */
+function success(data, options = {}) {
+    const { statusCode = 200, headers = {}, requestId } = options;
+    const body = {
+        data,
+        ...(requestId && {
+            meta: {
+                requestId,
+                timestamp: new Date().toISOString(),
+            },
+        }),
+    };
+    return {
+        statusCode,
+        headers: {
+            'Content-Type': 'application/json',
+            ...headers,
+        },
+        body: JSON.stringify(body),
+    };
+}
+/**
+ * Create a created response (201)
+ */
+function created(data, options = {}) {
+    return success(data, { ...options, statusCode: 201 });
+}
+/**
+ * Create a no content response (204)
+ */
+function noContent(options = {}) {
+    return {
+        statusCode: 204,
+        body: '',
+        headers: options.requestId ? { 'x-request-id': options.requestId } : undefined,
+    };
+}
+/**
+ * Create an error response from a VentureError
+ */
+function error(err, options = {}) {
+    const { requestId } = options;
+    const body = {
+        error: {
+            code: err.code,
+            message: err.message,
+            ...(err.details && { details: err.details }),
+        },
+        ...(requestId && {
+            meta: {
+                requestId,
+                timestamp: new Date().toISOString(),
+            },
+        }),
+    };
+    return {
+        statusCode: err.statusCode,
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+    };
+}
+/**
+ * Convert any error to an API Gateway response
+ */
+function errorResponse(err, options = {}) {
+    const { requestId, logError = true } = options;
+    if ((0, errors_1.isVentureError)(err)) {
+        return error(err, { requestId });
+    }
+    // Log unexpected errors
+    if (logError) {
+        console.error('Unexpected error:', err);
+    }
+    // Wrap in InternalError for consistent response
+    return error(new errors_1.InternalError(), { requestId });
+}
+/**
+ * Create a redirect response
+ */
+function redirect(location, permanent = false) {
+    return {
+        statusCode: permanent ? 301 : 302,
+        headers: {
+            Location: location,
+        },
+        body: '',
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ws.d.ts

@@ -0,0 +1,138 @@
+/**
+ * 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
+ */
+export interface ConnectionRecord {
+    connectionId: string;
+    authenticated: boolean;
+    userId?: string;
+    tenantId?: string;
+    email?: string;
+    connectedAt: number;
+    authenticatedAt?: number;
+    ttl: number;
+    [key: string]: unknown;
+}
+export interface ConnectionMetadata {
+    userId: string;
+    tenantId?: string;
+    email?: string;
+    [key: string]: unknown;
+}
+/**
+ * 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
+ * ```
+ */
+export declare const connectionStore: {
+    /**
+     * Save a new connection on $connect.
+     * The connection is unauthenticated with a short TTL.
+     * The client must send an auth message to upgrade.
+     */
+    save(connectionId: string): Promise<void>;
+    /**
+     * 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.
+     */
+    authenticate(connectionId: string, metadata: ConnectionMetadata): Promise<void>;
+    /**
+     * Remove a connection on $disconnect.
+     */
+    remove(connectionId: string): Promise<void>;
+    /**
+     * Get a single connection record.
+     */
+    get(connectionId: string): Promise<ConnectionRecord | null>;
+    /**
+     * Get all authenticated connections.
+     * For large-scale apps, prefer getByUser() or getByTenant().
+     */
+    getAll(): Promise<ConnectionRecord[]>;
+    /**
+     * 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).
+     */
+    getByUser(userId: string): Promise<ConnectionRecord[]>;
+    /**
+     * Get all connections for a specific tenant.
+     * Requires GSI: tenantId-index (partition key: tenantId).
+     */
+    getByTenant(tenantId: string): Promise<ConnectionRecord[]>;
+    /**
+     * 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.
+     */
+    postToConnection(domainName: string, stage: string, connectionId: string, data: unknown): Promise<boolean>;
+    /**
+     * Send data to all connections belonging to a specific user.
+     * Returns the number of connections that received the message.
+     */
+    sendToUser(domainName: string, stage: string, userId: string, data: unknown): Promise<number>;
+    /**
+     * Send data to all connections within a specific tenant.
+     * Returns the number of connections that received the message.
+     */
+    sendToTenant(domainName: string, stage: string, tenantId: string, data: unknown): Promise<number>;
+    /**
+     * Broadcast data to all authenticated connections.
+     * Returns the number of clients that received the message.
+     */
+    broadcast(domainName: string, stage: string, data: unknown): Promise<number>;
+};