@friggframework/devtools 2.0.0-next.47 → 2.0.0-next.48

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

@@ -0,0 +1,93 @@
+/**
+ * Copyright (c) 2024 Frigg Integration Framework
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+const path = require('path');
+const chalk = require('chalk');
+const validateProjectName = require('validate-npm-package-name');
+const semver = require('semver');
+const BackendFirstHandler = require('./backend-first-handler');
+
+function checkAppName(appName) {
+    const validationResult = validateProjectName(appName);
+    if (!validationResult.validForNewPackages) {
+        console.error(
+            chalk.red(
+                `Cannot create a project named ${chalk.green(
+                    `"${appName}"`
+                )} because of npm naming restrictions:\n`
+            )
+        );
+        [
+            ...(validationResult.errors || []),
+            ...(validationResult.warnings || []),
+        ].forEach(error => {
+            console.error(chalk.red(`  * ${error}`));
+        });
+        console.error(chalk.red('\nPlease choose a different project name.'));
+        process.exit(1);
+    }
+}
+
+function checkNodeVersion() {
+    const unsupportedNodeVersion = !semver.satisfies(
+        semver.coerce(process.version),
+        '>=14'
+    );
+
+    if (unsupportedNodeVersion) {
+        console.log(
+            chalk.yellow(
+                `You are using Node ${process.version} so the project will be bootstrapped with an old unsupported version of tools.\n\n` +
+                `Please update to Node 14 or higher for a better, fully supported experience.\n`
+            )
+        );
+    }
+}
+
+async function initCommand(projectName, options) {
+    const verbose = options.verbose || false;
+    const force = options.force || false;
+    
+    checkNodeVersion();
+
+    const root = path.resolve(projectName);
+    const appName = path.basename(root);
+
+    checkAppName(appName);
+    
+    // Use backend-first handler by default
+    if (!options.template && !options.legacyFrontend) {
+        try {
+            const handler = new BackendFirstHandler(root, {
+                force,
+                verbose,
+                mode: options.mode,
+                frontend: options.frontend
+            });
+            
+            await handler.initialize();
+            return;
+        } catch (error) {
+            console.log();
+            console.log(chalk.red('Aborting installation.'));
+            console.log(chalk.red('Error:'), error.message);
+            console.log();
+            process.exit(1);
+        }
+    }
+    
+    // If we get here, show an error for legacy options
+    console.log();
+    console.log(chalk.red('Legacy template system is no longer supported.'));
+    console.log(chalk.yellow('Please use the new backend-first approach.'));
+    console.log();
+    process.exit(1);
+}
+
+module.exports = { initCommand };

package/frigg-cli/init-command/template-handler.js

@@ -0,0 +1,143 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { execSync } = require('child_process');
+
+/**
+ * Handles template initialization for the frigg init command
+ */
+class TemplateHandler {
+    constructor(targetPath, options = {}) {
+        this.targetPath = targetPath;
+        this.options = options;
+        this.templatesDir = path.join(__dirname, '..', 'templates');
+    }
+
+    /**
+     * Initialize a new Frigg backend project from template
+     */
+    async initializeBackendTemplate() {
+        const templatePath = path.join(this.templatesDir, 'backend');
+        
+        if (!fs.existsSync(templatePath)) {
+            throw new Error('Backend template not found. Please ensure the CLI is properly installed.');
+        }
+
+        // Create target directory if it doesn't exist
+        await fs.ensureDir(this.targetPath);
+
+        // Check if directory is empty
+        const files = await fs.readdir(this.targetPath);
+        if (files.length > 0 && !this.options.force) {
+            throw new Error('Target directory is not empty. Use --force to override.');
+        }
+
+        console.log('🚀 Initializing new Frigg backend project...');
+
+        // Copy template files
+        await this.copyTemplateFiles(templatePath, this.targetPath);
+
+        // Update package.json with project name
+        await this.updatePackageJson();
+
+        // Update serverless.yml with project name
+        await this.updateServerlessConfig();
+
+        // Initialize git if requested
+        if (this.options.git !== false) {
+            await this.initializeGit();
+        }
+
+        // Install dependencies if requested
+        if (this.options.install !== false) {
+            await this.installDependencies();
+        }
+
+        console.log('✅ Frigg backend project initialized successfully!');
+        console.log('\nNext steps:');
+        console.log(`  cd ${path.basename(this.targetPath)}`);
+        if (this.options.install === false) {
+            console.log('  npm install');
+        }
+        console.log('  npm run docker:start');
+        console.log('  npm run backend-start');
+        console.log('\nFor more information, check the README.md file.');
+    }
+
+    /**
+     * Copy template files to target directory
+     */
+    async copyTemplateFiles(source, target) {
+        await fs.copy(source, target, {
+            overwrite: this.options.force || false,
+            filter: (src) => {
+                // Skip node_modules and other build artifacts
+                const basename = path.basename(src);
+                return !['node_modules', '.serverless', 'dist', 'build'].includes(basename);
+            }
+        });
+    }
+
+    /**
+     * Update package.json with project-specific details
+     */
+    async updatePackageJson() {
+        const packageJsonPath = path.join(this.targetPath, 'package.json');
+        const packageJson = await fs.readJson(packageJsonPath);
+        
+        // Update package name based on directory name
+        const projectName = path.basename(this.targetPath);
+        packageJson.name = projectName;
+        
+        // Remove private flag for new projects
+        delete packageJson.private;
+        
+        await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+    }
+
+    /**
+     * Update serverless.yml with project-specific details
+     */
+    async updateServerlessConfig() {
+        const serverlessPath = path.join(this.targetPath, 'serverless.yml');
+        let serverlessContent = await fs.readFile(serverlessPath, 'utf8');
+        
+        // Update service name based on directory name
+        const projectName = path.basename(this.targetPath);
+        serverlessContent = serverlessContent.replace(
+            /^service: create-frigg-app$/m,
+            `service: ${projectName}`
+        );
+        
+        await fs.writeFile(serverlessPath, serverlessContent);
+    }
+
+    /**
+     * Initialize git repository
+     */
+    async initializeGit() {
+        try {
+            console.log('📦 Initializing git repository...');
+            execSync('git init', { cwd: this.targetPath, stdio: 'ignore' });
+            execSync('git add .', { cwd: this.targetPath, stdio: 'ignore' });
+            execSync('git commit -m "Initial commit from Frigg CLI"', { 
+                cwd: this.targetPath, 
+                stdio: 'ignore' 
+            });
+        } catch (error) {
+            console.warn('⚠️  Git initialization failed. You can initialize git manually later.');
+        }
+    }
+
+    /**
+     * Install npm dependencies
+     */
+    async installDependencies() {
+        console.log('📦 Installing dependencies...');
+        execSync('npm install', { 
+            cwd: this.targetPath, 
+            stdio: 'inherit' 
+        });
+    }
+}
+
+module.exports = TemplateHandler;

package/frigg-cli/install-command/backend-js.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/install-command/commit-changes.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/install-command/environment-variables.js

@@ -0,0 +1,127 @@
+const fs = require('fs');
+const dotenv = require('dotenv');
+const { readFileSync, writeFileSync, existsSync } = require('fs');
+const { logInfo } = require('./logger');
+const { resolve } = require('node:path');
+const { confirm, input } = require('@inquirer/prompts');
+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 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 input({
+                        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/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/install-command/index.js

@@ -0,0 +1,54 @@
+const { installPackage } = require('./install-package');
+const { createIntegrationFile } = require('./integration-file');
+const { resolve } = require('node:path');
+const { updateBackendJsFile } = require('./backend-js');
+const { logInfo, logError } = require('./logger');
+const { commitChanges } = require('./commit-changes');
+const { handleEnvVariables } = require('./environment-variables');
+const {
+    validatePackageExists,
+    searchAndSelectPackage,
+} = require('./validate-package');
+const { findNearestBackendPackageJson, validateBackendPath } = require('@friggframework/core/utils');
+
+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/install-command/install-package.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/install-command/integration-file.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/install-command/logger.js

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