@friggframework/devtools 1.1.6 → 1.1.7-next.1

package/CHANGELOG.md

@@ -1,3 +1,58 @@
+# v1.2.0 (Tue Aug 06 2024)
+
+#### 🚀 Enhancement
+
+- CLI for Frigg - Install command for now [#322](https://github.com/friggframework/frigg/pull/322) ([@seanspeaks](https://github.com/seanspeaks))
+
+#### 🐛 Bug Fix
+
+- Add READMEs that will need updating, but for version releasing [#324](https://github.com/friggframework/frigg/pull/324) ([@seanspeaks](https://github.com/seanspeaks))
+- Add READMEs that will need updating, but for version releasing ([@seanspeaks](https://github.com/seanspeaks))
+- small update to integration testing / tooling [#304](https://github.com/friggframework/frigg/pull/304) ([@MichaelRyanWebber](https://github.com/MichaelRyanWebber))
+- Added missing dependencies ([@seanspeaks](https://github.com/seanspeaks))
+- Added a missing dependency ([@seanspeaks](https://github.com/seanspeaks))
+- Updated to handle envs properly, also further refactoring, and better templating. ([@seanspeaks](https://github.com/seanspeaks))
+- WIP with help from Tabnine AI chat. ([@seanspeaks](https://github.com/seanspeaks))
+- Bump version to: v1.1.8 \[skip ci\] ([@seanspeaks](https://github.com/seanspeaks))
+- use the factory methods for creating the mock integration so that everything is set up (mostly events and userActions) ([@MichaelRyanWebber](https://github.com/MichaelRyanWebber))
+- Bump version to: v1.1.5 \[skip ci\] ([@seanspeaks](https://github.com/seanspeaks))
+
+#### Authors: 2
+
+- [@MichaelRyanWebber](https://github.com/MichaelRyanWebber)
+- Sean Matthews ([@seanspeaks](https://github.com/seanspeaks))
+
+---
+
+# v1.1.8 (Thu Jul 18 2024)
+
+#### 🐛 Bug Fix
+
+- Revert open to support commonjs [#319](https://github.com/friggframework/frigg/pull/319) ([@MichaelRyanWebber](https://github.com/MichaelRyanWebber))
+- Bump version to: v1.1.6 \[skip ci\] ([@seanspeaks](https://github.com/seanspeaks))
+
+#### Authors: 2
+
+- [@MichaelRyanWebber](https://github.com/MichaelRyanWebber)
+- Sean Matthews ([@seanspeaks](https://github.com/seanspeaks))
+
+---
+
+# v1.1.7 (Mon Jul 15 2024)
+
+#### 🐛 Bug Fix
+
+- getAuthorizationRequirements() async [#318](https://github.com/friggframework/frigg/pull/318) ([@MichaelRyanWebber](https://github.com/MichaelRyanWebber))
+- await getAuthorizeRequirements() ([@MichaelRyanWebber](https://github.com/MichaelRyanWebber))
+- Bump version to: v1.1.6 \[skip ci\] ([@seanspeaks](https://github.com/seanspeaks))
+
+#### Authors: 2
+
+- [@MichaelRyanWebber](https://github.com/MichaelRyanWebber)
+- Sean Matthews ([@seanspeaks](https://github.com/seanspeaks))
+
+---
+
 # v1.1.6 (Fri Apr 26 2024)
 
 #### 🐛 Bug Fix

package/README.md

@@ -0,0 +1,81 @@
+# Frigg Framework Devtools
+
+This package contains development tools and utilities for the Frigg Framework, an open-source serverless framework designed to simplify the development of integrations at scale.
+
+## Contents
+
+The devtools package includes the following main components:
+
+1. Frigg CLI
+2. Migrations
+3. Test Utilities
+4. Local runner and deploy tooling
+
+## Frigg CLI
+
+The Frigg CLI is a command-line interface tool that helps developers manage and install API modules in their Frigg projects.
+
+### Key Features
+
+- Install API modules
+- Search for available API modules
+- Automatically update project files
+- Handle environment variables
+- Validate package existence and backend paths
+
+### Usage
+
+To use the Frigg CLI, run the following command:
+```sh
+frigg install <api-module-name>
+```
+
+This command will search for the specified API module, install it, and update your project accordingly.
+
+## Migrations
+
+(Add information about migrations here if available)
+
+## Test Utilities
+
+The test directory contains utilities to assist with testing in the Frigg Framework.
+
+### Key Features
+
+- Integration validator (TODO: implementation details to be added)
+- Mock API functionality
+
+### Mock API
+
+The `mock-api.js` file provides functionality to mock API responses for testing purposes. It uses `nock` for HTTP request interception and includes features like:
+
+- Caching of authentication tokens
+- Recording and replaying of HTTP requests
+- Jest test state management
+
+Usage example:
+
+```javascript
+const { mockApi } = require('@friggframework/devtools/test/mock-api');
+
+// Use mockApi in your tests to simulate API responses
+```
+## Installation
+
+To install the devtools package as a dev dependency, run:
+
+```
+npm install --save-dev @friggframework/devtools
+```
+
+## Contributing
+
+Please read [CONTRIBUTING.md](../../CONTRIBUTING.md) for details on our code of conduct, and the process for submitting pull requests to us.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE.md](../../LICENSE.md) file for details
+
+## Support
+
+For support, please open an issue in the main Frigg Framework repository or contact the maintainers directly.

package/frigg-cli/backendJs.js

@@ -0,0 +1,33 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { logInfo } = require('./logger');
+const INTEGRATIONS_DIR = 'src/integrations';
+const BACKEND_JS = 'backend.js';
+
+function updateBackendJsFile(backendPath, apiModuleName) {
+    const backendJsPath = path.join(path.dirname(backendPath), BACKEND_JS);
+    logInfo(`Updating backend.js: ${backendJsPath}`);
+    updateBackendJs(backendJsPath, apiModuleName);
+}
+
+function updateBackendJs(backendJsPath, apiModuleName) {
+    const backendJsContent = fs.readFileSync(backendJsPath, 'utf-8');
+    const importStatement = `const ${apiModuleName}Integration = require('./${INTEGRATIONS_DIR}/${apiModuleName}Integration');\n`;
+
+    if (!backendJsContent.includes(importStatement)) {
+        const updatedContent = backendJsContent.replace(
+            /(integrations\s*:\s*\[)([\s\S]*?)(\])/,
+            `$1\n        ${apiModuleName}Integration,$2$3`
+        );
+        fs.writeFileSync(backendJsPath, importStatement + updatedContent);
+    } else {
+        logInfo(
+            `Import statement for ${apiModuleName}Integration already exists in backend.js`
+        );
+    }
+}
+
+module.exports = {
+    updateBackendJsFile,
+    updateBackendJs,
+};

package/frigg-cli/backendPath.js

@@ -0,0 +1,26 @@
+const fs = require('fs-extra');
+const path = require('path');
+const PACKAGE_JSON = 'package.json';
+
+function findNearestBackendPackageJson() {
+    let currentDir = process.cwd();
+    while (currentDir !== path.parse(currentDir).root) {
+        const packageJsonPath = path.join(currentDir, 'backend', PACKAGE_JSON);
+        if (fs.existsSync(packageJsonPath)) {
+            return packageJsonPath;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return null;
+}
+
+function validateBackendPath(backendPath) {
+    if (!backendPath) {
+        throw new Error('Could not find a backend package.json file.');
+    }
+}
+
+module.exports = {
+    findNearestBackendPackageJson,
+    validateBackendPath,
+};

package/frigg-cli/commitChanges.js

@@ -0,0 +1,16 @@
+const { execSync } = require('child_process');
+const path = require('path');
+
+function commitChanges(backendPath, apiModuleName) {
+    const apiModulePath = path.join(path.dirname(backendPath), 'src', 'integrations', `${apiModuleName}Integration.js`);
+    try {
+        execSync(`git add ${apiModulePath}`);
+        execSync(`git commit -m "Add ${apiModuleName}Integration to ${apiModuleName}Integration.js"`);
+    } catch (error) {
+        throw new Error('Failed to commit changes:', error);
+    }
+}
+
+module.exports = {
+    commitChanges,
+};

package/frigg-cli/environmentVariables.js

@@ -0,0 +1,134 @@
+const fs = require('fs');
+const dotenv = require('dotenv');
+const { readFileSync, writeFileSync, existsSync } = require('fs');
+const { logInfo } = require('./logger');
+const { resolve } = require('node:path');
+const inquirer = require('inquirer');
+
+const { parse } = require('@babel/parser');
+const traverse = require('@babel/traverse').default;
+
+const extractRawEnvVariables = (modulePath) => {
+    const filePath = resolve(modulePath, 'definition.js');
+
+    const fileContent = fs.readFileSync(filePath, 'utf-8');
+    const ast = parse(fileContent, {
+        sourceType: 'module',
+        plugins: ['jsx', 'typescript'], // Add more plugins if needed
+    });
+
+    const envVariables = {};
+
+    traverse(ast, {
+        ObjectProperty(path) {
+            if (path.node.key.name === 'env') {
+                path.node.value.properties.forEach((prop) => {
+                    const key = prop.key.name;
+                    if (prop.value.type === 'MemberExpression') {
+                        const property = prop.value.property.name;
+                        envVariables[key] = `${property}`;
+                    } else if (prop.value.type === 'TemplateLiteral') {
+                        // Handle template literals
+                        const expressions = prop.value.expressions.map((exp) =>
+                            exp.type === 'MemberExpression'
+                                ? `${exp.property.name}`
+                                : exp.name
+                        );
+                        envVariables[key] = expressions.join('');
+                    }
+                });
+            }
+        },
+    });
+
+    return envVariables;
+};
+const handleEnvVariables = async (backendPath, modulePath) => {
+    logInfo('Searching for missing environment variables...');
+    const Definition = { env: extractRawEnvVariables(modulePath) };
+    if (Definition && Definition.env) {
+        console.log('Here is Definition.env:', Definition.env);
+        const envVars = Object.values(Definition.env);
+
+        console.log(
+            'Found the following environment variables in the API module:',
+            envVars
+        );
+
+        const localEnvPath = resolve(backendPath, '../.env');
+        const localDevConfigPath = resolve(
+            backendPath,
+            '../src/configs/dev.json'
+        );
+
+        // Load local .env variables
+        let localEnvVars = {};
+        if (existsSync(localEnvPath)) {
+            localEnvVars = dotenv.parse(readFileSync(localEnvPath, 'utf8'));
+        }
+
+        // Load local dev.json variables
+        let localDevConfig = {};
+        if (existsSync(localDevConfigPath)) {
+            localDevConfig = JSON.parse(
+                readFileSync(localDevConfigPath, 'utf8')
+            );
+        }
+
+        const missingEnvVars = envVars.filter(
+            (envVar) => !localEnvVars[envVar] && !localDevConfig[envVar]
+        );
+
+        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?`,
+                },
+            ]);
+
+            if (addEnvVars) {
+                const envValues = {};
+                for (const envVar of missingEnvVars) {
+                    const { value } = await inquirer.prompt([
+                        {
+                            type: 'input',
+                            name: 'value',
+                            message: `Enter value for ${envVar}:`,
+                        },
+                    ]);
+                    envValues[envVar] = value;
+                }
+
+                // Add the envValues to the local .env file if it exists
+                if (existsSync(localEnvPath)) {
+                    const envContent = Object.entries(envValues)
+                        .map(([key, value]) => `${key}=${value}`)
+                        .join('\n');
+                    fs.appendFileSync(localEnvPath, `\n${envContent}`);
+                }
+
+                // Add the envValues to the local dev.json file if it exists
+                if (existsSync(localDevConfigPath)) {
+                    const updatedDevConfig = {
+                        ...localDevConfig,
+                        ...envValues,
+                    };
+                    writeFileSync(
+                        localDevConfigPath,
+                        JSON.stringify(updatedDevConfig, null, 2)
+                    );
+                }
+            } else {
+                logInfo("Edit whenever you're able, safe travels friend!");
+            }
+        }
+    }
+};
+
+module.exports = { handleEnvVariables };

package/frigg-cli/environmentVariables.test.js

@@ -0,0 +1,86 @@
+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)
+        );
+    });
+});

package/frigg-cli/index.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const { installCommand } = require('./installCommand');
+
+const program = new Command();
+program
+    .command('install [apiModuleName]')
+    .description('Install an API module')
+    .action(installCommand);
+
+program.parse(process.argv);
+
+module.exports = { installCommand };

package/frigg-cli/index.test.js

@@ -0,0 +1,109 @@
+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');
+
+describe('CLI Command Tests', () => {
+    it('should successfully install an API module when all steps complete without errors', async () => {
+        const mockApiModuleName = 'testModule';
+        const mockPackageName = `@friggframework/api-module-${mockApiModuleName}`;
+        const mockBackendPath = '/mock/backend/path';
+
+        jest.mock('./validatePackage', () => ({
+            validatePackageExists: jest.fn().mockResolvedValue(true),
+        }));
+        jest.mock('./backendPath', () => ({
+            findNearestBackendPackageJson: jest.fn().mockReturnValue(mockBackendPath),
+            validateBackendPath: jest.fn().mockReturnValue(true),
+        }));
+        jest.mock('./installPackage', () => ({
+            installPackage: jest.fn().mockReturnValue(true),
+        }));
+        jest.mock('./integrationFile', () => ({
+            createIntegrationFile: jest.fn().mockReturnValue(true),
+        }));
+        jest.mock('./backendJs', () => ({
+            updateBackendJsFile: jest.fn().mockReturnValue(true),
+        }));
+        jest.mock('./commitChanges', () => ({
+            commitChanges: jest.fn().mockReturnValue(true),
+        }));
+        jest.mock('./logger', () => ({
+            logInfo: jest.fn(),
+            logError: jest.fn(),
+        }));
+
+        const program = new Command();
+        program
+            .command('install <apiModuleName>')
+            .description('Install an API module')
+            .action(installCommand);
+
+        await program.parseAsync(['node', 'install', mockApiModuleName]);
+
+        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.`);
+    });
+
+    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 program = new Command();
+        program
+            .command('install <apiModuleName>')
+            .description('Install an API module')
+            .action(installCommand);
+
+        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(mockExit).toHaveBeenCalledWith(1);
+
+        mockExit.mockRestore();
+        mockLogError.mockRestore();
+        mockValidatePackageExists.mockRestore();
+    });
+
+    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 program = new Command();
+        program
+            .command('install <apiModuleName>')
+            .description('Install an API module')
+            .action(installCommand);
+
+        await program.parseAsync(['node', 'install', 'test-module']);
+
+        expect(mockLogError).toHaveBeenCalledWith('An error occurred:', expect.any(Error));
+        expect(mockProcessExit).toHaveBeenCalledWith(1);
+
+        mockLogError.mockRestore();
+        mockProcessExit.mockRestore();
+        mockValidatePackageExists.mockRestore();
+        mockFindNearestBackendPackageJson.mockRestore();
+        mockValidateBackendPath.mockRestore();
+    });
+});

package/frigg-cli/installCommand.js

@@ -0,0 +1,57 @@
+const { installPackage } = require('./installPackage');
+const { createIntegrationFile } = require('./integrationFile');
+const { resolve } = require('node:path');
+const { updateBackendJsFile } = require('./backendJs');
+const { logInfo, logError } = require('./logger');
+const { commitChanges } = require('./commitChanges');
+const {
+    findNearestBackendPackageJson,
+    validateBackendPath,
+} = require('./backendPath');
+const { handleEnvVariables } = require('./environmentVariables');
+const {
+    validatePackageExists,
+    searchAndSelectPackage,
+} = require('./validatePackage');
+
+const installCommand = async (apiModuleName) => {
+    try {
+        const packageNames = await searchAndSelectPackage(apiModuleName);
+        if (!packageNames || packageNames.length === 0) return;
+
+        const backendPath = findNearestBackendPackageJson();
+        validateBackendPath(backendPath);
+
+        for (const packageName of packageNames) {
+            await validatePackageExists(packageName);
+            installPackage(backendPath, packageName);
+
+            const modulePath = resolve(
+                backendPath,
+                `../../node_modules/${packageName}`
+            );
+            const {
+                Config: { label },
+                Api: ApiClass,
+            } = require(modulePath);
+
+            const sanitizedLabel = label.replace(
+                /[<>:"/\\|?*\x00-\x1F\s]/g,
+                ''
+            ); // Remove invalid characters and spaces            console.log('Installing integration for:', sanitizedLabel);
+            createIntegrationFile(backendPath, sanitizedLabel, ApiClass);
+            updateBackendJsFile(backendPath, sanitizedLabel);
+            commitChanges(backendPath, sanitizedLabel);
+            logInfo(
+                `Successfully installed ${packageName} and updated the project.`
+            );
+
+            await handleEnvVariables(backendPath, modulePath);
+        }
+    } catch (error) {
+        logError('An error occurred:', error);
+        process.exit(1);
+    }
+};
+
+module.exports = { installCommand };

package/frigg-cli/installPackage.js

@@ -0,0 +1,13 @@
+const { execSync } = require('child_process');
+const path = require('path');
+
+function installPackage(backendPath, packageName) {
+    execSync(`npm install ${packageName}`, {
+        cwd: path.dirname(backendPath),
+        stdio: 'inherit',
+    });
+}
+
+module.exports = {
+    installPackage,
+};

package/frigg-cli/integrationFile.js

@@ -0,0 +1,30 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { logInfo } = require('./logger');
+const { getIntegrationTemplate } = require('./template');
+const INTEGRATIONS_DIR = 'src/integrations';
+
+function createIntegrationFile(backendPath, apiModuleName, ApiClass) {
+    const integrationDir = path.join(
+        path.dirname(backendPath),
+        INTEGRATIONS_DIR
+    );
+    logInfo(`Ensuring directory exists: ${integrationDir}`);
+    fs.ensureDirSync(integrationDir);
+
+    const integrationFilePath = path.join(
+        integrationDir,
+        `${apiModuleName}Integration.js`
+    );
+    logInfo(`Writing integration file: ${integrationFilePath}`);
+    const integrationTemplate = getIntegrationTemplate(
+        apiModuleName,
+        backendPath,
+        ApiClass
+    );
+    fs.writeFileSync(integrationFilePath, integrationTemplate);
+}
+
+module.exports = {
+    createIntegrationFile,
+};

package/frigg-cli/logger.js

@@ -0,0 +1,12 @@
+function logInfo(message) {
+    console.log(message);
+}
+
+function logError(message, error) {
+    console.error(message, error);
+}
+
+module.exports = {
+    logInfo,
+    logError,
+};

package/frigg-cli/template.js

@@ -0,0 +1,90 @@
+const path = require('path');
+
+function getIntegrationTemplate(apiModuleName, backendPath, ApiClass) {
+    // Find the sample data method
+    const apiMethods = Object.getOwnPropertyNames(ApiClass.prototype);
+    const sampleDataMethod =
+        apiMethods.find(
+            (method) =>
+                method.toLowerCase().includes('search') ||
+                method.toLowerCase().includes('list') ||
+                method.toLowerCase().includes('get')
+        ) || 'searchDeals';
+
+    return `const { get, IntegrationBase, Options } = require('@friggframework/core');
+const { Definition: ${apiModuleName}Module, Config: defaultConfig } = require('@friggframework/api-module-${apiModuleName.toLowerCase()}');
+
+class ${apiModuleName}Integration extends IntegrationBase {
+    static Config = {
+        name: defaultConfig.name || '${apiModuleName.toLowerCase()}',
+        version: '1.0.0',
+        supportedVersions: ['1.0.0'],
+        events: ['SEARCH_DEALS'],
+    };
+
+    static Options =
+        new Options({
+            module: ${apiModuleName}Module,
+            integrations: [${apiModuleName}Module],
+            display: {
+                name: defaultConfig.displayName || '${apiModuleName}',
+                description: defaultConfig.description || 'Sales & CRM, Marketing',
+                category: defaultConfig.category || 'Sales & CRM, Marketing',
+                detailsUrl: defaultConfig.detailsUrl || 'https://www.${apiModuleName.toLowerCase()}.com',
+                icon: defaultConfig.icon || 'https://friggframework.org/assets/img/${apiModuleName.toLowerCase()}.jpeg',
+            },
+            hasUserConfig: true,
+        });
+
+    static modules = {
+        ${apiModuleName.toLowerCase()}: ${apiModuleName}Module,
+    }
+
+    /**
+     * HANDLE EVENTS
+     */
+    async receiveNotification(notifier, event, object = null) {
+        if (event === 'SEARCH_DEALS') {
+            return this.target.api.searchDeals(object);
+        }
+    }
+
+    /**
+     * ALL CUSTOM/OPTIONAL METHODS FOR AN INTEGRATION MANAGER
+     */
+    async getSampleData() {
+        const res = await this.target.api.${sampleDataMethod}();
+        return { data: res };
+    }
+
+    /**
+     * ALL REQUIRED METHODS FOR AN INTEGRATION MANAGER
+     */
+    async onCreate(params) {
+        // Validate that we have all of the data we need
+        // Set integration status as makes sense. Default ENABLED
+        // TODO turn this into a validateConfig method/function
+        this.record.status = 'ENABLED';
+        await this.record.save();
+        return this.record;
+    }
+
+    async onUpdate(params) {
+        const newConfig = get(params, 'config');
+        const oldConfig = this.record.config;
+        // Just save whatever
+        this.record.markModified('config');
+        await this.record.save();
+        return this.validateConfig();
+    }
+
+    async getConfigOptions() {
+        const options = {}
+        return options;
+    }
+}
+
+module.exports = ${apiModuleName}Integration;`;
+}
+
+module.exports = { getIntegrationTemplate };

package/frigg-cli/validatePackage.js

@@ -0,0 +1,79 @@
+const { execSync } = require('child_process');
+const axios = require('axios');
+const { logError } = require('./logger');
+const inquirer = require('inquirer');
+
+async function searchPackages(apiModuleName) {
+    const searchCommand = `npm search @friggframework/api-module-${apiModuleName} --json`;
+    const result = execSync(searchCommand, { encoding: 'utf8' });
+    return JSON.parse(result);
+}
+
+async function checkPackageExists(packageName) {
+    try {
+        const response = await axios.get(
+            `https://registry.npmjs.org/${packageName}`
+        );
+        return response.status === 200;
+    } catch (error) {
+        return false;
+    }
+}
+
+async function validatePackageExists(packageName) {
+    const packageExists = await checkPackageExists(packageName);
+    if (!packageExists) {
+        throw new Error(`Package ${packageName} does not exist on npm.`);
+    }
+}
+
+const searchAndSelectPackage = async (apiModuleName) => {
+    const searchResults = await searchPackages(apiModuleName || '');
+
+    if (searchResults.length === 0) {
+        logError(`No packages found matching ${apiModuleName}`);
+        process.exit(1);
+    }
+
+    const filteredResults = searchResults.filter((pkg) => {
+        const version = pkg.version
+            ? pkg.version.split('.').map(Number)
+            : [];
+        return version[0] >= 1;
+    });
+
+    if (filteredResults.length === 0) {
+        const earlierVersions = searchResults
+            .map((pkg) => `${pkg.name} (${pkg.version})`)
+            .join(', ');
+        logError(
+            `No packages found with version 1.0.0 or above for ${apiModuleName}. Found earlier versions: ${earlierVersions}`
+        );
+        process.exit(1);
+    }
+
+    const choices = filteredResults.map((pkg) => {
+        return {
+            name: `${pkg.name} (${pkg.version})`,
+            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,
+        },
+    ]);
+
+    return selectedPackages.map(choice => choice.split(' ')[0]);
+};
+
+module.exports = {
+    validatePackageExists,
+    checkPackageExists,
+    searchPackages,
+    searchAndSelectPackage,
+};

package/package.json

@@ -1,26 +1,36 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "1.1.6",
+  "version": "1.1.7-next.1",
   "dependencies": {
     "@babel/eslint-parser": "^7.18.9",
-    "@friggframework/core": "^1.1.6",
-    "@friggframework/test": "^1.1.6",
+    "@babel/parser": "^7.25.3",
+    "@babel/traverse": "^7.25.3",
+    "@friggframework/core": "1.1.7-next.1",
+    "@friggframework/test": "1.1.7-next.1",
+    "axios": "^1.7.2",
+    "commander": "^12.1.0",
+    "dotenv": "^16.4.5",
     "eslint": "^8.22.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-json": "^3.1.0",
     "eslint-plugin-markdown": "^3.0.0",
     "eslint-plugin-no-only-tests": "^3.0.0",
-    "eslint-plugin-yaml": "^0.5.0"
+    "eslint-plugin-yaml": "^0.5.0",
+    "fs-extra": "^11.2.0",
+    "inquirer": "^10.1.6"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "^1.1.6",
-    "@friggframework/prettier-config": "^1.1.6"
+    "@friggframework/eslint-config": "1.1.7-next.1",
+    "@friggframework/prettier-config": "1.1.7-next.1"
   },
   "scripts": {
     "lint:fix": "prettier --write --loglevel error . && eslint . --fix",
     "test": "jest --passWithNoTests # TODO"
   },
+  "bin": {
+    "frigg": "./frigg-cli/index.js"
+  },
   "author": "",
   "license": "MIT",
   "main": "index.js",
@@ -36,5 +46,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "49897aff107e2fb5b3cfe78a09106766bd34ca28"
+  "gitHead": "064b36b36e6600ea126bde63ea05890ee87795a3"
 }

package/test/auther-definition-tester.js

@@ -52,7 +52,7 @@ function testAutherDefinition(definition, mocks) {
             authCallbackParams = mocks.authorizeResponse || mocks.authorizeParams;
             describe('getAuthorizationRequirements() test', () => {
                 it('should return auth requirements', async () => {
-                    requirements = module.getAuthorizationRequirements();
+                    requirements = await module.getAuthorizationRequirements();
                     expect(requirements).toBeDefined();
                     expect(requirements.type).toEqual(ModuleConstants.authType.oauth2);
                     expect(requirements.url).toBeDefined();

package/test/mock-integration.js

@@ -1,10 +1,9 @@
-const { Auther, Credential, Entity, IntegrationModel, mongoose } = require('@friggframework/core');
+const { Auther, Credential, Entity, IntegrationFactory, createObjectId } = require('@friggframework/core');
 
 
 async function createMockIntegration(IntegrationClassDef, userId = null, config = {},) {
-    const integration = new IntegrationClassDef();
-    userId = userId || new mongoose.Types.ObjectId();
-    integration.delegateTypes.push(...IntegrationClassDef.Config.events)
+    const integrationFactory = new IntegrationFactory([IntegrationClassDef]);
+    userId = userId || createObjectId();
 
     const insertOptions = {
         new: true,
@@ -42,11 +41,13 @@ async function createMockIntegration(IntegrationClassDef, userId = null, config
     );
 
     const entities = [entity1, entity2]
-    integration.record = await IntegrationModel.create({
-        entities,
-        user: userId,
-        config: {type: IntegrationClassDef.Config.name, ...config}
-    })
+
+    const integration =
+        await integrationFactory.createIntegration(
+            entities,
+            userId,
+            config,
+        );
 
     integration.id = integration.record._id