@friggframework/devtools 2.0.0--canary.522.923dfae.0 → 2.0.0--canary.540.c5ef83f.0

package/frigg-cli/__tests__/unit/commands/init.test.js

@@ -1,406 +0,0 @@
-/**
- * Tests for the init command and BackendFirstHandler
- * TDD: These tests define the expected behavior for frigg init
- */
-
-const path = require('path');
-const fs = require('fs-extra');
-
-// Mock dependencies before requiring the modules
-jest.mock('@inquirer/prompts', () => ({
-    select: jest.fn(),
-    confirm: jest.fn(),
-    multiselect: jest.fn()
-}));
-
-jest.mock('../../../utils/npm-registry', () => ({
-    searchApiModules: jest.fn().mockResolvedValue([]),
-    getModulesByType: jest.fn().mockResolvedValue({})
-}));
-
-jest.mock('@friggframework/schemas', () => ({
-    validateAppDefinition: jest.fn().mockReturnValue({ valid: true, errors: [] }),
-    formatErrors: jest.fn().mockReturnValue('')
-}));
-
-const { select, confirm, multiselect } = require('@inquirer/prompts');
-const BackendFirstHandler = require('../../../init-command/backend-first-handler');
-
-describe('BackendFirstHandler', () => {
-    let tempDir;
-    let targetPath;
-
-    beforeEach(async () => {
-        // Create a real temporary directory for each test
-        tempDir = global.TestHelpers.createTempDir();
-        targetPath = path.join(tempDir, 'test-frigg-app');
-
-        // Reset all mocks
-        jest.clearAllMocks();
-    });
-
-    afterEach(async () => {
-        // Clean up
-        global.TestHelpers.cleanupTempDir(tempDir);
-    });
-
-    describe('constructor', () => {
-        test('initializes with target path and options', () => {
-            const handler = new BackendFirstHandler(targetPath, { verbose: true });
-
-            expect(handler.targetPath).toBe(targetPath);
-            expect(handler.appName).toBe('test-frigg-app');
-            expect(handler.options.verbose).toBe(true);
-        });
-
-        test('sets templates directory correctly', () => {
-            const handler = new BackendFirstHandler(targetPath);
-
-            expect(handler.templatesDir).toContain('templates');
-        });
-    });
-
-    describe('selectDeploymentMode', () => {
-        test('returns mode from options if provided', async () => {
-            const handler = new BackendFirstHandler(targetPath, { mode: 'standalone' });
-
-            const mode = await handler.selectDeploymentMode();
-
-            expect(mode).toBe('standalone');
-            expect(select).not.toHaveBeenCalled();
-        });
-
-        test('prompts user if mode not provided', async () => {
-            select.mockResolvedValue('embedded');
-            const handler = new BackendFirstHandler(targetPath, {});
-
-            const mode = await handler.selectDeploymentMode();
-
-            expect(mode).toBe('embedded');
-            expect(select).toHaveBeenCalledWith(expect.objectContaining({
-                message: expect.stringContaining('deploy')
-            }));
-        });
-    });
-
-    describe('getProjectConfiguration', () => {
-        test('collects all required configuration options', async () => {
-            const handler = new BackendFirstHandler(targetPath, { frontend: false });
-
-            // Mock all prompts in correct order
-            // 1. appPurpose
-            select.mockResolvedValueOnce('own-app');
-            // 2. needsCustomApiModule (only asked when appPurpose === 'own-app')
-            confirm.mockResolvedValueOnce(true);
-            // 3. includeIntegrations
-            confirm.mockResolvedValueOnce(false);
-            // 4. serverlessProvider (only for standalone)
-            select.mockResolvedValueOnce('aws');
-            // 5. installDependencies
-            confirm.mockResolvedValueOnce(true);
-            // 6. initializeGit
-            confirm.mockResolvedValueOnce(true);
-
-            const config = await handler.getProjectConfiguration('standalone');
-
-            expect(config.deploymentMode).toBe('standalone');
-            expect(config.appPurpose).toBe('own-app');
-            expect(config.needsCustomApiModule).toBe(true);
-            expect(config.installDependencies).toBe(true);
-            expect(config.initializeGit).toBe(true);
-        });
-
-        test('asks about demo frontend when not disabled', async () => {
-            const handler = new BackendFirstHandler(targetPath, { frontend: undefined });
-
-            // Mock prompts in correct order:
-            // 1. appPurpose
-            select.mockResolvedValueOnce('exploring');
-            // 2. includeIntegrations
-            confirm.mockResolvedValueOnce(false);
-            // 3. includeDemoFrontend (asked when frontend !== false)
-            confirm.mockResolvedValueOnce(true);
-            // 4. frontendFramework (asked when includeDemoFrontend is true)
-            select.mockResolvedValueOnce('react');
-            // 5. demoAuthMode (asked when includeDemoFrontend is true)
-            select.mockResolvedValueOnce('mock');
-            // 6. serverlessProvider (for standalone mode)
-            select.mockResolvedValueOnce('local');
-            // 7. installDependencies
-            confirm.mockResolvedValueOnce(true);
-            // 8. initializeGit
-            confirm.mockResolvedValueOnce(true);
-
-            const config = await handler.getProjectConfiguration('standalone');
-
-            expect(config.includeDemoFrontend).toBe(true);
-            expect(config.frontendFramework).toBe('react');
-            expect(config.demoAuthMode).toBe('mock');
-        });
-
-        test('skips demo frontend question when frontend is false', async () => {
-            const handler = new BackendFirstHandler(targetPath, { frontend: false });
-
-            select.mockResolvedValueOnce('exploring') // appPurpose
-                  .mockResolvedValueOnce('local'); // serverlessProvider
-            confirm.mockResolvedValueOnce(false) // includeIntegrations
-                   .mockResolvedValueOnce(true)  // installDependencies
-                   .mockResolvedValueOnce(true); // initializeGit
-
-            const config = await handler.getProjectConfiguration('standalone');
-
-            expect(config.includeDemoFrontend).toBeUndefined();
-        });
-    });
-
-    describe('createProject', () => {
-        test('creates target directory if it does not exist', async () => {
-            const handler = new BackendFirstHandler(targetPath, { force: true });
-
-            // Create minimal config
-            const config = {
-                deploymentMode: 'standalone',
-                installDependencies: false,
-                initializeGit: false,
-                serverlessProvider: 'local'
-            };
-
-            // Mock that templates exist
-            const templatesDir = handler.templatesDir;
-            const backendTemplateDir = path.join(templatesDir, 'backend');
-
-            // We expect the directory to be created
-            await handler.ensureSafeDirectory();
-
-            expect(fs.existsSync(targetPath)).toBe(true);
-        });
-
-        test('throws error when directory is not empty without force flag', async () => {
-            // Create target directory with a file in it
-            await fs.ensureDir(targetPath);
-            await fs.writeFile(path.join(targetPath, 'existing-file.js'), 'content');
-
-            const handler = new BackendFirstHandler(targetPath, { force: false });
-
-            await expect(handler.ensureSafeDirectory())
-                .rejects
-                .toThrow('Directory not empty');
-        });
-
-        test('allows non-empty directory with force flag', async () => {
-            // Create target directory with a file in it
-            await fs.ensureDir(targetPath);
-            await fs.writeFile(path.join(targetPath, 'existing-file.js'), 'content');
-
-            const handler = new BackendFirstHandler(targetPath, { force: true });
-
-            // Should not throw
-            await handler.ensureSafeDirectory();
-
-            expect(fs.existsSync(targetPath)).toBe(true);
-        });
-
-        test('allows allowed files without force flag', async () => {
-            // Create target directory with allowed files
-            await fs.ensureDir(targetPath);
-            await fs.writeFile(path.join(targetPath, '.git'), '');
-            await fs.writeFile(path.join(targetPath, '.gitignore'), '');
-            await fs.writeFile(path.join(targetPath, 'README.md'), '');
-
-            const handler = new BackendFirstHandler(targetPath, { force: false });
-
-            // Should not throw for allowed files
-            await handler.ensureSafeDirectory();
-
-            expect(fs.existsSync(targetPath)).toBe(true);
-        });
-    });
-
-    describe('createStandaloneProject', () => {
-        // Note: These tests rely on the real backend template in templates/backend
-        // If the template doesn't exist, tests will be skipped
-
-        test('creates package.json with correct scripts', async () => {
-            const handler = new BackendFirstHandler(targetPath, { force: true });
-            await fs.ensureDir(targetPath);
-
-            const config = {
-                serverlessProvider: 'aws',
-                starterIntegrations: [],
-                installDependencies: false
-            };
-
-            await handler.createStandaloneProject(config);
-
-            const packageJson = await fs.readJSON(path.join(targetPath, 'package.json'));
-
-            expect(packageJson.name).toBe('test-frigg-app');
-            expect(packageJson.scripts).toHaveProperty('start');
-            expect(packageJson.scripts).toHaveProperty('build');
-            expect(packageJson.scripts).toHaveProperty('deploy');
-            expect(packageJson.scripts).toHaveProperty('test');
-        });
-
-        test('adds selected integrations as dependencies', async () => {
-            const handler = new BackendFirstHandler(targetPath, { force: true });
-            await fs.ensureDir(targetPath);
-
-            const config = {
-                serverlessProvider: 'aws',
-                starterIntegrations: ['salesforce', 'hubspot'],
-                installDependencies: false
-            };
-
-            await handler.createStandaloneProject(config);
-
-            const packageJson = await fs.readJSON(path.join(targetPath, 'package.json'));
-
-            expect(packageJson.dependencies).toHaveProperty('@friggframework/api-module-salesforce');
-            expect(packageJson.dependencies).toHaveProperty('@friggframework/api-module-hubspot');
-        });
-
-        test('includes @friggframework/core as dependency', async () => {
-            const handler = new BackendFirstHandler(targetPath, { force: true });
-            await fs.ensureDir(targetPath);
-
-            const config = {
-                serverlessProvider: 'local',
-                starterIntegrations: [],
-                installDependencies: false
-            };
-
-            await handler.createStandaloneProject(config);
-
-            const packageJson = await fs.readJSON(path.join(targetPath, 'package.json'));
-
-            expect(packageJson.dependencies).toHaveProperty('@friggframework/core');
-        });
-    });
-
-    describe('createEmbeddedProject', () => {
-        // Note: These tests rely on the real backend template in templates/backend
-        // If the template doesn't exist, tests will be skipped
-
-        test('creates frigg-integration subdirectory', async () => {
-            const handler = new BackendFirstHandler(targetPath, { force: true });
-            await fs.ensureDir(targetPath);
-
-            const config = {
-                installDependencies: false
-            };
-
-            await handler.createEmbeddedProject(config);
-
-            const integrationDir = path.join(targetPath, 'frigg-integration');
-            expect(fs.existsSync(integrationDir)).toBe(true);
-        });
-
-        test('creates FRIGG_INTEGRATION.md guide', async () => {
-            const handler = new BackendFirstHandler(targetPath, { force: true });
-            await fs.ensureDir(targetPath);
-
-            const config = {
-                installDependencies: false
-            };
-
-            await handler.createEmbeddedProject(config);
-
-            const guidePath = path.join(targetPath, 'FRIGG_INTEGRATION.md');
-            expect(fs.existsSync(guidePath)).toBe(true);
-
-            const content = await fs.readFile(guidePath, 'utf8');
-            expect(content).toContain('# Frigg Integration Guide');
-            expect(content).toContain('@friggframework/core');
-        });
-    });
-
-    describe('getIntegrationClassName', () => {
-        test('converts known integrations to class names', () => {
-            const handler = new BackendFirstHandler(targetPath);
-
-            expect(handler.getIntegrationClassName('salesforce')).toBe('SalesforceIntegration');
-            expect(handler.getIntegrationClassName('hubspot')).toBe('HubSpotIntegration');
-            expect(handler.getIntegrationClassName('slack')).toBe('SlackIntegration');
-            expect(handler.getIntegrationClassName('google-sheets')).toBe('GoogleSheetsIntegration');
-        });
-
-        test('generates class name for unknown integrations', () => {
-            const handler = new BackendFirstHandler(targetPath);
-
-            expect(handler.getIntegrationClassName('custom-api')).toBe('Custom-apiIntegration');
-        });
-    });
-
-    describe('isUsingYarn', () => {
-        test('returns true when npm_config_user_agent contains yarn', () => {
-            const originalEnv = process.env.npm_config_user_agent;
-            process.env.npm_config_user_agent = 'yarn/1.22.0';
-
-            const handler = new BackendFirstHandler(targetPath);
-
-            expect(handler.isUsingYarn()).toBe(true);
-
-            process.env.npm_config_user_agent = originalEnv;
-        });
-
-        test('returns false when using npm', () => {
-            const originalEnv = process.env.npm_config_user_agent;
-            process.env.npm_config_user_agent = 'npm/8.0.0';
-
-            const handler = new BackendFirstHandler(targetPath);
-
-            expect(handler.isUsingYarn()).toBe(false);
-
-            process.env.npm_config_user_agent = originalEnv;
-        });
-    });
-});
-
-describe('initCommand', () => {
-    const { initCommand } = require('../../../init-command');
-    let tempDir;
-
-    beforeEach(() => {
-        tempDir = global.TestHelpers.createTempDir();
-        jest.clearAllMocks();
-    });
-
-    afterEach(() => {
-        global.TestHelpers.cleanupTempDir(tempDir);
-    });
-
-    test('validates project name - uppercase names are allowed in npm', async () => {
-        // Note: npm actually allows uppercase names now, they get lowercased
-        // The validate-npm-package-name package allows uppercase
-        const validName = path.join(tempDir, 'Valid-Name');
-
-        // Mock prompts to allow the command to proceed
-        select.mockResolvedValue('standalone');
-        confirm.mockResolvedValue(false);
-
-        // This should not throw for package name validation
-        // It may fail for other reasons like missing templates
-        try {
-            await initCommand(validName, { mode: 'standalone' });
-        } catch (e) {
-            // Expected to fail for missing template, not for name validation
-            expect(e.message).not.toContain('npm naming restrictions');
-        }
-    });
-
-    test('checks Node version', async () => {
-        const projectPath = path.join(tempDir, 'valid-project');
-
-        // Mock prompts to return quickly
-        select.mockResolvedValue('standalone');
-        confirm.mockResolvedValue(false);
-
-        // This should not throw for invalid Node version (just warn)
-        // The test validates checkNodeVersion is called
-        try {
-            await initCommand(projectPath, { mode: 'standalone' });
-        } catch (e) {
-            // May fail for other reasons, but shouldn't throw for Node version
-        }
-    });
-});

package/frigg-cli/__tests__/unit/commands/repair.test.js

@@ -1,275 +0,0 @@
-/**
- * Unit tests for frigg repair command
- * Tests repair workflow orchestration and output usage
- */
-
-// Mock all external dependencies
-jest.mock('../../../utils/output');
-jest.mock('../../../repair-command/index.js', () => {
-    const actualModule = jest.requireActual('../../../repair-command/index.js');
-    return actualModule;
-}, { virtual: false });
-
-const output = require('../../../utils/output');
-
-describe('Repair Command - Output Integration', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-
-        // Setup output mocks
-        output.success = jest.fn();
-        output.error = jest.fn();
-        output.info = jest.fn();
-        output.warn = jest.fn();
-        output.log = jest.fn();
-        output.confirm = jest.fn();
-    });
-
-    describe('Output method usage', () => {
-        test('should use output.success for successful operations', () => {
-            // Test that success messages use output.success
-            output.success(' No orphaned resources to import');
-
-            expect(output.success).toHaveBeenCalledWith(
-                expect.stringContaining('No orphaned resources')
-            );
-        });
-
-        test('should use output.error for error messages', () => {
-            // Test that errors use output.error
-            const error = new Error('Stack not found');
-            output.error('An error occurred:', error);
-
-            expect(output.error).toHaveBeenCalledWith('An error occurred:', error);
-        });
-
-        test('should use output.info for informational messages', () => {
-            // Test that info messages use output.info with emoji
-            output.info('🔍 Analyzing stack health...');
-
-            expect(output.info).toHaveBeenCalledWith(
-                expect.stringContaining('Analyzing stack')
-            );
-        });
-
-        test('should use output.warn for warnings', () => {
-            // Test that warnings use output.warn
-            output.warn('️  Build template not found');
-
-            expect(output.warn).toHaveBeenCalledWith(
-                expect.stringContaining('Build template not found')
-            );
-        });
-
-        test('should use output.log for general messages', () => {
-            // Test that general messages use output.log
-            output.log('  • serverless package');
-
-            expect(output.log).toHaveBeenCalledWith(
-                expect.stringContaining('serverless package')
-            );
-        });
-
-        test('should use output.confirm for user confirmations', async () => {
-            // Test that confirmations use output.confirm
-            output.confirm.mockResolvedValue(true);
-
-            const result = await output.confirm('Import 5 orphaned resource(s)?');
-
-            expect(output.confirm).toHaveBeenCalledWith(
-                expect.stringContaining('Import')
-            );
-            expect(result).toBe(true);
-        });
-    });
-
-    describe('Error handling scenarios', () => {
-        test('should handle and report stack not found errors', () => {
-            const error = new Error('Stack does not exist');
-            output.error('An error occurred:', error);
-
-            expect(output.error).toHaveBeenCalledWith('An error occurred:', error);
-        });
-
-        test('should handle and report import validation errors', () => {
-            output.log('\nValidation errors:');
-            output.log('  • Resource1: Invalid property');
-
-            expect(output.log).toHaveBeenCalledWith('\nValidation errors:');
-            expect(output.log).toHaveBeenCalledWith(expect.stringContaining('Invalid property'));
-        });
-
-        test('should handle and report AWS API errors', () => {
-            const error = new Error('AccessDenied: Insufficient permissions');
-            output.error('An error occurred:', error);
-
-            expect(output.error).toHaveBeenCalledWith('An error occurred:', error);
-        });
-    });
-
-    describe('User workflow scenarios', () => {
-        test('should report when no orphaned resources are found', () => {
-            output.success(' No orphaned resources to import');
-
-            expect(output.success).toHaveBeenCalled();
-            expect(output.success).toHaveBeenCalledWith(
-                expect.stringContaining('No orphaned resources')
-            );
-        });
-
-        test('should list orphaned resources before import', () => {
-            output.info('📦 Found 3 orphaned resource(s) to import:');
-            output.log('  1. AWS::Lambda::Function - my-function');
-            output.log('  2. AWS::S3::Bucket - my-bucket');
-            output.log('  3. AWS::DynamoDB::Table - my-table');
-
-            expect(output.info).toHaveBeenCalledWith(
-                expect.stringMatching(/Found \d+ orphaned/)
-            );
-            expect(output.log).toHaveBeenCalledTimes(3);
-        });
-
-        test('should warn when build template is missing', () => {
-            output.warn('️  Build template not found. Generating sequential logical IDs (not recommended).');
-            output.log('   Run one of the following to generate build template:');
-            output.log('     • serverless package');
-
-            expect(output.warn).toHaveBeenCalledWith(
-                expect.stringContaining('Build template not found')
-            );
-            expect(output.log).toHaveBeenCalledWith(
-                expect.stringContaining('serverless package')
-            );
-        });
-
-        test('should confirm before performing import', async () => {
-            output.confirm.mockResolvedValue(true);
-
-            const confirmed = await output.confirm('Import 5 orphaned resource(s) with sequential IDs?');
-
-            expect(output.confirm).toHaveBeenCalled();
-            expect(confirmed).toBe(true);
-        });
-
-        test('should handle user cancellation gracefully', async () => {
-            output.confirm.mockResolvedValue(false);
-
-            const confirmed = await output.confirm('Import resources?');
-            if (!confirmed) {
-                output.log('Import cancelled');
-            }
-
-            expect(output.confirm).toHaveBeenCalled();
-            expect(output.log).toHaveBeenCalledWith('Import cancelled');
-        });
-
-        test('should report successful import results', () => {
-            output.success(' Successfully imported 5 resource(s)');
-
-            expect(output.success).toHaveBeenCalledWith(
-                expect.stringMatching(/Successfully imported \d+/)
-            );
-        });
-    });
-
-    describe('Repair workflow stages', () => {
-        test('should progress through health check stage', () => {
-            output.info('🏥 Running health check on stack...');
-
-            expect(output.info).toHaveBeenCalledWith(
-                expect.stringContaining('health check')
-            );
-        });
-
-        test('should progress through import stage', () => {
-            output.info('🔧 Importing resources with sequential IDs...');
-
-            expect(output.info).toHaveBeenCalledWith(
-                expect.stringContaining('Importing resources')
-            );
-        });
-
-        test('should progress through reconciliation stage', () => {
-            output.info('🔄 Reconciling property drift...');
-
-            expect(output.info).toHaveBeenCalledWith(
-                expect.stringContaining('Reconciling')
-            );
-        });
-
-        test('should report completion with summary', () => {
-            output.success(' Repair completed successfully');
-            output.log('\nSummary:');
-            output.log('  • Imported: 5 resources');
-            output.log('  • Reconciled: 3 properties');
-
-            expect(output.success).toHaveBeenCalledWith(
-                expect.stringContaining('completed successfully')
-            );
-            expect(output.log).toHaveBeenCalledWith('\nSummary:');
-        });
-    });
-
-    describe('Output consistency', () => {
-        test('should not use console.log directly', () => {
-            // Verify that all logging goes through output module
-            const consoleLogSpy = jest.spyOn(console, 'log');
-
-            output.log('Test message');
-
-            // output.log may call console.log internally, but command code shouldn't
-            expect(output.log).toHaveBeenCalled();
-
-            consoleLogSpy.mockRestore();
-        });
-
-        test('should not use console.error directly', () => {
-            // Verify that all errors go through output module
-            const consoleErrorSpy = jest.spyOn(console, 'error');
-
-            const error = new Error('Test error');
-            output.error('An error occurred:', error);
-
-            // output.error may call console.error internally, but command code shouldn't
-            expect(output.error).toHaveBeenCalled();
-
-            consoleErrorSpy.mockRestore();
-        });
-
-        test('should use consistent emoji patterns', () => {
-            // Verify emoji usage follows patterns
-            output.success(' Success message'); // ✓ or ✅
-            output.error(' Error message'); // ✗ or ❌
-            output.warn('️ Warning message'); // ⚠️
-            output.info('🔍 Info message'); // Various info emojis
-
-            expect(output.success).toHaveBeenCalled();
-            expect(output.error).toHaveBeenCalled();
-            expect(output.warn).toHaveBeenCalled();
-            expect(output.info).toHaveBeenCalled();
-        });
-    });
-
-    describe('Migration verification', () => {
-        test('should have migrated all console.log calls', () => {
-            // This test verifies the migration was complete
-            // In the actual command file, there should be 0 console.log references
-            expect(output.log).toBeDefined();
-            expect(output.info).toBeDefined();
-            expect(output.success).toBeDefined();
-        });
-
-        test('should have migrated all console.error calls', () => {
-            // This test verifies the migration was complete
-            // In the actual command file, there should be 0 console.error references
-            expect(output.error).toBeDefined();
-            expect(output.warn).toBeDefined();
-        });
-
-        test('should have migrated readline confirm to output.confirm', () => {
-            // This test verifies readline was replaced with output.confirm
-            expect(output.confirm).toBeDefined();
-            expect(typeof output.confirm).toBe('function');
-        });
-    });
-});