@nexical/cli 0.10.0 → 0.11.1

package/test/unit/commands/setup.test.ts

@@ -0,0 +1,187 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import SetupCommand from '../../../src/commands/setup.js';
+import fs from 'fs-extra';
+import path from 'path';
+import { CLI } from '@nexical/cli-core';
+
+// Mock fs-extra
+vi.mock('fs-extra');
+
+describe('SetupCommand', () => {
+  let command: SetupCommand;
+  let mockCli: CLI;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let exitSpy: any;
+
+  // Mock BaseCommand methods
+  // We need to extend SetupCommand or mock the prototype to capture error/warn/success
+  // Or we can just spy on them if we can access the instance methods.
+
+  // Better approach: Spy on the prototype methods of BaseCommand or the instance itself.
+  // However, BaseCommand methods like `error` might process.exit.
+
+  // Let's create a subclass for testing or mock the CLI and use the standard instantiation.
+  // The current SetupCommand implementation calls `process.exit(1)` in `error` logic in `run`.
+  // Wait, looking at `setup.ts`:
+  // if (!fs.existsSync(path.join(rootDir, 'core'))) {
+  //     this.error('Could not find "core" directory. Are you in the project root?');
+  //     process.exit(1);
+  // }
+
+  // So we need to stub process.exit to prevent test runner from exiting.
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockCli = new CLI({ commandName: 'test-cli' });
+    command = new SetupCommand(mockCli);
+
+    // Spy on logging methods
+    vi.spyOn(command, 'error').mockImplementation(() => {});
+    vi.spyOn(command, 'warn').mockImplementation(() => {});
+    vi.spyOn(command, 'info').mockImplementation(() => {});
+    vi.spyOn(command, 'success').mockImplementation(() => {});
+
+    // Mock process.cwd to return a known path
+    vi.spyOn(process, 'cwd').mockReturnValue('/mock/project/root');
+
+    // Mock process.exit
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should error if "core" directory is missing', async () => {
+    // specific check: fs.existsSync returns false for core
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    await command.run();
+
+    expect(command.error).toHaveBeenCalledWith(
+      'Could not find "core" directory. Are you in the project root?',
+    );
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it('should warn and skip if app directory is missing', async () => {
+    // Setup fs mocks
+    vi.mocked(fs.existsSync).mockImplementation((p) => {
+      const pStr = p.toString();
+      if (pStr.endsWith('core')) return true;
+      if (pStr.endsWith('apps/frontend')) return true;
+      if (pStr.endsWith('apps/backend')) return false; // Missing backend
+      return false;
+    });
+
+    await command.run();
+
+    expect(command.warn).toHaveBeenCalledWith('App directory backend not found. Skipping.');
+    expect(command.info).toHaveBeenCalledWith('Setting up frontend...');
+  });
+
+  it('should symlink shared assets', async () => {
+    // Setup fs mocks
+    vi.mocked(fs.existsSync).mockImplementation((p) => {
+      const pStr = p.toString();
+      // Core exists
+      if (pStr.endsWith('core')) return true;
+      // Apps exist
+      if (pStr.endsWith('apps/frontend') || pStr.endsWith('apps/backend')) return true;
+
+      // Shared assets in core exist
+      if (pStr.includes('core/') && !pStr.endsWith('core')) return true;
+
+      return false;
+    });
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(fs.lstatSync).mockReturnValue({ isSymbolicLink: () => true } as any);
+
+    await command.run();
+
+    // Check if verify apps are processed
+    expect(command.info).toHaveBeenCalledWith('Setting up frontend...');
+    expect(command.info).toHaveBeenCalledWith('Setting up backend...');
+
+    // Check symlink calls
+    // We have 2 apps * 7 shared assets = 14 symlinks
+    // sharedAssets = ['prisma', 'src', 'public', 'locales', 'scripts', 'astro.config.mjs', 'tsconfig.json']
+
+    const assets = [
+      'prisma',
+      'src',
+      'public',
+      'locales',
+      'scripts',
+      'astro.config.mjs',
+      'tsconfig.json',
+    ];
+
+    for (const app of ['frontend', 'backend']) {
+      for (const asset of assets) {
+        const dest = path.join('/mock/project/root', 'apps', app, asset);
+        // const source = path.join('/mock/project/root', 'core', asset);
+
+        // Ensure removeSync called
+        expect(fs.removeSync).toHaveBeenCalledWith(dest);
+
+        // Ensure symlink called
+        // valid relative path calculation might vary, but verify arguments
+        expect(fs.symlink).toHaveBeenCalled();
+      }
+    }
+
+    expect(command.success).toHaveBeenCalledWith('Application setup complete.');
+  });
+
+  it('should warn if source asset is missing in core', async () => {
+    // Setup fs mocks
+    vi.mocked(fs.existsSync).mockImplementation((p) => {
+      const pStr = p.toString();
+      if (pStr.endsWith('core')) return true;
+      if (pStr.includes('apps/')) return true;
+
+      // Mock that 'prisma' is missing in core
+      if (pStr.endsWith('core/prisma')) return false;
+
+      // Others exist
+      if (pStr.includes('core/') && !pStr.endsWith('core')) return true;
+
+      return false;
+    });
+
+    await command.run();
+
+    expect(command.warn).toHaveBeenCalledWith('Source asset prisma not found in core.');
+  });
+
+  it('should throw error if removal fails with non-ENOENT', async () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(fs.lstatSync).mockReturnValue({ isSymbolicLink: () => true } as any);
+
+    const error = new Error('Permission denied');
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (error as any).code = 'EACCES';
+    vi.mocked(fs.removeSync).mockImplementation(() => {
+      throw error;
+    });
+
+    await command.run();
+
+    expect(command.error).toHaveBeenCalledWith(expect.stringContaining('Failed to symlink'));
+  });
+
+  it('should log error if symlink fails', async () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(fs.lstatSync).mockReturnValue({ isSymbolicLink: () => true } as any);
+    vi.mocked(fs.symlink).mockRejectedValue(new Error('Symlink failed'));
+
+    await command.run();
+
+    expect(command.error).toHaveBeenCalledWith(expect.stringContaining('Failed to symlink'));
+  });
+});

package/test/unit/utils/command-discovery.test.ts

@@ -1,5 +1,4 @@
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { discoverCommandDirectories } from '../../../src/utils/discovery';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -9,126 +8,135 @@ vi.mock('node:fs');
 // Mock path module to allow controlled resolution for duplicate testing
 const originalPath = await import('node:path');
 const originalResolve = originalPath.resolve;
-const originalJoin = originalPath.join;
 
 vi.mock('node:path', async (importOriginal) => {
-    const mod = await importOriginal<any>();
-    return {
-        ...mod,
-        default: {
-            ...mod.default,
-            resolve: vi.fn((...args: string[]) => mod.default.resolve(...args)),
-        },
-        resolve: vi.fn((...args: string[]) => mod.resolve(...args)),
-    };
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const mod: any = await importOriginal();
+  return {
+    ...mod,
+    default: {
+      ...mod.default,
+      resolve: vi.fn((...args: string[]) => mod.default.resolve(...args)),
+    },
+    resolve: vi.fn((...args: string[]) => mod.resolve(...args)),
+  };
 });
 
 vi.mock('@nexical/cli-core', () => ({
-    logger: {
-        debug: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn()
-    }
+  logger: {
+    debug: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  },
 }));
 
 describe('discoverCommandDirectories', () => {
-    // ... setup ...
-    const cwd = '/app';
-
-    beforeEach(() => {
-        vi.resetAllMocks();
-        // Restore default path behavior
-        vi.mocked(path.resolve).mockImplementation(originalResolve);
-        // Default fs mocks
-        vi.mocked(fs.existsSync).mockReturnValue(false);
-        vi.mocked(fs.readdirSync).mockReturnValue([]);
-        vi.mocked(fs.statSync).mockReturnValue({ isDirectory: () => true } as any);
-    });
-
-    it('should return empty list if no directories exist', () => {
-        const dirs = discoverCommandDirectories(cwd);
-        expect(dirs).toHaveLength(0);
+  // ... setup ...
+  const cwd = '/app';
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    // Restore default path behavior
+    vi.mocked(path.resolve).mockImplementation(originalResolve);
+    // Default fs mocks
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+    vi.mocked(fs.readdirSync).mockReturnValue([]);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(fs.statSync).mockReturnValue({ isDirectory: () => true } as any);
+  });
+
+  it('should return empty list if no directories exist', () => {
+    const dirs = discoverCommandDirectories(cwd);
+    expect(dirs).toHaveLength(0);
+  });
+
+  it('should find core commands in project directory', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(fs.existsSync).mockImplementation((p: any) => {
+      return p === path.resolve('/app/src/commands');
     });
 
-    it('should find core commands in project directory', () => {
-        vi.mocked(fs.existsSync).mockImplementation((p: any) => {
-            return p === path.resolve('/app/src/commands');
-        });
-
-        const dirs = discoverCommandDirectories(cwd);
-        expect(dirs).toContain(path.resolve('/app/src/commands'));
+    const dirs = discoverCommandDirectories(cwd);
+    expect(dirs).toContain(path.resolve('/app/src/commands'));
+  });
+
+  it('should scan modules for commands', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(fs.existsSync).mockImplementation((p: any) => {
+      if (p === path.resolve('/app/modules')) return true;
+      if (p === path.resolve('/app/modules/mod1')) return true;
+      if (p === path.resolve('/app/modules/mod1/src/commands')) return true;
+      if (p === path.resolve('/app/modules/mod2')) return true;
+      return false;
     });
 
-    it('should scan modules for commands', () => {
-        vi.mocked(fs.existsSync).mockImplementation((p: any) => {
-            if (p === path.resolve('/app/modules')) return true;
-            if (p === path.resolve('/app/modules/mod1')) return true;
-            if (p === path.resolve('/app/modules/mod1/src/commands')) return true;
-            if (p === path.resolve('/app/modules/mod2')) return true;
-            return false;
-        });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(fs.readdirSync).mockReturnValue(['mod1', 'mod2', '.hidden'] as any);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(fs.statSync).mockReturnValue({ isDirectory: () => true } as any);
 
-        vi.mocked(fs.readdirSync).mockReturnValue(['mod1', 'mod2', '.hidden'] as any);
-        vi.mocked(fs.statSync).mockReturnValue({ isDirectory: () => true } as any);
+    const dirs = discoverCommandDirectories(cwd);
 
-        const dirs = discoverCommandDirectories(cwd);
+    expect(dirs).toContain(path.resolve('/app/modules/mod1/src/commands'));
+    expect(dirs).not.toContain(path.resolve('/app/modules/mod2/src/commands'));
+  });
 
-        expect(dirs).toContain(path.resolve('/app/modules/mod1/src/commands'));
-        expect(dirs).not.toContain(path.resolve('/app/modules/mod2/src/commands'));
+  it('should scan src/modules for commands', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(fs.existsSync).mockImplementation((p: any) => {
+      if (p === path.resolve('/app/src/modules')) return true;
+      if (p === path.resolve('/app/src/modules/mod-src')) return true;
+      if (p === path.resolve('/app/src/modules/mod-src/src/commands')) return true;
+      return false;
     });
 
-    it('should scan src/modules for commands', () => {
-        vi.mocked(fs.existsSync).mockImplementation((p: any) => {
-            if (p === path.resolve('/app/src/modules')) return true;
-            if (p === path.resolve('/app/src/modules/mod-src')) return true;
-            if (p === path.resolve('/app/src/modules/mod-src/src/commands')) return true;
-            return false;
-        });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(fs.readdirSync).mockReturnValue(['mod-src'] as any);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(fs.statSync).mockReturnValue({ isDirectory: () => true } as any);
 
-        vi.mocked(fs.readdirSync).mockReturnValue(['mod-src'] as any);
-        vi.mocked(fs.statSync).mockReturnValue({ isDirectory: () => true } as any);
+    const dirs = discoverCommandDirectories(cwd);
 
-        const dirs = discoverCommandDirectories(cwd);
+    expect(dirs).toContain(path.resolve('/app/src/modules/mod-src/src/commands'));
+  });
 
-        expect(dirs).toContain(path.resolve('/app/src/modules/mod-src/src/commands'));
+  it('should handle errors when scanning modules', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(fs.existsSync).mockImplementation((p: any) => {
+      return p === path.resolve('/app/src/commands');
     });
-
-    it('should handle errors when scanning modules', () => {
-        vi.mocked(fs.existsSync).mockImplementation((p: any) => {
-            return p === path.resolve('/app/src/commands');
-        });
-        vi.mocked(fs.readdirSync).mockImplementation((p: any) => {
-            if (p.includes('modules')) throw new Error('Permission denied');
-            return [];
-        });
-
-        const dirs = discoverCommandDirectories(cwd);
-        // Should not crash
-        expect(dirs).toHaveLength(1);
-        expect(dirs).toContain(path.resolve('/app/src/commands'));
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(fs.readdirSync).mockImplementation((p: any) => {
+      if (p.includes('modules')) throw new Error('Permission denied');
+      return [];
     });
 
-    it('should deduplicate dist and src core commands', () => {
-        const srcPath = path.resolve('/app/src/commands');
-        const distPath = path.resolve('/app/dist/src/commands');
+    const dirs = discoverCommandDirectories(cwd);
+    // Should not crash
+    expect(dirs).toHaveLength(1);
+    expect(dirs).toContain(path.resolve('/app/src/commands'));
+  });
+
+  it('should deduplicate dist and src core commands', () => {
+    // const srcPath = path.resolve('/app/src/commands');
 
-        // First we add distPath (manually simulate index.ts adding it to visited if we could, 
-        // but here we test the internal visited set of discoverCommandDirectories for multiple calls if we used it that way,
-        // or rather we test how it handles its OWN loops.
-        // Actually discoverCommandDirectories doesn't see distPath unless we add it to its loops.
+    // First we add distPath (manually simulate index.ts adding it to visited if we could,
+    // but here we test the internal visited set of discoverCommandDirectories for multiple calls if we used it that way,
+    // or rather we test how it handles its OWN loops.
+    // Actually discoverCommandDirectories doesn't see distPath unless we add it to its loops.
 
-        // Let's test if it skips src/commands if it SHOULD.
-        // Wait, the new logic in discovery.ts skips src/commands if dist/src/commands is in visited.
-        // So we need to simulate adding dist/src/commands first.
+    // Let's test if it skips src/commands if it SHOULD.
+    // Wait, the new logic in discovery.ts skips src/commands if dist/src/commands is in visited.
+    // So we need to simulate adding dist/src/commands first.
 
-        // Actually my new logic in discovery.ts DOES NOT scan for dist/src/commands automatically.
-        // It relies on index.ts adding it, OR if it's found in a module.
+    // Actually my new logic in discovery.ts DOES NOT scan for dist/src/commands automatically.
+    // It relies on index.ts adding it, OR if it's found in a module.
 
-        // Let's test the deduplication logic in addDir specifically if we can.
-        // I'll add a test case that calls it twice conceptually.
+    // Let's test the deduplication logic in addDir specifically if we can.
+    // I'll add a test case that calls it twice conceptually.
 
-        // Wait, discovery.ts:
-        /*
+    // Wait, discovery.ts:
+    /*
             const isSrc = resolved.endsWith(path.join('src', 'commands'));
             if (isSrc) {
                 const distEquivalent = resolved.replace(path.sep + 'src' + path.sep, path.sep + 'dist' + path.sep + 'src' + path.sep);
@@ -136,41 +144,46 @@ describe('discoverCommandDirectories', () => {
             }
         */
 
-        // Implementation check:
-        vi.mocked(fs.existsSync).mockReturnValue(true);
-        vi.mocked(fs.readdirSync).mockReturnValue([]);
+    // Implementation check:
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readdirSync).mockReturnValue([]);
 
-        // Since we can't easily control 'visited' from outside, we trust the logic.
-        // But we can verify it doesn't return BOTH if they resolve to same thing (already handled by visited.has(resolved)).
-    });
-
-    it('should ignore duplicate paths', () => {
-        const corePath = path.resolve('/app/src/commands');
-
-        vi.mocked(fs.existsSync).mockImplementation((p: any) => {
-            return p === corePath;
-        });
+    // Since we can't easily control 'visited' from outside, we trust the logic.
+    // But we can verify it doesn't return BOTH if they resolve to same thing (already handled by visited.has(resolved)).
+  });
 
-        const dirs = discoverCommandDirectories(cwd);
+  it('should ignore duplicate paths', () => {
+    const corePath = path.resolve('/app/src/commands');
 
-        expect(dirs).toContain(corePath);
-        expect(dirs).toHaveLength(1);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(fs.existsSync).mockImplementation((p: any) => {
+      return p === corePath;
     });
 
-    it('should ignore files in modules directory', () => {
-        vi.mocked(fs.existsSync).mockReturnValue(true);
-        vi.mocked(fs.readdirSync).mockReturnValue(['mod1', 'file.txt'] as any);
-        vi.mocked(fs.statSync).mockImplementation((p: any) => {
-            if (typeof p === 'string' && p.endsWith('file.txt')) {
-                return { isDirectory: () => false } as any;
-            }
-            return { isDirectory: () => true } as any;
-        });
-
-        const dirs = discoverCommandDirectories(cwd);
-        // Should process mod1, ignore file.txt
-        // The logic prefers dist/src/commands if it exists, and our mock returns true for all existsSync
-        expect(dirs).toContain(path.resolve('/app/modules/mod1/dist/src/commands'));
-        expect(dirs).not.toContain(path.resolve('/app/modules/file.txt/src/commands'));
+    const dirs = discoverCommandDirectories(cwd);
+
+    expect(dirs).toContain(corePath);
+    expect(dirs).toHaveLength(1);
+  });
+
+  it('should ignore files in modules directory', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(fs.readdirSync).mockReturnValue(['mod1', 'file.txt'] as any);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(fs.statSync).mockImplementation((p: any) => {
+      if (typeof p === 'string' && p.endsWith('file.txt')) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return { isDirectory: () => false } as any;
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return { isDirectory: () => true } as any;
     });
+
+    const dirs = discoverCommandDirectories(cwd);
+    // Should process mod1, ignore file.txt
+    // The logic prefers dist/src/commands if it exists, and our mock returns true for all existsSync
+    expect(dirs).toContain(path.resolve('/app/modules/mod1/dist/src/commands'));
+    expect(dirs).not.toContain(path.resolve('/app/modules/file.txt/src/commands'));
+  });
 });