@friggframework/devtools 2.0.0-next.0 → 2.0.0-next.2

package/frigg-cli/index.js

@@ -1,7 +1,8 @@
 #!/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 program = new Command();
 program
@@ -9,6 +10,11 @@ program
     .description('Install an API module')
     .action(installCommand);
 
+program
+    .command('start')
+    .description('Run the backend and optional frontend')
+    .action(startCommand);
+
 program.parse(process.argv);
 
-module.exports = { installCommand };
+module.exports = { installCommand, startCommand };

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,30 @@
+const { spawn } = require('child_process');
+const path = require('path');
+
+function startCommand() {
+    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=dev'];
+
+    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/app-handler-helpers.js

@@ -0,0 +1,57 @@
+const { createHandler, flushDebugLog } = require('@friggframework/core');
+const express = require('express');
+const bodyParser = require('body-parser');
+const cors = require('cors');
+const Boom = require('@hapi/boom');
+const loadUserManager = require('./routers/middleware/loadUser');
+const serverlessHttp = require('serverless-http');
+
+const createApp = (applyMiddleware) => {
+    const app = express();
+
+    app.use(bodyParser.json({ limit: '10mb' }));
+    app.use(bodyParser.urlencoded({ extended: true }));
+    app.use(
+        cors({
+            origin: '*',
+            credentials: true,
+        })
+    );
+
+    app.use(loadUserManager);
+
+    if (applyMiddleware) applyMiddleware(app);
+
+    // Handle sending error response and logging server errors to console
+    app.use((err, req, res, next) => {
+        const boomError = err.isBoom ? err : Boom.boomify(err);
+        const {
+            output: { statusCode = 500 },
+        } = boomError;
+
+        if (statusCode >= 500) {
+            flushDebugLog(boomError);
+            res.status(statusCode).json({ error: 'Internal Server Error' });
+        } else {
+            res.status(statusCode).json({ error: err.message });
+        }
+    });
+
+    return app;
+};
+
+function createAppHandler(eventName, router, shouldUseDatabase = true) {
+    const app = createApp((app) => {
+        app.use(router);
+    });
+    return createHandler({
+        eventName,
+        method: serverlessHttp(app),
+        shouldUseDatabase,
+    });
+}
+
+module.exports = {
+    createApp,
+    createAppHandler,
+};

package/infrastructure/backend-utils.js

@@ -0,0 +1,90 @@
+const { createFriggBackend, Worker } = require('@friggframework/core');
+const {
+    findNearestBackendPackageJson,
+} = require('../frigg-cli/utils/backend-path');
+const path = require('path');
+const fs = require('fs-extra');
+
+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 backendJsFile = require(backendFilePath);
+const { Router } = require('express');
+const appDefinition = backendJsFile.Definition;
+
+const backend = createFriggBackend(appDefinition);
+const loadRouterFromObject = (IntegrationClass, routerObject) => {
+    const router = Router();
+    const { path, method, event } = routerObject;
+    console.log(
+        `Registering ${method} ${path} for ${IntegrationClass.Definition.name}`
+    );
+    router[method.toLowerCase()](path, async (req, res, next) => {
+        try {
+            const integration = new IntegrationClass({});
+            await integration.loadModules();
+            await integration.registerEventHandlers();
+            const result = await integration.send(event, req.body);
+            res.json(result);
+        } catch (error) {
+            next(error);
+        }
+    });
+
+    return router;
+};
+const createQueueWorker = (integrationClass) => {
+    class QueueWorker extends Worker {
+        constructor(params) {
+            super(params);
+        }
+        async _run(params, context) {
+            try {
+                let instance;
+                if (!params.integrationId) {
+                    instance = new integrationClass({});
+                    await instance.loadModules();
+                    // await instance.loadUserActions();
+                    await instance.registerEventHandlers();
+                    console.log(
+                        `${params.event} for ${integrationClass.Definition.name} integration with no integrationId`
+                    );
+                } else {
+                    instance =
+                        await integrationClass.getInstanceFromIntegrationId({
+                            integrationId: params.integrationId,
+                        });
+                    console.log(
+                        `${params.event} for ${instance.integration.config.type} of integrationId: ${params.integrationId}`
+                    );
+                }
+                const res = await instance.send(params.event, {
+                    data: params.data,
+                    context,
+                });
+                return res;
+            } catch (error) {
+                console.error(
+                    `Error in ${params.event} for ${integrationClass.Definition.name}:`,
+                    error
+                );
+                throw error;
+            }
+        }
+    }
+    return QueueWorker;
+};
+
+module.exports = {
+    ...backend,
+    loadRouterFromObject,
+    createQueueWorker,
+};