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

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/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0-next.0",
+  "version": "2.0.0-next.1",
   "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/core": "2.0.0-next.1",
+    "@friggframework/test": "2.0.0-next.1",
     "axios": "^1.7.2",
     "commander": "^12.1.0",
     "dotenv": "^16.4.5",
@@ -21,8 +21,8 @@
     "inquirer": "^10.1.6"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "^2.0.0-next.0",
-    "@friggframework/prettier-config": "^2.0.0-next.0"
+    "@friggframework/eslint-config": "2.0.0-next.1",
+    "@friggframework/prettier-config": "2.0.0-next.1"
   },
   "scripts": {
     "lint:fix": "prettier --write --loglevel error . && eslint . --fix",
@@ -46,5 +46,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "e37f577d3c14f8eed6584517830c6c61815cf759"
+  "gitHead": "44b619e288b23d879673518076cf9e4acacb3c71"
 }

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)
-        );
-    });
-});