@friggframework/devtools 2.0.0-next.0 → 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

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
 
 const { Command } = require('commander');
-const { installCommand } = require('./installCommand');
+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
@@ -9,6 +12,24 @@ program
     .description('Install an API module')
     .action(installCommand);
 
+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 };
+module.exports = { installCommand, startCommand, buildCommand, deployCommand };

package/frigg-cli/index.test.js

@@ -1,12 +1,15 @@
 const { Command } = require('commander');
 const { installCommand } = require('./index');
-const { validatePackageExists } = require('./validatePackage');
-const { findNearestBackendPackageJson, validateBackendPath } = require('./backendPath');
-const { installPackage } = require('./installPackage');
-const { createIntegrationFile } = require('./integrationFile');
-const { updateBackendJsFile } = require('./backendJs');
-const { commitChanges } = require('./commitChanges');
-const { logInfo, logError } = require('./logger');
+const { validatePackageExists } = require('./install-command/validate-package');
+const {
+    findNearestBackendPackageJson,
+    validateBackendPath,
+} = require('./utils/backend-path');
+const { installPackage } = require('./install-command/install-package');
+const { createIntegrationFile } = require('./install-command/integration-file');
+const { updateBackendJsFile } = require('./install-command/backend-js');
+const { commitChanges } = require('./install-command/commit-changes');
+const { logInfo, logError } = require('./install-command/logger');
 
 describe('CLI Command Tests', () => {
     it('should successfully install an API module when all steps complete without errors', async () => {
@@ -14,26 +17,28 @@ describe('CLI Command Tests', () => {
         const mockPackageName = `@friggframework/api-module-${mockApiModuleName}`;
         const mockBackendPath = '/mock/backend/path';
 
-        jest.mock('./validatePackage', () => ({
+        jest.mock('./install-command/validate-package', () => ({
             validatePackageExists: jest.fn().mockResolvedValue(true),
         }));
-        jest.mock('./backendPath', () => ({
-            findNearestBackendPackageJson: jest.fn().mockReturnValue(mockBackendPath),
+        jest.mock('./utils/backend-path', () => ({
+            findNearestBackendPackageJson: jest
+                .fn()
+                .mockReturnValue(mockBackendPath),
             validateBackendPath: jest.fn().mockReturnValue(true),
         }));
-        jest.mock('./installPackage', () => ({
+        jest.mock('./install-command/install-package', () => ({
             installPackage: jest.fn().mockReturnValue(true),
         }));
-        jest.mock('./integrationFile', () => ({
+        jest.mock('./install-command/integration-file', () => ({
             createIntegrationFile: jest.fn().mockReturnValue(true),
         }));
-        jest.mock('./backendJs', () => ({
+        jest.mock('./install-command/backend-js', () => ({
             updateBackendJsFile: jest.fn().mockReturnValue(true),
         }));
-        jest.mock('./commitChanges', () => ({
+        jest.mock('./install-command/commit-changes', () => ({
             commitChanges: jest.fn().mockReturnValue(true),
         }));
-        jest.mock('./logger', () => ({
+        jest.mock('./install-command/logger', () => ({
             logInfo: jest.fn(),
             logError: jest.fn(),
         }));
@@ -49,19 +54,42 @@ describe('CLI Command Tests', () => {
         expect(validatePackageExists).toHaveBeenCalledWith(mockPackageName);
         expect(findNearestBackendPackageJson).toHaveBeenCalled();
         expect(validateBackendPath).toHaveBeenCalledWith(mockBackendPath);
-        expect(installPackage).toHaveBeenCalledWith(mockBackendPath, mockPackageName);
-        expect(createIntegrationFile).toHaveBeenCalledWith(mockBackendPath, mockApiModuleName);
-        expect(updateBackendJsFile).toHaveBeenCalledWith(mockBackendPath, mockApiModuleName);
-        expect(commitChanges).toHaveBeenCalledWith(mockBackendPath, mockApiModuleName);
-        expect(logInfo).toHaveBeenCalledWith(`Successfully installed ${mockPackageName} and updated the project.`);
+        expect(installPackage).toHaveBeenCalledWith(
+            mockBackendPath,
+            mockPackageName
+        );
+        expect(createIntegrationFile).toHaveBeenCalledWith(
+            mockBackendPath,
+            mockApiModuleName
+        );
+        expect(updateBackendJsFile).toHaveBeenCalledWith(
+            mockBackendPath,
+            mockApiModuleName
+        );
+        expect(commitChanges).toHaveBeenCalledWith(
+            mockBackendPath,
+            mockApiModuleName
+        );
+        expect(logInfo).toHaveBeenCalledWith(
+            `Successfully installed ${mockPackageName} and updated the project.`
+        );
     });
 
     it('should log an error and exit with code 1 if the package does not exist', async () => {
-        const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {});
-        const mockLogError = jest.spyOn(require('./logger'), 'logError').mockImplementation(() => {});
-        const mockValidatePackageExists = jest.spyOn(require('./validatePackage'), 'validatePackageExists').mockImplementation(() => {
-            throw new Error('Package not found');
-        });
+        const mockExit = jest
+            .spyOn(process, 'exit')
+            .mockImplementation(() => {});
+        const mockLogError = jest
+            .spyOn(require('./install-command/logger'), 'logError')
+            .mockImplementation(() => {});
+        const mockValidatePackageExists = jest
+            .spyOn(
+                require('./install-command/validate-package'),
+                'validatePackageExists'
+            )
+            .mockImplementation(() => {
+                throw new Error('Package not found');
+            });
 
         const program = new Command();
         program
@@ -71,8 +99,13 @@ describe('CLI Command Tests', () => {
 
         await program.parseAsync(['node', 'install', 'nonexistent-package']);
 
-        expect(mockValidatePackageExists).toHaveBeenCalledWith('@friggframework/api-module-nonexistent-package');
-        expect(mockLogError).toHaveBeenCalledWith('An error occurred:', expect.any(Error));
+        expect(mockValidatePackageExists).toHaveBeenCalledWith(
+            '@friggframework/api-module-nonexistent-package'
+        );
+        expect(mockLogError).toHaveBeenCalledWith(
+            'An error occurred:',
+            expect.any(Error)
+        );
         expect(mockExit).toHaveBeenCalledWith(1);
 
         mockExit.mockRestore();
@@ -81,13 +114,29 @@ describe('CLI Command Tests', () => {
     });
 
     it('should log an error and exit with code 1 if the backend path is invalid', async () => {
-        const mockLogError = jest.spyOn(require('./logger'), 'logError').mockImplementation(() => {});
-        const mockProcessExit = jest.spyOn(process, 'exit').mockImplementation(() => {});
-        const mockValidatePackageExists = jest.spyOn(require('./validatePackage'), 'validatePackageExists').mockResolvedValue(true);
-        const mockFindNearestBackendPackageJson = jest.spyOn(require('./backendPath'), 'findNearestBackendPackageJson').mockReturnValue('/invalid/path');
-        const mockValidateBackendPath = jest.spyOn(require('./backendPath'), 'validateBackendPath').mockImplementation(() => {
-            throw new Error('Invalid backend path');
-        });
+        const mockLogError = jest
+            .spyOn(require('./install-command/logger'), 'logError')
+            .mockImplementation(() => {});
+        const mockProcessExit = jest
+            .spyOn(process, 'exit')
+            .mockImplementation(() => {});
+        const mockValidatePackageExists = jest
+            .spyOn(
+                require('./install-command/validate-package'),
+                'validatePackageExists'
+            )
+            .mockResolvedValue(true);
+        const mockFindNearestBackendPackageJson = jest
+            .spyOn(
+                require('./utils/backend-path'),
+                'findNearestBackendPackageJson'
+            )
+            .mockReturnValue('/invalid/path');
+        const mockValidateBackendPath = jest
+            .spyOn(require('./utils/backend-path'), 'validateBackendPath')
+            .mockImplementation(() => {
+                throw new Error('Invalid backend path');
+            });
 
         const program = new Command();
         program
@@ -97,7 +146,10 @@ describe('CLI Command Tests', () => {
 
         await program.parseAsync(['node', 'install', 'test-module']);
 
-        expect(mockLogError).toHaveBeenCalledWith('An error occurred:', expect.any(Error));
+        expect(mockLogError).toHaveBeenCalledWith(
+            'An error occurred:',
+            expect.any(Error)
+        );
         expect(mockProcessExit).toHaveBeenCalledWith(1);
 
         mockLogError.mockRestore();

package/frigg-cli/{environmentVariables.js → install-command/environment-variables.js}

@@ -3,8 +3,7 @@ const dotenv = require('dotenv');
 const { readFileSync, writeFileSync, existsSync } = require('fs');
 const { logInfo } = require('./logger');
 const { resolve } = require('node:path');
-const inquirer = require('inquirer');
-
+const { confirm, input } = require('@inquirer/prompts');
 const { parse } = require('@babel/parser');
 const traverse = require('@babel/traverse').default;
 
@@ -82,26 +81,20 @@ const handleEnvVariables = async (backendPath, modulePath) => {
         logInfo(`Missing environment variables: ${missingEnvVars.join(', ')}`);
 
         if (missingEnvVars.length > 0) {
-            const { addEnvVars } = await inquirer.prompt([
-                {
-                    type: 'confirm',
-                    name: 'addEnvVars',
-                    message: `The following environment variables are required: ${missingEnvVars.join(
-                        ', '
-                    )}. Do you want to add them now?`,
-                },
-            ]);
+            const addEnvVars = await confirm({
+                message: `The following environment variables are required: ${missingEnvVars.join(
+                    ', '
+                )}. Do you want to add them now?`,
+            });
 
             if (addEnvVars) {
                 const envValues = {};
                 for (const envVar of missingEnvVars) {
-                    const { value } = await inquirer.prompt([
-                        {
-                            type: 'input',
-                            name: 'value',
-                            message: `Enter value for ${envVar}:`,
-                        },
-                    ]);
+                    const value = await input({
+                        type: 'input',
+                        name: 'value',
+                        message: `Enter value for ${envVar}:`,
+                    });
                     envValues[envVar] = value;
                 }
 

package/frigg-cli/install-command/environment-variables.test.js

@@ -0,0 +1,136 @@
+const { handleEnvVariables } = require('./environment-variables');
+const { logInfo } = require('./logger');
+const inquirer = require('inquirer');
+const fs = require('fs');
+const dotenv = require('dotenv');
+const { resolve } = require('node:path');
+const { parse } = require('@babel/parser');
+const traverse = require('@babel/traverse');
+
+jest.mock('inquirer');
+jest.mock('fs');
+jest.mock('dotenv');
+jest.mock('./logger');
+jest.mock('@babel/parser');
+jest.mock('@babel/traverse');
+
+describe('handleEnvVariables', () => {
+    const backendPath = '/mock/backend/path';
+    const modulePath = '/mock/module/path';
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        fs.readFileSync.mockReturnValue(`
+            const Definition = {
+                env: {
+                    client_id: process.env.GOOGLE_CALENDAR_CLIENT_ID,
+                    client_secret: process.env.GOOGLE_CALENDAR_CLIENT_SECRET,
+                    redirect_uri: \`\${process.env.REDIRECT_URI}/google-calendar\`,
+                    scope: process.env.GOOGLE_CALENDAR_SCOPE,
+                }
+            };
+        `);
+        parse.mockReturnValue({});
+        traverse.default.mockImplementation((ast, visitor) => {
+            visitor.ObjectProperty({
+                node: {
+                    key: { name: 'env' },
+                    value: {
+                        properties: [
+                            {
+                                key: { name: 'client_id' },
+                                value: {
+                                    type: 'MemberExpression',
+                                    object: { name: 'process' },
+                                    property: {
+                                        name: 'GOOGLE_CALENDAR_CLIENT_ID',
+                                    },
+                                },
+                            },
+                            {
+                                key: { name: 'client_secret' },
+                                value: {
+                                    type: 'MemberExpression',
+                                    object: { name: 'process' },
+                                    property: {
+                                        name: 'GOOGLE_CALENDAR_CLIENT_SECRET',
+                                    },
+                                },
+                            },
+                            {
+                                key: { name: 'redirect_uri' },
+                                value: {
+                                    type: 'MemberExpression',
+                                    object: { name: 'process' },
+                                    property: { name: 'REDIRECT_URI' },
+                                },
+                            },
+                            {
+                                key: { name: 'scope' },
+                                value: {
+                                    type: 'MemberExpression',
+                                    object: { name: 'process' },
+                                    property: { name: 'GOOGLE_CALENDAR_SCOPE' },
+                                },
+                            },
+                        ],
+                    },
+                },
+            });
+        });
+    });
+
+    xit('should identify and handle missing environment variables', async () => {
+        const localEnvPath = resolve(backendPath, '../.env');
+        const localDevConfigPath = resolve(
+            backendPath,
+            '../src/configs/dev.json'
+        );
+
+        fs.existsSync.mockImplementation(
+            (path) => path === localEnvPath || path === localDevConfigPath
+        );
+        dotenv.parse.mockReturnValue({});
+        fs.readFileSync.mockImplementation((path) => {
+            if (path === resolve(modulePath, 'index.js'))
+                return 'mock module content';
+            if (path === localEnvPath) return '';
+            if (path === localDevConfigPath) return '{}';
+            return '';
+        });
+
+        inquirer.prompt
+            .mockResolvedValueOnce({ addEnvVars: true })
+            .mockResolvedValueOnce({ value: 'client_id_value' })
+            .mockResolvedValueOnce({ value: 'client_secret_value' })
+            .mockResolvedValueOnce({ value: 'redirect_uri_value' })
+            .mockResolvedValueOnce({ value: 'scope_value' });
+
+        await handleEnvVariables(backendPath, modulePath);
+
+        expect(logInfo).toHaveBeenCalledWith(
+            'Searching for missing environment variables...'
+        );
+        expect(logInfo).toHaveBeenCalledWith(
+            'Missing environment variables: GOOGLE_CALENDAR_CLIENT_ID, GOOGLE_CALENDAR_CLIENT_SECRET, REDIRECT_URI, GOOGLE_CALENDAR_SCOPE'
+        );
+        expect(inquirer.prompt).toHaveBeenCalledTimes(5);
+        expect(fs.appendFileSync).toHaveBeenCalledWith(
+            localEnvPath,
+            '\nGOOGLE_CALENDAR_CLIENT_ID=client_id_value\nGOOGLE_CALENDAR_CLIENT_SECRET=client_secret_value\nREDIRECT_URI=redirect_uri_value\nGOOGLE_CALENDAR_SCOPE=scope_value'
+        );
+        expect(fs.writeFileSync).toHaveBeenCalledWith(
+            localDevConfigPath,
+            JSON.stringify(
+                {
+                    GOOGLE_CALENDAR_CLIENT_ID: 'client_id_value',
+                    GOOGLE_CALENDAR_CLIENT_SECRET: 'client_secret_value',
+                    REDIRECT_URI: 'redirect_uri_value',
+                    GOOGLE_CALENDAR_SCOPE: 'scope_value',
+                },
+                null,
+                2
+            )
+        );
+    });
+});

package/frigg-cli/{installCommand.js → install-command/index.js}

@@ -1,18 +1,18 @@
-const { installPackage } = require('./installPackage');
-const { createIntegrationFile } = require('./integrationFile');
+const { installPackage } = require('./install-package');
+const { createIntegrationFile } = require('./integration-file');
 const { resolve } = require('node:path');
-const { updateBackendJsFile } = require('./backendJs');
+const { updateBackendJsFile } = require('./backend-js');
 const { logInfo, logError } = require('./logger');
-const { commitChanges } = require('./commitChanges');
+const { commitChanges } = require('./commit-changes');
 const {
     findNearestBackendPackageJson,
     validateBackendPath,
-} = require('./backendPath');
-const { handleEnvVariables } = require('./environmentVariables');
+} = require('../utils/backend-path');
+const { handleEnvVariables } = require('./environment-variables');
 const {
     validatePackageExists,
     searchAndSelectPackage,
-} = require('./validatePackage');
+} = require('./validate-package');
 
 const installCommand = async (apiModuleName) => {
     try {

package/frigg-cli/{validatePackage.js → install-command/validate-package.js}

@@ -1,7 +1,7 @@
 const { execSync } = require('child_process');
 const axios = require('axios');
 const { logError } = require('./logger');
-const inquirer = require('inquirer');
+const { checkbox } = require('@inquirer/prompts');
 
 async function searchPackages(apiModuleName) {
     const searchCommand = `npm search @friggframework/api-module-${apiModuleName} --json`;
@@ -36,9 +36,7 @@ const searchAndSelectPackage = async (apiModuleName) => {
     }
 
     const filteredResults = searchResults.filter((pkg) => {
-        const version = pkg.version
-            ? pkg.version.split('.').map(Number)
-            : [];
+        const version = pkg.version ? pkg.version.split('.').map(Number) : [];
         return version[0] >= 1;
     });
 
@@ -55,20 +53,18 @@ const searchAndSelectPackage = async (apiModuleName) => {
     const choices = filteredResults.map((pkg) => {
         return {
             name: `${pkg.name} (${pkg.version})`,
+            value: pkg.name,
             checked: filteredResults.length === 1, // Automatically select if only one result
         };
     });
 
-    const { selectedPackages } = await inquirer.prompt([
-        {
-            type: 'checkbox',
-            name: 'selectedPackages',
-            message: 'Select the packages to install:',
-            choices,
-        },
-    ]);
+    const selectedPackages = await checkbox({
+        message: 'Select the packages to install:',
+        choices,
+    });
+    console.log('Selected packages:', selectedPackages);
 
-    return selectedPackages.map(choice => choice.split(' ')[0]);
+    return selectedPackages.map((choice) => choice.split(' ')[0]);
 };
 
 module.exports = {

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

@@ -0,0 +1,36 @@
+const { spawn } = require('child_process');
+const path = require('path');
+
+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;
+    const backendPath = path.resolve(process.cwd());
+    console.log(`Starting backend in ${backendPath}...`);
+    const infrastructurePath = 'infrastructure.js';
+    const command = 'serverless';
+    const args = [
+        'offline',
+        '--config',
+        infrastructurePath,
+        '--stage',
+        options.stage
+    ];
+
+    const childProcess = spawn(command, args, {
+        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 = { startCommand };

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.0",
+  "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.0",
-    "@friggframework/test": "^2.0.0-next.0",
+    "@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.0",
-    "@friggframework/prettier-config": "^2.0.0-next.0"
+    "@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": "e37f577d3c14f8eed6584517830c6c61815cf759"
+  "gitHead": "67dc76e94c02c0074f7ff2d7292c4d2203bf3949"
 }

package/test/mock-integration.js

@@ -1,65 +1,65 @@
-const { Auther, Credential, Entity, IntegrationFactory, createObjectId } = require('@friggframework/core');
+const {
+    Auther,
+    Credential,
+    Entity,
+    IntegrationFactory,
+    createObjectId,
+} = require('@friggframework/core');
 
-
-async function createMockIntegration(IntegrationClassDef, userId = null, config = {},) {
-    const integrationFactory = new IntegrationFactory([IntegrationClassDef]);
+async function createMockIntegration(
+    IntegrationClass,
+    userId = null,
+    config = { type: IntegrationClass.Definition.name }
+) {
+    const integrationFactory = new IntegrationFactory([IntegrationClass]);
     userId = userId || createObjectId();
 
     const insertOptions = {
         new: true,
         upsert: true,
         setDefaultsOnInsert: true,
-    }
-    const user = {user: userId}
-
-    const credential = await Credential.findOneAndUpdate(
-        user,
-        { $set: user },
-        insertOptions
-    );
-    const entity1 = await Entity.findOneAndUpdate(
-        user,
-        {
-            $set: {
-                credential: credential.id,
-                user: userId,
-                name: 'Test user',
-                externalId: '1234567890123456',
-            },
-        },
-        insertOptions
-    );
-    const entity2 = await Entity.findOneAndUpdate(
-        user,
-        {
-            $set: {
-                credential: credential.id,
-                user: userId,
-            },
-        },
-        insertOptions
-    );
+    };
+    const user = { user: userId };
 
-    const entities = [entity1, entity2]
-
-    const integration =
-        await integrationFactory.createIntegration(
-            entities,
-            userId,
-            config,
+    const entities = [];
+    for (const moduleName in IntegrationClass.modules) {
+        const ModuleDef = IntegrationClass.Definition.modules[moduleName];
+        const module = await Auther.getInstance({
+            definition: ModuleDef,
+            userId: userId,
+        });
+        const credential = await module.CredentialModel.findOneAndUpdate(
+            user,
+            { $set: user },
+            insertOptions
+        );
+        entities.push(
+            (
+                await module.EntityModel.findOneAndUpdate(
+                    user,
+                    {
+                        $set: {
+                            credential,
+                            user: userId,
+                            name: `Test ${moduleName}`,
+                            externalId: `1234567890123456_${moduleName}`,
+                        },
+                    },
+                    insertOptions
+                )
+            ).id
         );
+    }
 
-    integration.id = integration.record._id
+    const integration = await integrationFactory.createIntegration(
+        entities,
+        userId,
+        config
+    );
 
-    for (const i in entities){
-        if (Object.entries(IntegrationClassDef.modules).length <= i) break
-        const [moduleName, ModuleDef] = Object.entries(IntegrationClassDef.modules)[i];
-        const module = await Auther.getInstance({definition: ModuleDef, userId: userId})
-        module.entity = entities[i];
-        integration[moduleName] = module;
-    }
+    integration.id = integration.record._id;
 
-    return integration
+    return integration;
 }
 
 function createMockApiObject(jest, api = {}, mockMethodMap) {
@@ -67,17 +67,22 @@ function createMockApiObject(jest, api = {}, mockMethodMap) {
     // and values which are the mock response (or implementation)
     const clone = (data) => JSON.parse(JSON.stringify(data));
 
-    for (const [methodName, mockDataOrImplementation] of Object.entries(mockMethodMap)) {
+    for (const [methodName, mockDataOrImplementation] of Object.entries(
+        mockMethodMap
+    )) {
         if (mockDataOrImplementation instanceof Function) {
             api[methodName] = jest.fn(mockDataOrImplementation);
-        }
-        else if (api[methodName]?.constructor?.name === "AsyncFunction") {
-            api[methodName] = jest.fn().mockResolvedValue(clone(mockDataOrImplementation));
+        } else if (api[methodName]?.constructor?.name === 'AsyncFunction') {
+            api[methodName] = jest
+                .fn()
+                .mockResolvedValue(clone(mockDataOrImplementation));
         } else {
-            api[methodName] = jest.fn().mockReturnValue(clone(mockDataOrImplementation));
+            api[methodName] = jest
+                .fn()
+                .mockReturnValue(clone(mockDataOrImplementation));
         }
     }
     return api;
 }
 
-module.exports = {createMockIntegration, createMockApiObject};
+module.exports = { createMockIntegration, createMockApiObject };

package/frigg-cli/environmentVariables.test.js

@@ -1,86 +0,0 @@
-const { handleEnvVariables } = require('./environmentVariables');
-const { logInfo } = require('./logger');
-const inquirer = require('inquirer');
-const fs = require('fs');
-const dotenv = require('dotenv');
-const { resolve } = require('node:path');
-const { parse } = require('@babel/parser');
-const traverse = require('@babel/traverse');
-
-jest.mock('inquirer');
-jest.mock('fs');
-jest.mock('dotenv');
-jest.mock('./logger');
-jest.mock('@babel/parser');
-jest.mock('@babel/traverse');
-
-describe('handleEnvVariables', () => {
-    const backendPath = '/mock/backend/path';
-    const modulePath = '/mock/module/path';
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-        fs.readFileSync.mockReturnValue(`
-            const Definition = {
-                env: {
-                    client_id: process.env.GOOGLE_CALENDAR_CLIENT_ID,
-                    client_secret: process.env.GOOGLE_CALENDAR_CLIENT_SECRET,
-                    redirect_uri: \`\${process.env.REDIRECT_URI}/google-calendar\`,
-                    scope: process.env.GOOGLE_CALENDAR_SCOPE,
-                }
-            };
-        `);
-        parse.mockReturnValue({});
-        traverse.default.mockImplementation((ast, visitor) => {
-            visitor.ObjectProperty({
-                node: {
-                    key: { name: 'env' },
-                    value: {
-                        properties: [
-                            { key: { name: 'client_id' }, value: { type: 'MemberExpression', object: { name: 'process' }, property: { name: 'GOOGLE_CALENDAR_CLIENT_ID' } } },
-                            { key: { name: 'client_secret' }, value: { type: 'MemberExpression', object: { name: 'process' }, property: { name: 'GOOGLE_CALENDAR_CLIENT_SECRET' } } },
-                            { key: { name: 'redirect_uri' }, value: { type: 'MemberExpression', object: { name: 'process' }, property: { name: 'REDIRECT_URI' } } },
-                            { key: { name: 'scope' }, value: { type: 'MemberExpression', object: { name: 'process' }, property: { name: 'GOOGLE_CALENDAR_SCOPE' } } },
-                        ]
-                    }
-                }
-            });
-        });
-    });
-
-    xit('should identify and handle missing environment variables', async () => {
-        const localEnvPath = resolve(backendPath, '../.env');
-        const localDevConfigPath = resolve(backendPath, '../src/configs/dev.json');
-
-        fs.existsSync.mockImplementation((path) => path === localEnvPath || path === localDevConfigPath);
-        dotenv.parse.mockReturnValue({});
-        fs.readFileSync.mockImplementation((path) => {
-            if (path === resolve(modulePath, 'index.js')) return 'mock module content';
-            if (path === localEnvPath) return '';
-            if (path === localDevConfigPath) return '{}';
-            return '';
-        });
-
-        inquirer.prompt.mockResolvedValueOnce({ addEnvVars: true })
-            .mockResolvedValueOnce({ value: 'client_id_value' })
-            .mockResolvedValueOnce({ value: 'client_secret_value' })
-            .mockResolvedValueOnce({ value: 'redirect_uri_value' })
-            .mockResolvedValueOnce({ value: 'scope_value' });
-
-        await handleEnvVariables(backendPath, modulePath);
-
-        expect(logInfo).toHaveBeenCalledWith('Searching for missing environment variables...');
-        expect(logInfo).toHaveBeenCalledWith('Missing environment variables: GOOGLE_CALENDAR_CLIENT_ID, GOOGLE_CALENDAR_CLIENT_SECRET, REDIRECT_URI, GOOGLE_CALENDAR_SCOPE');
-        expect(inquirer.prompt).toHaveBeenCalledTimes(5);
-        expect(fs.appendFileSync).toHaveBeenCalledWith(localEnvPath, '\nGOOGLE_CALENDAR_CLIENT_ID=client_id_value\nGOOGLE_CALENDAR_CLIENT_SECRET=client_secret_value\nREDIRECT_URI=redirect_uri_value\nGOOGLE_CALENDAR_SCOPE=scope_value');
-        expect(fs.writeFileSync).toHaveBeenCalledWith(
-            localDevConfigPath,
-            JSON.stringify({
-                GOOGLE_CALENDAR_CLIENT_ID: 'client_id_value',
-                GOOGLE_CALENDAR_CLIENT_SECRET: 'client_secret_value',
-                REDIRECT_URI: 'redirect_uri_value',
-                GOOGLE_CALENDAR_SCOPE: 'scope_value'
-            }, null, 2)
-        );
-    });
-});