@sfdc-webapps/cli 1.0.2

package/test/unit/import-merger.spec.ts

@@ -0,0 +1,395 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Project } from 'ts-morph';
+import { mergeImports } from '../../src/utils/import-merger.js';
+
+describe('import-merger', () => {
+  let project: Project;
+
+  beforeEach(() => {
+    project = new Project({ useInMemoryFileSystem: true });
+  });
+
+  describe('mergeImports - Scenarios that work', () => {
+    it('should merge named imports from the same module', () => {
+      const targetFile = project.createSourceFile(
+        'target.ts',
+        `import { useState } from 'react';
+
+export const App = () => {
+  const [state, setState] = useState(0);
+  return <div>{state}</div>;
+};`
+      );
+
+      const featureFile = project.createSourceFile(
+        'feature.ts',
+        `import { useEffect } from 'react';`
+      );
+
+      mergeImports(featureFile, targetFile);
+
+      const result = targetFile.getText();
+
+      // Should have both named imports
+      expect(result).toContain('useState');
+      expect(result).toContain('useEffect');
+      expect(result).toMatch(/from ['"]react['"]/);
+
+      // Should preserve code
+      expect(result).toContain('export const App');
+    });
+
+    it('should deduplicate imports from the same module in target', () => {
+      const targetFile = project.createSourceFile(
+        'target.ts',
+        `import { useState } from 'react';
+import { useEffect } from 'react';
+
+export const App = () => <div>Test</div>;`
+      );
+
+      const featureFile = project.createSourceFile(
+        'feature.ts',
+        `import { useMemo } from 'react';`
+      );
+
+      mergeImports(featureFile, targetFile);
+
+      const result = targetFile.getText();
+
+      // Should have all three hooks
+      expect(result).toContain('useState');
+      expect(result).toContain('useEffect');
+      expect(result).toContain('useMemo');
+
+      // Should preserve code
+      expect(result).toContain('export const App');
+    });
+
+    it('should not duplicate imports that already exist', () => {
+      const targetFile = project.createSourceFile(
+        'target.ts',
+        `import { useState, useEffect } from 'react';
+
+export const App = () => <div>Test</div>;`
+      );
+
+      const featureFile = project.createSourceFile(
+        'feature.ts',
+        `import { useState } from 'react';`
+      );
+
+      mergeImports(featureFile, targetFile);
+
+      const result = targetFile.getText();
+
+      // Should have both hooks
+      expect(result).toContain('useState');
+      expect(result).toContain('useEffect');
+
+      // Count occurrences of 'useState' in imports (should be 1)
+      const importSection = result.split('export')[0];
+      const useStateCount = (importSection.match(/useState/g) || []).length;
+      expect(useStateCount).toBe(1);
+    });
+
+    it('should handle when feature has no imports', () => {
+      const targetFile = project.createSourceFile(
+        'target.ts',
+        `import React from 'react';
+
+export const App = () => <div>Test</div>;`
+      );
+
+      const featureFile = project.createSourceFile(
+        'feature.ts',
+        `export const value = 42;`
+      );
+
+      mergeImports(featureFile, targetFile);
+
+      const result = targetFile.getText();
+
+      // Should keep existing import
+      expect(result).toMatch(/import React from ['"]react['"]/);
+      // Should preserve code
+      expect(result).toContain('export const App');
+    });
+
+    it('should handle when both files have no imports', () => {
+      const targetFile = project.createSourceFile(
+        'target.ts',
+        `export const value = 42;`
+      );
+
+      const featureFile = project.createSourceFile(
+        'feature.ts',
+        `export const other = 100;`
+      );
+
+      mergeImports(featureFile, targetFile);
+
+      const result = targetFile.getText();
+
+      // Should preserve code
+      expect(result).toContain('export const value = 42');
+    });
+
+    it('should add imports from different modules (no conflicts)', () => {
+      const targetFile = project.createSourceFile(
+        'target.ts',
+        `import React from 'react';
+import { Link } from 'react-router';
+
+export const App = () => <Link to="/">Home</Link>;`
+      );
+
+      const featureFile = project.createSourceFile(
+        'feature.ts',
+        `import { Outlet } from 'react-router';
+import styles from './styles.css';`
+      );
+
+      mergeImports(featureFile, targetFile);
+
+      const result = targetFile.getText();
+
+      // Should have all imports
+      expect(result).toContain('React');
+      expect(result).toContain('Link');
+      expect(result).toContain('Outlet');
+      expect(result).toContain('styles');
+      // Should preserve code
+      expect(result).toContain('export const App');
+    });
+
+    it('should handle relative imports from different paths', () => {
+      const targetFile = project.createSourceFile(
+        'target.ts',
+        `import ComponentA from './components/ComponentA';
+
+export const App = () => <ComponentA />;`
+      );
+
+      const featureFile = project.createSourceFile(
+        'feature.ts',
+        `import ComponentB from './components/ComponentB';
+import UtilA from '../utils/UtilA';`
+      );
+
+      mergeImports(featureFile, targetFile);
+
+      const result = targetFile.getText();
+
+      // Should have all imports
+      expect(result).toContain('ComponentA');
+      expect(result).toContain('ComponentB');
+      expect(result).toContain('UtilA');
+      expect(result).toContain('./components/');
+      expect(result).toContain('../utils/');
+    });
+  });
+
+  describe('mergeImports - Conflicting imports', () => {
+    it('should handle when target and feature have same default import name from different modules', () => {
+      // When both files import the same name from different modules,
+      // feature should take precedence
+
+      const targetFile = project.createSourceFile(
+        'target.ts',
+        `import AppLayout from './appLayout';
+
+export const routes = [];`
+      );
+
+      const featureFile = project.createSourceFile(
+        'feature.ts',
+        `import AppLayout from './different';
+import NewComponent from './new';`
+      );
+
+      mergeImports(featureFile, targetFile);
+
+      const result = targetFile.getText();
+
+      // Feature's import should replace target's import
+      expect(result).toContain('AppLayout');
+      expect(result).toContain('NewComponent');
+      expect(result).toMatch(/from ['"]\.\/different['"]/); // Feature's module path
+      expect(result).not.toMatch(/from ['"]\.\/appLayout['"]/); // Target's old module path should be replaced
+    });
+
+    it('should add imports when target has no imports', () => {
+      // Should be able to add imports to a file with no existing imports
+
+      const targetFile = project.createSourceFile(
+        'target.ts',
+        `export const value = 42;`
+      );
+
+      const featureFile = project.createSourceFile(
+        'feature.ts',
+        `import { useState } from 'react';`
+      );
+
+      mergeImports(featureFile, targetFile);
+
+      const result = targetFile.getText();
+
+      expect(result).toContain('useState');
+      expect(result).toMatch(/from ['"]react['"]/); // Accept both single and double quotes
+      expect(result).toContain('export const value = 42');
+    });
+  });
+
+  describe('mergeImports - Deduplication', () => {
+    it('should deduplicate duplicate named imports within an import declaration', () => {
+      // When target has duplicate imports, should deduplicate them
+      const targetFile = project.createSourceFile(
+        'target.ts',
+        `import { RouteObject, RouteObject } from 'react-router';
+
+export const routes = [];`
+      );
+
+      const featureFile = project.createSourceFile(
+        'feature.ts',
+        `import { Outlet } from 'react-router';`
+      );
+
+      mergeImports(featureFile, targetFile);
+
+      const result = targetFile.getText();
+
+      // Should deduplicate RouteObject and add Outlet
+      expect(result).toContain('RouteObject');
+      expect(result).toContain('Outlet');
+      expect(result).toMatch(/from ['"]react-router['"]/);
+
+      // Count occurrences of "RouteObject" in the import section (should be 1)
+      const importLines = result.split('export')[0]; // Get just the import section
+      const matches = importLines.match(/RouteObject/g);
+      expect(matches?.length).toBe(1);
+    });
+  });
+
+  describe('mergeImports - Type imports', () => {
+    it('should keep type imports separate from regular imports', () => {
+      // When target has type import and feature has regular import from same module,
+      // should keep both as separate import declarations
+      const targetFile = project.createSourceFile(
+        'target.ts',
+        `import type { RouteObject } from 'react-router';
+
+export const routes: RouteObject[] = [];`
+      );
+
+      const featureFile = project.createSourceFile(
+        'feature.ts',
+        `import { Outlet } from 'react-router';`
+      );
+
+      mergeImports(featureFile, targetFile);
+
+      const result = targetFile.getText();
+
+      // Should keep type import and add regular import as separate declarations
+      expect(result).toContain('RouteObject');
+      expect(result).toContain('Outlet');
+      expect(result).toContain('react-router');
+
+      // Should have both type and regular import declarations
+      expect(result).toContain('import type');
+      expect(result).toMatch(/import\s+\{[^}]*Outlet[^}]*\}\s+from/); // Regular import with Outlet
+    });
+  });
+
+  describe('mergeImports - Formatting', () => {
+    it('should preserve blank line between imports and code after removing __delete__ imports', () => {
+      // This simulates the scenario where a feature deletes an import,
+      // and we need to ensure proper formatting is maintained
+      const targetFile = project.createSourceFile(
+        'target.ts',
+        `import type { RouteObject } from 'react-router';
+import AppLayout from './appLayout';
+import Home from './home';
+import OldPage from './old-page';
+
+export const routes: RouteObject[] = [];`
+      );
+
+      const featureFile = project.createSourceFile(
+        'feature.ts',
+        `import type { RouteObject } from 'react-router';
+import AppLayout from './__inherit__appLayout';
+import About from './about';
+import OldPage from './__delete__old-page';
+
+export const routes: RouteObject[] = [];`
+      );
+
+      mergeImports(featureFile, targetFile);
+
+      const result = targetFile.getText();
+
+      // Should have the About import added
+      expect(result).toContain('About');
+
+      // Should NOT have the __delete__ import
+      expect(result).not.toContain('__delete__');
+
+      // Most importantly: should have blank line between imports and export
+      // Check that there's a newline after the last import before the export
+      expect(result).toMatch(/from ['"][^'"]+['"];\n\nexport const routes/);
+    });
+
+    it('should maintain blank line when merging routes with imports', () => {
+      // Simulates real-world scenario: base app + feature with routes
+      const targetFile = project.createSourceFile(
+        'routes.tsx',
+        `import type { RouteObject } from 'react-router';
+import AppLayout from './appLayout';
+import Home from './home';
+import OldPage from './old-page';
+
+export const routes: RouteObject[] = [
+  {
+    path: '/',
+    element: <AppLayout />,
+    children: [
+      { index: true, element: <Home /> },
+      { path: 'old', element: <OldPage /> }
+    ]
+  }
+];`
+      );
+
+      const featureFile = project.createSourceFile(
+        'feature-routes.tsx',
+        `import type { RouteObject } from 'react-router';
+import AppLayout from './__inherit__appLayout';
+import About from './about';
+
+export const routes: RouteObject[] = [
+  {
+    path: '/',
+    element: <AppLayout />,
+    children: [
+      { path: 'about', element: <About /> }
+    ]
+  }
+];`
+      );
+
+      mergeImports(featureFile, targetFile);
+
+      const result = targetFile.getText();
+
+      // Should have About import
+      expect(result).toContain('About');
+
+      // Should have blank line between imports and export
+      expect(result).toMatch(/from ['"][^'"]+['"];\n\nexport const routes/);
+    });
+  });
+});

package/test/unit/index.spec.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Command } from 'commander';
+
+// Mock the commands before importing index
+vi.mock('../../src/commands/apply-patches.js', () => ({
+  applyPatchesCommand: vi.fn().mockResolvedValue(undefined)
+}));
+
+vi.mock('../../src/commands/watch-patches.js', () => ({
+  watchPatchesCommand: vi.fn().mockResolvedValue({ shutdown: vi.fn() })
+}));
+
+describe('CLI index', () => {
+  let originalArgv: string[];
+  let exitSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    originalArgv = process.argv;
+    exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined as never);
+  });
+
+  afterEach(() => {
+    process.argv = originalArgv;
+    exitSpy.mockRestore();
+    vi.clearAllMocks();
+  });
+
+  it('should have apply-patches command defined', async () => {
+    const program = new Command();
+
+    // Simulate the index.ts command setup
+    program
+      .name('apply-patches')
+      .version('1.0.0');
+
+    program
+      .command('apply-patches')
+      .description('Apply feature patches to an app')
+      .argument('<feature-path>', 'Path to the feature')
+      .argument('<app-path>', 'Path to the app')
+      .argument('<target-dir>', 'Target directory')
+      .option('--skip-dependency-changes', 'Skip installing dependencies')
+      .option('--clean', 'Remove target directory if it exists');
+
+    const applyPatchesCmd = program.commands.find(cmd => cmd.name() === 'apply-patches');
+    expect(applyPatchesCmd).toBeDefined();
+    expect(applyPatchesCmd?.description()).toBe('Apply feature patches to an app');
+  });
+
+  it('should have watch-patches command defined', () => {
+    const program = new Command();
+
+    program
+      .name('apply-patches')
+      .version('1.0.0');
+
+    program
+      .command('watch-patches')
+      .description('Watch feature template directory and auto-apply patches on changes')
+      .argument('<feature-path>', 'Path to the feature')
+      .argument('<app-path>', 'Path to the app')
+      .argument('<target-dir>', 'Target directory')
+      .option('--clean', 'Remove target directory if it exists');
+
+    const watchPatchesCmd = program.commands.find(cmd => cmd.name() === 'watch-patches');
+    expect(watchPatchesCmd).toBeDefined();
+    expect(watchPatchesCmd?.description()).toBe('Watch feature template directory and auto-apply patches on changes');
+  });
+
+  it('should parse apply-patches command arguments correctly', () => {
+    const program = new Command();
+
+    program
+      .command('apply-patches')
+      .argument('<feature-path>', 'Path to the feature')
+      .argument('<app-path>', 'Path to the app')
+      .argument('<target-dir>', 'Target directory')
+      .option('--skip-dependency-changes', 'Skip installing dependencies')
+      .option('--clean', 'Remove target directory if it exists')
+      .action((featurePath, appPath, targetDir, options) => {
+        expect(featurePath).toBe('packages/feature-test');
+        expect(appPath).toBe('packages/base-app');
+        expect(targetDir).toBe('my-app');
+        expect(options.skipDependencyChanges).toBe(true);
+        expect(options.clean).toBeUndefined(); // Not provided, so undefined
+      });
+
+    program.parse(['node', 'cli', 'apply-patches', 'packages/feature-test', 'packages/base-app', 'my-app', '--skip-dependency-changes']);
+  });
+
+  it('should parse watch-patches command arguments correctly', () => {
+    const program = new Command();
+
+    program
+      .command('watch-patches')
+      .argument('<feature-path>', 'Path to the feature')
+      .argument('<app-path>', 'Path to the app')
+      .argument('<target-dir>', 'Target directory')
+      .option('--clean', 'Remove target directory if it exists')
+      .action((featurePath, appPath, targetDir, options) => {
+        expect(featurePath).toBe('packages/feature-test');
+        expect(appPath).toBe('packages/base-app');
+        expect(targetDir).toBe('watch-target');
+        expect(options.clean).toBe(true);
+      });
+
+    program.parse(['node', 'cli', 'watch-patches', 'packages/feature-test', 'packages/base-app', 'watch-target', '--clean']);
+  });
+
+  it('should handle missing required arguments', () => {
+    const program = new Command();
+    program.exitOverride(); // Prevent actual exit in tests
+
+    program
+      .command('apply-patches')
+      .argument('<feature-path>', 'Path to the feature')
+      .argument('<app-path>', 'Path to the app')
+      .argument('<target-dir>', 'Target directory');
+
+    expect(() => {
+      program.parse(['node', 'cli', 'apply-patches']); // Missing required args
+    }).toThrow();
+  });
+
+  it('should have correct option flags for apply-patches', () => {
+    const program = new Command();
+
+    program
+      .command('apply-patches')
+      .argument('<feature-path>', 'Path to the feature')
+      .argument('<app-path>', 'Path to the app')
+      .argument('<target-dir>', 'Target directory')
+      .option('--skip-dependency-changes', 'Skip installing dependencies from package.json')
+      .option('--clean', 'Remove target directory if it exists before applying patches');
+
+    const cmd = program.commands[0];
+    const options = cmd.options;
+
+    expect(options.find(opt => opt.long === '--skip-dependency-changes')).toBeDefined();
+    expect(options.find(opt => opt.long === '--clean')).toBeDefined();
+  });
+
+  it('should have correct option flags for watch-patches', () => {
+    const program = new Command();
+
+    program
+      .command('watch-patches')
+      .argument('<feature-path>', 'Path to the feature')
+      .argument('<app-path>', 'Path to the app')
+      .argument('<target-dir>', 'Target directory')
+      .option('--clean', 'Remove target directory if it exists before applying patches');
+
+    const cmd = program.commands[0];
+    const options = cmd.options;
+
+    expect(options.find(opt => opt.long === '--clean')).toBeDefined();
+  });
+});