@friggframework/core 2.0.0--canary.461.3d6d8ad.0 → 2.0.0--canary.461.5100cd8.0

package/database/adapters/lambda-invoker.js

@@ -0,0 +1,96 @@
+/**
+ * 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/use-cases/{check-migration-status-use-case.js → check-database-state-use-case.js}

@@ -1,13 +1,13 @@
 /**
- * Check Migration Status Use Case
+ * Check Database State Use Case
  * 
- * Domain logic for checking if database has pending migrations.
- * Does NOT trigger migrations, just reports status.
+ * Domain logic for checking database state (pending migrations, errors, etc).
+ * Does NOT trigger migrations, just reports current state.
  * 
  * Architecture: Hexagonal/Clean
  * - Use Case (Domain Layer)
  * - Depends on prismaRunner (Infrastructure abstraction)
- * - Called by Router (Adapter Layer)
+ * - Called by Router or other Use Cases (Adapter Layer)
  */
 
 class ValidationError extends Error {
@@ -17,7 +17,7 @@ class ValidationError extends Error {
     }
 }
 
-class CheckMigrationStatusUseCase {
+class CheckDatabaseStateUseCase {
     /**
      * @param {Object} dependencies
      * @param {Object} dependencies.prismaRunner - Prisma runner utility
@@ -75,7 +75,7 @@ class CheckMigrationStatusUseCase {
 }
 
 module.exports = {
-    CheckMigrationStatusUseCase,
+    CheckDatabaseStateUseCase,
     ValidationError,
 };
 

package/database/use-cases/get-database-state-via-worker-use-case.js

@@ -0,0 +1,60 @@
+/**
+ * Get Database State Via Worker Use Case
+ * 
+ * Domain logic for getting database state by invoking the worker Lambda.
+ * This use case delegates to the worker Lambda which has Prisma CLI installed,
+ * keeping the router Lambda lightweight.
+ * 
+ * Architecture: Hexagonal/Clean
+ * - Use Case (Domain Layer)
+ * - Depends on LambdaInvoker (Infrastructure abstraction)
+ * - Called by Router (Adapter Layer)
+ */
+
+/**
+ * Domain Use Case: Get database state by invoking worker Lambda
+ * 
+ * This use case delegates database state checking to the worker Lambda,
+ * which has Prisma CLI installed. Keeps the router Lambda lightweight.
+ */
+class GetDatabaseStateViaWorkerUseCase {
+    /**
+     * @param {Object} dependencies
+     * @param {LambdaInvoker} dependencies.lambdaInvoker - Lambda invocation adapter
+     * @param {string} dependencies.workerFunctionName - Worker Lambda function name
+     */
+    constructor({ lambdaInvoker, workerFunctionName }) {
+        if (!lambdaInvoker) {
+            throw new Error('lambdaInvoker dependency is required');
+        }
+        if (!workerFunctionName) {
+            throw new Error('workerFunctionName is required');
+        }
+        this.lambdaInvoker = lambdaInvoker;
+        this.workerFunctionName = workerFunctionName;
+    }
+
+    /**
+     * Execute database state check via worker Lambda
+     * 
+     * @param {string} stage - Deployment stage (prod, dev, etc)
+     * @returns {Promise<Object>} Database state result
+     */
+    async execute(stage = 'production') {
+        const dbType = process.env.DB_TYPE || 'postgresql';
+
+        console.log(`Invoking worker Lambda to check database state: ${this.workerFunctionName}`);
+
+        // Invoke worker Lambda with checkStatus action
+        const result = await this.lambdaInvoker.invoke(this.workerFunctionName, {
+            action: 'checkStatus',
+            dbType,
+            stage,
+        });
+
+        return result;
+    }
+}
+
+module.exports = { GetDatabaseStateViaWorkerUseCase };
+

package/handlers/routers/db-migration.js

@@ -28,11 +28,10 @@ const {
     ValidationError: GetValidationError,
     NotFoundError,
 } = require('../../database/use-cases/get-migration-status-use-case');
+const { LambdaInvoker } = require('../../database/adapters/lambda-invoker');
 const {
-    CheckMigrationStatusUseCase,
-    ValidationError: CheckValidationError,
-} = require('../../database/use-cases/check-migration-status-use-case');
-const prismaRunner = require('../../database/utils/prisma-runner');
+    GetDatabaseStateViaWorkerUseCase,
+} = require('../../database/use-cases/get-database-state-via-worker-use-case');
 
 const router = Router();
 
@@ -46,7 +45,16 @@ const triggerMigrationUseCase = new TriggerDatabaseMigrationUseCase({
     // Note: QueuerUtil is used directly in the use case (static utility)
 });
 const getStatusUseCase = new GetMigrationStatusUseCase({ migrationStatusRepository });
-const checkMigrationStatusUseCase = new CheckMigrationStatusUseCase({ prismaRunner });
+
+// Lambda invocation for database state check (keeps router lightweight)
+const lambdaInvoker = new LambdaInvoker();
+const workerFunctionName = process.env.WORKER_FUNCTION_NAME ||
+    `${process.env.SERVICE || 'unknown'}-${process.env.STAGE || 'production'}-dbMigrationWorker`;
+
+const getDatabaseStateUseCase = new GetDatabaseStateViaWorkerUseCase({
+    lambdaInvoker,
+    workerFunctionName,
+});
 
 /**
  * Admin API key validation middleware
@@ -147,25 +155,24 @@ router.get(
     '/db-migrate/status',
     catchAsyncError(async (req, res) => {
         const stage = req.query.stage || process.env.STAGE || 'production';
-        const dbType = process.env.DB_TYPE || 'postgresql'; // Hardcoded for PostgreSQL migrations
 
-        console.log(`Checking migration status: dbType=${dbType}, stage=${stage}`);
+        console.log(`Checking database state: stage=${stage}, worker=${workerFunctionName}`);
 
         try {
-            const status = await checkMigrationStatusUseCase.execute(dbType, stage);
+            // Invoke worker Lambda to check database state
+            const status = await getDatabaseStateUseCase.execute(stage);
 
             res.status(200).json(status);
         } catch (error) {
-            // Handle validation errors (400 Bad Request)
-            if (error instanceof CheckValidationError) {
-                return res.status(400).json({
-                    success: false,
-                    error: error.message,
-                });
-            }
+            // Log full error for debugging
+            console.error('Database state check failed:', error);
 
-            // Re-throw other errors for global error handler
-            throw error;
+            // Return sanitized error to client
+            return res.status(500).json({
+                success: false,
+                error: 'Failed to check database state',
+                details: error.message,
+            });
         }
     })
 );

package/handlers/workers/db-migration.js

@@ -46,6 +46,9 @@ const {
     MigrationError,
     ValidationError,
 } = require('../../database/use-cases/run-database-migration-use-case');
+const {
+    CheckDatabaseStateUseCase,
+} = require('../../database/use-cases/check-database-state-use-case');
 const {
     MigrationStatusRepositoryS3,
 } = require('../../database/repositories/migration-status-repository-s3');
@@ -151,6 +154,45 @@ exports.handler = async (event, context) => {
     // Extract migration parameters from event
     const { migrationId, dbType, stage } = extractMigrationParams(event);
 
+    // Check for action parameter (direct invocation for status checks)
+    const action = event.action || 'migrate'; // Default to migration
+
+    // Handle checkStatus action
+    if (action === 'checkStatus') {
+        console.log(`\n========================================`);
+        console.log(`Action: checkStatus (dbType=${dbType}, stage=${stage})`);
+        console.log(`========================================`);
+
+        try {
+            const checkDbStateUseCase = new CheckDatabaseStateUseCase({ prismaRunner });
+            const status = await checkDbStateUseCase.execute(dbType, stage);
+
+            console.log('✓ Database state check completed');
+            console.log(`  Up to date: ${status.upToDate}`);
+            console.log(`  Pending migrations: ${status.pendingMigrations}`);
+
+            return {
+                statusCode: 200,
+                body: status,
+            };
+        } catch (error) {
+            console.error('❌ Database state check failed:', error.message);
+            return {
+                statusCode: 500,
+                body: {
+                    success: false,
+                    error: sanitizeError(error.message),
+                    upToDate: false,
+                },
+            };
+        }
+    }
+
+    // Otherwise, handle migration (existing code)
+    console.log(`\n========================================`);
+    console.log(`Action: migrate (migrationId=${migrationId || 'new'})`);
+    console.log(`========================================`);
+
     // Get environment variables
     const databaseUrl = process.env.DATABASE_URL;
 

package/package.json

@@ -1,10 +1,11 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.461.3d6d8ad.0",
+    "version": "2.0.0--canary.461.5100cd8.0",
     "dependencies": {
         "@aws-sdk/client-apigatewaymanagementapi": "^3.588.0",
         "@aws-sdk/client-kms": "^3.588.0",
+        "@aws-sdk/client-lambda": "^3.714.0",
         "@aws-sdk/client-sqs": "^3.588.0",
         "@hapi/boom": "^10.0.1",
         "bcryptjs": "^2.4.3",
@@ -37,9 +38,9 @@
         }
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0--canary.461.3d6d8ad.0",
-        "@friggframework/prettier-config": "2.0.0--canary.461.3d6d8ad.0",
-        "@friggframework/test": "2.0.0--canary.461.3d6d8ad.0",
+        "@friggframework/eslint-config": "2.0.0--canary.461.5100cd8.0",
+        "@friggframework/prettier-config": "2.0.0--canary.461.5100cd8.0",
+        "@friggframework/test": "2.0.0--canary.461.5100cd8.0",
         "@prisma/client": "^6.17.0",
         "@types/lodash": "4.17.15",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -79,5 +80,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "3d6d8ad065c2530fee34dcda5ee304979c718a65"
+    "gitHead": "5100cd81ceb3fe903e128b5f9530e09cb3e89495"
 }