@friggframework/core 2.0.0--canary.548.c8ae0ca.0 → 2.0.0--canary.545.c40eca4.0

package/websocket/repositories/websocket-connection-repository.js

@@ -1,8 +1,7 @@
 const { prisma } = require('../../database/prisma');
 const {
-    ApiGatewayManagementApiClient,
-    PostToConnectionCommand,
-} = require('@aws-sdk/client-apigatewaymanagementapi');
+    StaleConnectionError,
+} = require('../websocket-message-sender-interface');
 const {
     WebsocketConnectionRepositoryInterface,
 } = require('./websocket-connection-repository-interface');
@@ -16,15 +15,16 @@ const {
  * - PostgreSQL: Integer IDs with auto-increment
  * - Both use same query patterns (no many-to-many differences)
  *
- * Migration from Mongoose:
- * - Constructor injection of Prisma client
- * - Static method getActiveConnections() → Instance method
- * - AWS API Gateway Management API integration preserved
+ * BREAKING CHANGE (v3): A messageSender must be explicitly provided for
+ * WebSocket send functionality. For AWS API Gateway, pass
+ * `new ApiGatewayMessageSender()` from @friggframework/provider-aws.
+ * See docs/architecture-decisions/010-decouple-aws-from-core.md for migration guide.
  */
 class WebsocketConnectionRepository extends WebsocketConnectionRepositoryInterface {
-    constructor(prismaClient = prisma) {
+    constructor(prismaClient = prisma, messageSender = null) {
         super();
-        this.prisma = prismaClient; // Allow injection for testing
+        this.prisma = prismaClient;
+        this._messageSender = messageSender;
     }
 
     /**
@@ -79,25 +79,31 @@ class WebsocketConnectionRepository extends WebsocketConnectionRepositoryInterfa
                 select: { connectionId: true },
             });
 
+            if (!this._messageSender) {
+                throw new Error(
+                    'WebsocketConnectionRepository requires a messageSender for send functionality.\n' +
+                    'Pass one via constructor, e.g.:\n' +
+                    '  const { ApiGatewayMessageSender } = require("@friggframework/provider-aws");\n' +
+                    '  new WebsocketConnectionRepository(prisma, new ApiGatewayMessageSender())\n' +
+                    'See docs/architecture-decisions/010-decouple-aws-from-core.md for migration guide.'
+                );
+            }
+            const sender = this._messageSender;
+
             return connections.map((conn) => ({
                 connectionId: conn.connectionId,
                 send: async (data) => {
-                    const apigwManagementApi = new ApiGatewayManagementApiClient({
-                        endpoint: process.env.WEBSOCKET_API_ENDPOINT,
-                    });
-
                     try {
-                        const command = new PostToConnectionCommand({
-                            ConnectionId: conn.connectionId,
-                            Data: JSON.stringify(data),
-                        });
-                        await apigwManagementApi.send(command);
+                        await sender.send(
+                            conn.connectionId,
+                            data,
+                            process.env.WEBSOCKET_API_ENDPOINT
+                        );
                     } catch (error) {
-                        if (error.statusCode === 410 || error.$metadata?.httpStatusCode === 410) {
+                        if (error instanceof StaleConnectionError) {
                             console.log(
                                 `Stale connection ${conn.connectionId}`
                             );
-                            // Delete stale connection
                             await this.prisma.websocketConnection.deleteMany({
                                 where: { connectionId: conn.connectionId },
                             });

package/websocket/websocket-message-sender-interface.js

@@ -0,0 +1,38 @@
+/**
+ * WebSocket Message Sender Interface (Port)
+ *
+ * Defines the contract for sending messages to active WebSocket connections.
+ * Used by WebSocket connection repositories to push data to connected clients.
+ *
+ * Following Frigg's hexagonal architecture pattern:
+ * - Port defines WHAT the service does (contract)
+ * - Adapters implement HOW (AWS API Gateway, Netlify, etc.)
+ */
+class WebSocketMessageSenderInterface {
+    /**
+     * Send data to a specific WebSocket connection
+     *
+     * @param {string} connectionId - The WebSocket connection identifier
+     * @param {*} data - Data to send (will be JSON-serialized by the adapter)
+     * @param {string} endpoint - The WebSocket API endpoint URL
+     * @returns {Promise<void>}
+     * @throws {StaleConnectionError} If the connection is no longer active (410 Gone)
+     */
+    async send(connectionId, data, endpoint) {
+        throw new Error('Method send must be implemented by subclass');
+    }
+}
+
+/**
+ * Error thrown when a WebSocket connection is stale (disconnected).
+ * Repositories should catch this and clean up the stale connection record.
+ */
+class StaleConnectionError extends Error {
+    constructor(connectionId) {
+        super(`Stale WebSocket connection: ${connectionId}`);
+        this.name = 'StaleConnectionError';
+        this.connectionId = connectionId;
+    }
+}
+
+module.exports = { WebSocketMessageSenderInterface, StaleConnectionError };

package/database/adapters/lambda-invoker.js

@@ -1,97 +0,0 @@
-/**
- * Lambda Invoker Adapter
- * Infrastructure layer - handles AWS Lambda function invocations
- * 
- * Part of Hexagonal Architecture:
- * - Infrastructure Layer adapter for AWS SDK
- * - Used by Domain Layer use cases
- * - Isolates AWS-specific logic from business logic
- */
-
-const { LambdaClient, InvokeCommand } = require('@aws-sdk/client-lambda');
-
-/**
- * Custom error for Lambda invocation failures
- * Provides structured error information for debugging
- */
-class LambdaInvocationError extends Error {
-    constructor(message, functionName, statusCode) {
-        super(message);
-        this.name = 'LambdaInvocationError';
-        this.functionName = functionName;
-        this.statusCode = statusCode;
-    }
-}
-
-/**
- * Adapter for invoking AWS Lambda functions
- * 
- * Infrastructure layer - handles AWS SDK communication
- * Converts AWS SDK responses to domain-friendly formats
- */
-class LambdaInvoker {
-    /**
-     * @param {LambdaClient} lambdaClient - AWS Lambda client (injected for testability)
-     */
-    constructor(lambdaClient = new LambdaClient({})) {
-        this.client = lambdaClient;
-    }
-
-    /**
-     * Invoke Lambda function synchronously
-     * 
-     * @param {string} functionName - Lambda function name or ARN
-     * @param {Object} payload - Event payload to send to Lambda
-     * @returns {Promise<Object>} Parsed response body
-     * @throws {LambdaInvocationError} If Lambda returns error status
-     * @throws {Error} If AWS SDK call fails
-     */
-    async invoke(functionName, payload) {
-        try {
-            const command = new InvokeCommand({
-                FunctionName: functionName,
-                InvocationType: 'RequestResponse', // Synchronous
-                Payload: JSON.stringify(payload),
-            });
-
-            const response = await this.client.send(command);
-
-            // Parse response payload
-            let result;
-            try {
-                result = JSON.parse(Buffer.from(response.Payload).toString());
-            } catch (parseError) {
-                throw new LambdaInvocationError(
-                    `Failed to parse Lambda response: ${parseError.message}`,
-                    functionName,
-                    null
-                );
-            }
-
-            // Check status code
-            if (result.statusCode === 200) {
-                return result.body;
-            }
-
-            // Lambda returned error status
-            const errorMessage = result.body?.error || 'Lambda invocation failed';
-            throw new LambdaInvocationError(
-                `Lambda ${functionName} returned error: ${errorMessage}`,
-                functionName,
-                result.statusCode
-            );
-        } catch (error) {
-            // Re-throw LambdaInvocationError as-is
-            if (error instanceof LambdaInvocationError) {
-                throw error;
-            }
-
-            // Wrap AWS SDK errors
-            throw new Error(`Failed to invoke Lambda ${functionName}: ${error.message}`);
-        }
-    }
-}
-
-module.exports = { LambdaInvoker, LambdaInvocationError };
-
-

package/database/repositories/migration-status-repository-s3.js

@@ -1,137 +0,0 @@
-/**
- * Migration Status Repository - S3 Storage
- * 
- * Infrastructure Layer - Hexagonal Architecture
- * 
- * Stores migration status in S3 to avoid chicken-and-egg dependency on User/Process tables.
- * Initial database migrations can't use Process table (requires User FK which doesn't exist yet).
- */
-
-const { S3Client, PutObjectCommand, GetObjectCommand } = require('@aws-sdk/client-s3');
-const { randomUUID } = require('crypto');
-
-class MigrationStatusRepositoryS3 {
-    /**
-     * @param {string} bucketName - S3 bucket name for migration status storage
-     * @param {S3Client} s3Client - Optional S3 client (for testing)
-     */
-    constructor(bucketName, s3Client = null) {
-        this.bucketName = bucketName;
-        this.s3Client = s3Client || new S3Client({ region: process.env.AWS_REGION || 'us-east-1' });
-    }
-
-    /**
-     * Build S3 key for migration status
-     * @param {string} migrationId - Migration identifier
-     * @param {string} stage - Deployment stage
-     * @returns {string} S3 key
-     */
-    _buildS3Key(migrationId, stage) {
-        return `migrations/${stage}/${migrationId}.json`;
-    }
-
-    /**
-     * Create new migration status record
-     * @param {Object} data - Migration data
-     * @param {string} [data.migrationId] - Migration ID (generates UUID if not provided)
-     * @param {string} data.stage - Deployment stage
-     * @param {string} [data.triggeredBy] - User or system that triggered migration
-     * @param {string} [data.triggeredAt] - ISO timestamp
-     * @returns {Promise<Object>} Created migration status
-     */
-    async create(data) {
-        const migrationId = data.migrationId || randomUUID();
-        const timestamp = data.triggeredAt || new Date().toISOString();
-
-        const status = {
-            migrationId,
-            stage: data.stage,
-            state: 'INITIALIZING',
-            progress: 0,
-            triggeredBy: data.triggeredBy || 'system',
-            triggeredAt: timestamp,
-            createdAt: timestamp,
-            updatedAt: timestamp,
-        };
-
-        const key = this._buildS3Key(migrationId, data.stage);
-
-        await this.s3Client.send(
-            new PutObjectCommand({
-                Bucket: this.bucketName,
-                Key: key,
-                Body: JSON.stringify(status, null, 2),
-                ContentType: 'application/json',
-            })
-        );
-
-        return status;
-    }
-
-    /**
-     * Update existing migration status
-     * @param {Object} data - Update data
-     * @param {string} data.migrationId - Migration ID
-     * @param {string} data.stage - Deployment stage
-     * @param {string} [data.state] - New state
-     * @param {number} [data.progress] - Progress percentage (0-100)
-     * @param {string} [data.error] - Error message if failed
-     * @param {string} [data.completedAt] - Completion timestamp
-     * @returns {Promise<Object>} Updated migration status
-     */
-    async update(data) {
-        const key = this._buildS3Key(data.migrationId, data.stage);
-
-        // Get existing status
-        const existing = await this.get(data.migrationId, data.stage);
-
-        // Merge updates
-        const updated = {
-            ...existing,
-            ...data,
-            updatedAt: new Date().toISOString(),
-        };
-
-        await this.s3Client.send(
-            new PutObjectCommand({
-                Bucket: this.bucketName,
-                Key: key,
-                Body: JSON.stringify(updated, null, 2),
-                ContentType: 'application/json',
-            })
-        );
-
-        return updated;
-    }
-
-    /**
-     * Get migration status by ID
-     * @param {string} migrationId - Migration ID
-     * @param {string} stage - Deployment stage
-     * @returns {Promise<Object>} Migration status
-     * @throws {Error} If migration not found
-     */
-    async get(migrationId, stage) {
-        const key = this._buildS3Key(migrationId, stage);
-
-        try {
-            const response = await this.s3Client.send(
-                new GetObjectCommand({
-                    Bucket: this.bucketName,
-                    Key: key,
-                })
-            );
-
-            const body = await response.Body.transformToString();
-            return JSON.parse(body);
-        } catch (error) {
-            if (error.name === 'NoSuchKey') {
-                throw new Error(`Migration not found: ${migrationId}`);
-            }
-            throw error;
-        }
-    }
-}
-
-module.exports = { MigrationStatusRepositoryS3 };
-

package/infrastructure/scheduler/eventbridge-scheduler-adapter.js

@@ -1,184 +0,0 @@
-/**
- * EventBridge Scheduler Adapter
- *
- * Infrastructure Layer - Hexagonal Architecture
- *
- * Responsible for:
- * - Creating one-time EventBridge Scheduler schedules
- * - Deleting schedules when no longer needed
- * - Checking schedule status
- *
- * This adapter implements SchedulerServiceInterface for AWS EventBridge Scheduler.
- */
-
-const {
-    SchedulerClient,
-    CreateScheduleCommand,
-    DeleteScheduleCommand,
-    GetScheduleCommand,
-    ResourceNotFoundException,
-} = require('@aws-sdk/client-scheduler');
-
-const { SchedulerServiceInterface } = require('./scheduler-service-interface');
-
-class EventBridgeSchedulerAdapter extends SchedulerServiceInterface {
-    constructor({ region } = {}) {
-        super();
-        this.client = new SchedulerClient({
-            region: region || process.env.AWS_REGION || 'us-east-1',
-        });
-        this.scheduleGroupName =
-            process.env.SCHEDULE_GROUP_NAME || 'frigg-integration-schedules';
-        this.roleArn = process.env.SCHEDULER_ROLE_ARN;
-    }
-
-    /**
-     * Create a one-time schedule that sends a message to SQS
-     *
-     * @param {Object} params
-     * @param {string} params.scheduleName - Unique name for the schedule
-     * @param {Date} params.scheduleAt - When to trigger the schedule
-     * @param {string} params.queueResourceId - Queue resource identifier (ARN) to send message to
-     * @param {Object} params.payload - Message payload
-     * @returns {Promise<{scheduledJobId: string, scheduledAt: string}>}
-     */
-    async scheduleOneTime({ scheduleName, scheduleAt, queueResourceId, payload }) {
-        if (!scheduleName) {
-            throw new Error('scheduleName is required');
-        }
-        if (!scheduleAt || !(scheduleAt instanceof Date)) {
-            throw new Error('scheduleAt must be a valid Date object');
-        }
-        if (!queueResourceId) {
-            throw new Error('queueResourceId is required');
-        }
-        if (!this.roleArn) {
-            throw new Error(
-                'SCHEDULER_ROLE_ARN environment variable is not set'
-            );
-        }
-
-        // Format date to AWS schedule expression (at(yyyy-mm-ddThh:mm:ss))
-        const scheduleExpression = `at(${scheduleAt.toISOString().replace(/\.\d{3}Z$/, '')})`;
-
-        const command = new CreateScheduleCommand({
-            Name: scheduleName,
-            GroupName: this.scheduleGroupName,
-            ScheduleExpression: scheduleExpression,
-            ScheduleExpressionTimezone: 'UTC',
-            FlexibleTimeWindow: {
-                Mode: 'OFF',
-            },
-            Target: {
-                Arn: queueResourceId,
-                RoleArn: this.roleArn,
-                Input: JSON.stringify(payload),
-            },
-            ActionAfterCompletion: 'DELETE', // Auto-cleanup after execution
-        });
-
-        try {
-            const response = await this.client.send(command);
-            console.log(
-                `[Scheduler] Created schedule ${scheduleName} for ${scheduleAt.toISOString()}`
-            );
-
-            return {
-                scheduledJobId: response.ScheduleArn,
-                scheduledAt: scheduleAt.toISOString(),
-            };
-        } catch (error) {
-            console.error(
-                `[Scheduler] Failed to create schedule ${scheduleName}:`,
-                error.message
-            );
-            throw error;
-        }
-    }
-
-    /**
-     * Delete a schedule
-     *
-     * @param {string} scheduleName - Name of the schedule to delete
-     * @returns {Promise<void>}
-     */
-    async deleteSchedule(scheduleName) {
-        if (!scheduleName) {
-            throw new Error('scheduleName is required');
-        }
-
-        const command = new DeleteScheduleCommand({
-            Name: scheduleName,
-            GroupName: this.scheduleGroupName,
-        });
-
-        try {
-            await this.client.send(command);
-            console.log(`[Scheduler] Deleted schedule ${scheduleName}`);
-        } catch (error) {
-            if (error instanceof ResourceNotFoundException) {
-                console.log(
-                    `[Scheduler] Schedule ${scheduleName} not found (already deleted or executed)`
-                );
-                return; // Graceful handling - schedule doesn't exist
-            }
-            console.error(
-                `[Scheduler] Failed to delete schedule ${scheduleName}:`,
-                error.message
-            );
-            throw error;
-        }
-    }
-
-    /**
-     * Get schedule status
-     *
-     * @param {string} scheduleName - Name of the schedule
-     * @returns {Promise<{exists: boolean, scheduledAt?: string, state?: string}>}
-     */
-    async getScheduleStatus(scheduleName) {
-        if (!scheduleName) {
-            throw new Error('scheduleName is required');
-        }
-
-        const command = new GetScheduleCommand({
-            Name: scheduleName,
-            GroupName: this.scheduleGroupName,
-        });
-
-        try {
-            const response = await this.client.send(command);
-
-            // Parse the schedule expression to get the scheduled time
-            // Format: at(yyyy-mm-ddThh:mm:ss)
-            let scheduledAt = null;
-            if (response.ScheduleExpression) {
-                const match = response.ScheduleExpression.match(
-                    /^at\((.+)\)$/
-                );
-                if (match) {
-                    scheduledAt = new Date(match[1] + 'Z').toISOString();
-                }
-            }
-
-            return {
-                exists: true,
-                scheduledAt,
-                state: response.State,
-            };
-        } catch (error) {
-            if (error instanceof ResourceNotFoundException) {
-                return {
-                    exists: false,
-                };
-            }
-            console.error(
-                `[Scheduler] Failed to get schedule ${scheduleName}:`,
-                error.message
-            );
-            throw error;
-        }
-    }
-}
-
-module.exports = { EventBridgeSchedulerAdapter };