@friggframework/devtools 2.0.0-next.29 → 2.0.0-next.30

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

@@ -0,0 +1,51 @@
+{
+  "name": "@friggframework/frigg-cli",
+  "version": "2.0.0-next.0",
+  "description": "Frigg Framework CLI tool",
+  "main": "index.js",
+  "bin": {
+    "frigg": "./index.js"
+  },
+  "scripts": {
+    "test": "jest"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.25.3",
+    "@babel/traverse": "^7.25.3",
+    "@friggframework/schemas": "workspace:*",
+    "@inquirer/prompts": "^5.3.8",
+    "axios": "^1.7.2",
+    "chalk": "^4.1.2",
+    "commander": "^12.1.0",
+    "cross-spawn": "^7.0.3",
+    "fs-extra": "^11.2.0",
+    "js-yaml": "^4.1.0",
+    "lodash": "4.17.21",
+    "node-cache": "^5.1.2",
+    "open": "^8.4.2",
+    "semver": "^7.6.0",
+    "validate-npm-package-name": "^5.0.0"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0"
+  },
+  "keywords": [
+    "frigg",
+    "cli",
+    "integration",
+    "framework"
+  ],
+  "author": "Frigg Framework Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/friggframework/frigg.git"
+  },
+  "bugs": {
+    "url": "https://github.com/friggframework/frigg/issues"
+  },
+  "homepage": "https://github.com/friggframework/frigg#readme",
+  "engines": {
+    "node": ">=18"
+  }
+}

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

@@ -0,0 +1,180 @@
+const path = require('path');
+const fs = require('fs-extra');
+const { initCommand } = require('../init-command');
+const BackendFirstHandler = require('../init-command/backend-first-handler');
+
+// Mock dependencies
+jest.mock('fs-extra');
+jest.mock('chalk', () => ({
+    blue: jest.fn(text => text),
+    green: jest.fn(text => text),
+    red: jest.fn(text => text),
+    yellow: jest.fn(text => text),
+    gray: jest.fn(text => text),
+    cyan: jest.fn(text => text),
+    bold: jest.fn(text => text)
+}));
+jest.mock('@inquirer/prompts');
+jest.mock('child_process');
+jest.mock('cross-spawn');
+jest.mock('../init-command/backend-first-handler');
+jest.mock('validate-npm-package-name');
+
+describe('Init Command', () => {
+    const mockProjectPath = '/test/project/path';
+    const mockProjectName = 'test-project';
+    let mockExit;
+    let mockConsoleLog;
+    const validateProjectName = require('validate-npm-package-name');
+    
+    beforeEach(() => {
+        jest.clearAllMocks();
+        
+        // Mock process.exit
+        mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {
+            throw new Error('process.exit');
+        });
+        
+        // Mock console.log and console.error
+        mockConsoleLog = jest.spyOn(console, 'log').mockImplementation();
+        jest.spyOn(console, 'error').mockImplementation();
+        
+        // Reset fs mocks
+        const fs = require('fs-extra');
+        fs.ensureDirSync.mockImplementation(() => {});
+        fs.pathExists.mockResolvedValue(false);
+        fs.readdir.mockResolvedValue([]);
+        fs.readdirSync.mockReturnValue([]);
+        fs.writeFileSync.mockImplementation(() => {});
+        fs.lstatSync.mockReturnValue({ isDirectory: () => false });
+        
+        // Mock BackendFirstHandler
+        BackendFirstHandler.mockImplementation(() => ({
+            initialize: jest.fn().mockResolvedValue()
+        }));
+        
+        // Mock validate-npm-package-name
+        validateProjectName.mockReturnValue({
+            validForNewPackages: true,
+            errors: [],
+            warnings: []
+        });
+    });
+    
+    afterEach(() => {
+        mockExit.mockRestore();
+        mockConsoleLog.mockRestore();
+    });
+
+    describe('Validation', () => {
+        it('should validate project name', async () => {
+            validateProjectName.mockReturnValue({
+                validForNewPackages: false,
+                errors: ['Invalid name'],
+                warnings: []
+            });
+            
+            await expect(initCommand('invalid-name', {})).rejects.toThrow('process.exit');
+            expect(mockExit).toHaveBeenCalledWith(1);
+            expect(console.error).toHaveBeenCalledWith(expect.stringContaining('npm naming restrictions'));
+        });
+
+        it('should accept valid project names', async () => {
+            validateProjectName.mockReturnValue({
+                validForNewPackages: true,
+                errors: [],
+                warnings: []
+            });
+            
+            await initCommand('valid-name', {});
+            expect(BackendFirstHandler).toHaveBeenCalled();
+        });
+
+        it('should check Node.js version compatibility', async () => {
+            const originalVersion = process.version;
+            Object.defineProperty(process, 'version', {
+                value: 'v12.0.0',
+                configurable: true
+            });
+
+            const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+            await initCommand(mockProjectName, {});
+            
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Node 14 or higher'));
+            
+            Object.defineProperty(process, 'version', {
+                value: originalVersion,
+                configurable: true
+            });
+            consoleSpy.mockRestore();
+        });
+    });
+
+    describe('Project Creation Modes', () => {
+        it('should use BackendFirstHandler by default', async () => {
+            await initCommand(mockProjectName, {});
+            
+            expect(BackendFirstHandler).toHaveBeenCalledWith(
+                expect.stringContaining(mockProjectName),
+                expect.objectContaining({
+                    force: false,
+                    verbose: false
+                })
+            );
+        });
+
+        it('should pass options to BackendFirstHandler', async () => {
+            const options = {
+                force: true,
+                verbose: true,
+                mode: 'standalone',
+                frontend: false
+            };
+            
+            await initCommand(mockProjectName, options);
+            
+            expect(BackendFirstHandler).toHaveBeenCalledWith(
+                expect.any(String),
+                expect.objectContaining(options)
+            );
+        });
+
+        it('should handle initialization errors gracefully', async () => {
+            const mockError = new Error('Initialization failed');
+            BackendFirstHandler.mockImplementation(() => ({
+                initialize: jest.fn().mockRejectedValue(mockError)
+            }));
+            
+            await expect(initCommand(mockProjectName, {})).rejects.toThrow('process.exit');
+            
+            expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('Aborting'));
+            expect(mockExit).toHaveBeenCalledWith(1);
+        });
+    });
+
+    describe('Directory Safety', () => {
+        it('should check if directory is safe to use', async () => {
+            BackendFirstHandler.mockImplementation(() => ({
+                initialize: jest.fn().mockRejectedValue(new Error('Directory not empty'))
+            }));
+            
+            await expect(initCommand(mockProjectName, {})).rejects.toThrow('process.exit');
+            
+            expect(mockExit).toHaveBeenCalledWith(1);
+        });
+
+        it('should allow safe files in directory', async () => {
+            await initCommand(mockProjectName, {});
+            expect(BackendFirstHandler).toHaveBeenCalled();
+        });
+
+        it('should force overwrite when --force flag is used', async () => {
+            await initCommand(mockProjectName, { force: true });
+            expect(BackendFirstHandler).toHaveBeenCalledWith(
+                expect.any(String),
+                expect.objectContaining({ force: true })
+            );
+        });
+    });
+
+});