@friggframework/devtools 2.0.0-next.1 → 2.0.0-next.10

package/frigg-cli/build-command/index.js

@@ -0,0 +1,33 @@
+const { spawn } = require('child_process');
+const path = require('path');
+
+function buildCommand(options) {
+    console.log('Building the serverless application...');
+    const backendPath = path.resolve(process.cwd());
+    const infrastructurePath = 'infrastructure.js';
+    const command = 'serverless';
+    const serverlessArgs = [
+        'package',
+        '--config',
+        infrastructurePath,
+        '--stage',
+        options.stage
+    ];
+
+    const childProcess = spawn(command, serverlessArgs, {
+        cwd: backendPath,
+        stdio: 'inherit',
+    });
+
+    childProcess.on('error', (error) => {
+        console.error(`Error executing command: ${error.message}`);
+    });
+
+    childProcess.on('close', (code) => {
+        if (code !== 0) {
+            console.log(`Child process exited with code ${code}`);
+        }
+    });
+}
+
+module.exports = { buildCommand };

package/frigg-cli/deploy-command/index.js

@@ -0,0 +1,33 @@
+const { spawn } = require('child_process');
+const path = require('path');
+
+function deployCommand(options) {
+    console.log('Deploying the serverless application...');
+    const backendPath = path.resolve(process.cwd());
+    const infrastructurePath = 'infrastructure.js';
+    const command = 'serverless';
+    const serverlessArgs = [
+        'deploy',
+        '--config',
+        infrastructurePath,
+        '--stage',
+        options.stage
+    ];
+
+    const childProcess = spawn(command, serverlessArgs, {
+        cwd: backendPath,
+        stdio: 'inherit',
+    });
+
+    childProcess.on('error', (error) => {
+        console.error(`Error executing command: ${error.message}`);
+    });
+
+    childProcess.on('close', (code) => {
+        if (code !== 0) {
+            console.log(`Child process exited with code ${code}`);
+        }
+    });
+}
+
+module.exports = { deployCommand };

package/frigg-cli/index.js

@@ -3,6 +3,8 @@
 const { Command } = require('commander');
 const { installCommand } = require('./install-command');
 const { startCommand } = require('./start-command'); // Assuming you have a startCommand module
+const { buildCommand } = require('./build-command');
+const { deployCommand } = require('./deploy-command');
 
 const program = new Command();
 program
@@ -13,8 +15,21 @@ program
 program
     .command('start')
     .description('Run the backend and optional frontend')
+    .option('-s, --stage <stage>', 'deployment stage', 'dev')
     .action(startCommand);
 
+program
+    .command('build')
+    .description('Build the serverless application')
+    .option('-s, --stage <stage>', 'deployment stage', 'dev')
+    .action(buildCommand);
+
+program
+    .command('deploy')
+    .description('Deploy the serverless application')
+    .option('-s, --stage <stage>', 'deployment stage', 'dev')
+    .action(deployCommand);
+
 program.parse(process.argv);
 
-module.exports = { installCommand, startCommand };
+module.exports = { installCommand, startCommand, buildCommand, deployCommand };

package/frigg-cli/start-command/index.js

@@ -1,7 +1,7 @@
 const { spawn } = require('child_process');
 const path = require('path');
 
-function startCommand() {
+function startCommand(options) {
     console.log('Starting backend and optional frontend...');
     // Suppress AWS SDK warning message about maintenance mode
     process.env.AWS_SDK_JS_SUPPRESS_MAINTENANCE_MODE_MESSAGE = 1;
@@ -9,7 +9,13 @@ function startCommand() {
     console.log(`Starting backend in ${backendPath}...`);
     const infrastructurePath = 'infrastructure.js';
     const command = 'serverless';
-    const args = ['offline', '--config', infrastructurePath, '--stage=dev'];
+    const args = [
+        'offline',
+        '--config',
+        infrastructurePath,
+        '--stage',
+        options.stage
+    ];
 
     const childProcess = spawn(command, args, {
         cwd: backendPath,

package/index.js

@@ -1,5 +1,7 @@
 const test = require('./test');
+const { createFriggInfrastructure } = require('./infrastructure');
 
 module.exports = {
-    ...test
-}
+    createFriggInfrastructure,
+    ...test,
+};

package/infrastructure/create-frigg-infrastructure.js

@@ -0,0 +1,38 @@
+const path = require('path');
+const fs = require('fs-extra');
+const { composeServerlessDefinition } = require('./serverless-template');
+
+const {
+    findNearestBackendPackageJson,
+} = require('../frigg-cli/utils/backend-path');
+
+function createFriggInfrastructure() {
+    const backendPath = findNearestBackendPackageJson();
+    if (!backendPath) {
+        throw new Error('Could not find backend package.json');
+    }
+
+    const backendDir = path.dirname(backendPath);
+    const backendFilePath = path.join(backendDir, 'index.js');
+    if (!fs.existsSync(backendFilePath)) {
+        throw new Error('Could not find index.js');
+    }
+
+    const backend = require(backendFilePath);
+    const appDefinition = backend.Definition;
+
+    // const serverlessTemplate = require(path.resolve(
+    //     __dirname,
+    //     './serverless-template.js'
+    // ));
+    const definition = composeServerlessDefinition(
+        appDefinition,
+        backend.IntegrationFactory
+    );
+
+    return {
+        ...definition,
+    };
+}
+
+module.exports = { createFriggInfrastructure };

package/infrastructure/index.js

@@ -0,0 +1,4 @@
+const { createFriggInfrastructure } = require('./create-frigg-infrastructure');
+module.exports = {
+    createFriggInfrastructure,
+};

package/infrastructure/serverless-template.js

@@ -0,0 +1,283 @@
+const path = require('path');
+const fs = require('fs');
+
+const composeServerlessDefinition = (AppDefinition) => {
+    const definition = {
+        frameworkVersion: '>=3.17.0',
+        service: AppDefinition.name || 'create-frigg-app',
+        package: {
+            individually: true,
+        },
+        useDotenv: true,
+        provider: {
+            name: AppDefinition.provider || 'aws',
+            runtime: 'nodejs20.x',
+            timeout: 30,
+            region: 'us-east-1',
+            stage: '${opt:stage}',
+            environment: {
+                STAGE: '${opt:stage}',
+                AWS_NODEJS_CONNECTION_REUSE_ENABLED: 1,
+            },
+            iamRoleStatements: [
+                {
+                    Effect: 'Allow',
+                    Action: ['sns:Publish'],
+                    Resource: {
+                        Ref: 'InternalErrorBridgeTopic',
+                    },
+                },
+            ],
+        },
+        plugins: [
+            // 'serverless-webpack',
+            'serverless-dotenv-plugin',
+            'serverless-offline-sqs',
+            'serverless-offline',
+            '@friggframework/serverless-plugin',
+        ],
+        custom: {
+            'serverless-offline': {
+                httpPort: 3001,
+                lambdaPort: 4001,
+                websocketPort: 3002,
+            },
+            'serverless-offline-sqs': {
+                autoCreate: false,
+                apiVersion: '2012-11-05',
+                endpoint: 'http://localhost:4566',
+                region: 'us-east-1',
+                accessKeyId: 'root',
+                secretAccessKey: 'root',
+                skipCacheInvalidation: false,
+            },
+            webpack: {
+                webpackConfig: 'webpack.config.js',
+                includeModules: {
+                    forceExclude: ['aws-sdk'],
+                },
+                packager: 'npm',
+                excludeFiles: ['src/**/*.test.js', 'test/'],
+            },
+        },
+        functions: {
+            defaultWebsocket: {
+                handler: 'node_modules/@friggframework/core/handlers/routers/websocket.handler',
+                events: [
+                    {
+                        websocket: {
+                            route: '$connect',
+                        },
+                    },
+                    {
+                        websocket: {
+                            route: '$default',
+                        },
+                    },
+                    {
+                        websocket: {
+                            route: '$disconnect',
+                        },
+                    },
+                ],
+            },
+            auth: {
+                handler: 'node_modules/@friggframework/core/handlers/routers/auth.handler',
+                events: [
+                    {
+                        http: {
+                            path: '/api/integrations',
+                            method: 'ANY',
+                            cors: true,
+                        },
+                    },
+                    {
+                        http: {
+                            path: '/api/integrations/{proxy+}',
+                            method: 'ANY',
+                            cors: true,
+                        },
+                    },
+                    {
+                        http: {
+                            path: '/api/authorize',
+                            method: 'ANY',
+                            cors: true,
+                        },
+                    },
+                ],
+            },
+            user: {
+                handler: 'node_modules/@friggframework/core/handlers/routers/user.handler',
+                events: [
+                    {
+                        http: {
+                            path: '/user/{proxy+}',
+                            method: 'ANY',
+                            cors: true,
+                        },
+                    },
+                ],
+            },
+        },
+        resources: {
+            Resources: {
+                InternalErrorQueue: {
+                    Type: 'AWS::SQS::Queue',
+                    Properties: {
+                        QueueName:
+                            'internal-error-queue-${self:provider.stage}',
+                        MessageRetentionPeriod: 300,
+                    },
+                },
+                InternalErrorBridgeTopic: {
+                    Type: 'AWS::SNS::Topic',
+                    Properties: {
+                        Subscription: [
+                            {
+                                Protocol: 'sqs',
+                                Endpoint: {
+                                    'Fn::GetAtt': ['InternalErrorQueue', 'Arn'],
+                                },
+                            },
+                        ],
+                    },
+                },
+                InternalErrorBridgePolicy: {
+                    Type: 'AWS::SQS::QueuePolicy',
+                    Properties: {
+                        Queues: [{ Ref: 'InternalErrorQueue' }],
+                        PolicyDocument: {
+                            Version: '2012-10-17',
+                            Statement: [
+                                {
+                                    Sid: 'Allow Dead Letter SNS to publish to SQS',
+                                    Effect: 'Allow',
+                                    Principal: {
+                                        Service: 'sns.amazonaws.com',
+                                    },
+                                    Resource: {
+                                        'Fn::GetAtt': [
+                                            'InternalErrorQueue',
+                                            'Arn',
+                                        ],
+                                    },
+                                    Action: [
+                                        'SQS:SendMessage',
+                                        'SQS:SendMessageBatch',
+                                    ],
+                                    Condition: {
+                                        ArnEquals: {
+                                            'aws:SourceArn': {
+                                                Ref: 'InternalErrorBridgeTopic',
+                                            },
+                                        },
+                                    },
+                                },
+                            ],
+                        },
+                    },
+                },
+                ApiGatewayAlarm5xx: {
+                    Type: 'AWS::CloudWatch::Alarm',
+                    Properties: {
+                        AlarmDescription: 'API Gateway 5xx Errors',
+                        Namespace: 'AWS/ApiGateway',
+                        MetricName: '5XXError',
+                        Statistic: 'Sum',
+                        Threshold: 0,
+                        ComparisonOperator: 'GreaterThanThreshold',
+                        EvaluationPeriods: 1,
+                        Period: 60,
+                        AlarmActions: [{ Ref: 'InternalErrorBridgeTopic' }],
+                        Dimensions: [
+                            {
+                                Name: 'ApiName',
+                                Value: {
+                                    'Fn::Join': [
+                                        '-',
+                                        [
+                                            '${self:provider.stage}',
+                                            '${self:service}',
+                                        ],
+                                    ],
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+        },
+    };
+
+    // Add integration-specific functions and resources
+    for (const integration of AppDefinition.integrations) {
+        const integrationName = integration.Definition.name;
+
+        // Add function for the integration
+        definition.functions[integrationName] = {
+            handler: `node_modules/@friggframework/core/handlers/routers/integration-defined-routers.handlers.${integrationName}.handler`,
+            events: [
+                {
+                    http: {
+                        path: `/api/${integrationName}-integration/{proxy+}`,
+                        method: 'ANY',
+                        cors: true,
+                    },
+                },
+            ],
+        };
+
+        // Add SQS Queue for the integration
+        const queueReference = `${
+            integrationName.charAt(0).toUpperCase() + integrationName.slice(1)
+        }Queue`;
+        const queueName = `\${self:service}--\${self:provider.stage}-${queueReference}`;
+        definition.resources.Resources[queueReference] = {
+            Type: 'AWS::SQS::Queue',
+            Properties: {
+                QueueName: `\${self:custom.${queueReference}}`,
+                MessageRetentionPeriod: 60,
+                VisibilityTimeout: 1800,  // 30 minutes
+                RedrivePolicy: {
+                    maxReceiveCount: 1,
+                    deadLetterTargetArn: {
+                        'Fn::GetAtt': ['InternalErrorQueue', 'Arn'],
+                    },
+                },
+            },
+        };
+
+        // Add Queue Worker for the integration
+        const queueWorkerName = `${integrationName}QueueWorker`;
+        definition.functions[queueWorkerName] = {
+            handler: `node_modules/@friggframework/core/handlers/workers/integration-defined-workers.handlers.${integrationName}.queueWorker`,
+            reservedConcurrency: 5,
+            events: [
+                {
+                    sqs: {
+                        arn: {
+                            'Fn::GetAtt': [queueReference, 'Arn'],
+                        },
+                        batchSize: 1,
+                    },
+                },
+            ],
+            timeout: 600,
+        };
+
+        // Add Queue URL for the integration to the ENVironment variables
+        definition.provider.environment = {
+            ...definition.provider.environment,
+            [`${integrationName.toUpperCase()}_QUEUE_URL`]: {
+                Ref: queueReference,
+            },
+        };
+
+        definition.custom[queueReference] = queueName;
+    }
+
+    return definition;
+};
+
+module.exports = { composeServerlessDefinition };

package/infrastructure/webpack.config.js

@@ -0,0 +1,20 @@
+const slsw = require('serverless-webpack');
+const webpack = require('webpack');
+const path = require('path');
+const CopyPlugin = require('copy-webpack-plugin');
+
+
+module.exports = {
+    devtool: 'source-map',
+    entry: slsw.lib.entries,
+    mode: slsw.lib.webpack.isLocal ? 'development' : 'production',
+    target: 'node',
+    externals: ['mongoose', 'express', 'node-fetch'],
+    plugins: [
+        // This defines the window global (with value of `undefined`).
+        new webpack.ProvidePlugin({
+            window: path.resolve(path.join(__dirname, 'src/utils/webpackFakeWindow')),
+        }),
+    ]
+
+};

package/package.json

@@ -1,15 +1,18 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0-next.1",
+  "version": "2.0.0-next.10",
   "dependencies": {
     "@babel/eslint-parser": "^7.18.9",
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
-    "@friggframework/core": "2.0.0-next.1",
-    "@friggframework/test": "2.0.0-next.1",
+    "@friggframework/test": "2.0.0-next.10",
+    "@hapi/boom": "^7.4.11",
+    "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.2",
+    "body-parser": "^1.20.2",
     "commander": "^12.1.0",
+    "cors": "^2.8.5",
     "dotenv": "^16.4.5",
     "eslint": "^8.22.0",
     "eslint-config-prettier": "^8.5.0",
@@ -17,12 +20,20 @@
     "eslint-plugin-markdown": "^3.0.0",
     "eslint-plugin-no-only-tests": "^3.0.0",
     "eslint-plugin-yaml": "^0.5.0",
+    "express": "^4.19.2",
+    "express-async-handler": "^1.2.0",
     "fs-extra": "^11.2.0",
-    "inquirer": "^10.1.6"
+    "lodash": "^4.17.21",
+    "serverless-http": "^2.7.0"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0-next.1",
-    "@friggframework/prettier-config": "2.0.0-next.1"
+    "@friggframework/eslint-config": "2.0.0-next.10",
+    "@friggframework/prettier-config": "2.0.0-next.10",
+    "serverless": "3.39.0",
+    "serverless-dotenv-plugin": "^6.0.0",
+    "serverless-offline": "^13.8.0",
+    "serverless-offline-sqs": "^8.0.0",
+    "serverless-webpack": "^5.14.1"
   },
   "scripts": {
     "lint:fix": "prettier --write --loglevel error . && eslint . --fix",
@@ -46,5 +57,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "44b619e288b23d879673518076cf9e4acacb3c71"
+  "gitHead": "67dc76e94c02c0074f7ff2d7292c4d2203bf3949"
 }