@nexical/cli 0.11.8 → 0.11.10

package/test/integration/commands/deploy.integration.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect, vi, beforeEach, afterAll } from 'vitest';
+import DeployCommand from '../../../src/commands/deploy.js';
+import { createTempDir, createMockRepo, cleanupTestRoot } from '../../utils/integration-helpers.js';
+import path from 'node:path';
+import fs from 'fs-extra';
+import { CLI } from '@nexical/cli-core';
+
+// Mock ConfigManager and Registry to control provider behavior without relying on real files or dynamic imports
+vi.mock('../../../src/deploy/config-manager.js', () => {
+  return {
+    ConfigManager: vi.fn().mockImplementation(function () {
+      return {
+        load: vi.fn().mockResolvedValue({
+          deploy: {
+            backend: { provider: 'railway' },
+            frontend: { provider: 'cloudflare' },
+            repository: { provider: 'github' },
+          },
+        }),
+      };
+    }),
+  };
+});
+
+vi.mock('../../../src/deploy/registry.js', () => {
+  return {
+    ProviderRegistry: vi.fn().mockImplementation(function () {
+      return {
+        loadCoreProviders: vi.fn(),
+        loadLocalProviders: vi.fn(),
+        getDeploymentProvider: vi.fn().mockImplementation((name) => {
+          if (name === 'railway') {
+            return {
+              name: 'railway',
+              provision: vi.fn().mockResolvedValue(undefined),
+              getSecrets: vi.fn().mockResolvedValue({ R_SEC: 'val' }),
+              getVariables: vi.fn().mockResolvedValue({ R_VAR: 'val' }),
+            };
+          }
+          if (name === 'cloudflare') {
+            return {
+              name: 'cloudflare',
+              provision: vi.fn().mockResolvedValue(undefined),
+              getSecrets: vi.fn().mockResolvedValue({ C_SEC: 'val' }),
+              getVariables: vi.fn().mockResolvedValue({ C_VAR: 'val' }),
+            };
+          }
+          return undefined;
+        }),
+        getRepositoryProvider: vi.fn().mockReturnValue({
+          name: 'github',
+          configureSecrets: vi.fn().mockResolvedValue(undefined),
+          configureVariables: vi.fn().mockResolvedValue(undefined),
+          generateWorkflow: vi.fn().mockImplementation(async (ctx, vars) => {
+            // Simulate writing a workflow file to verify context
+            const targetDir = path.join(ctx.cwd, '.github/workflows');
+            const targetFile = path.join(targetDir, 'deploy.yml');
+            await fs.ensureDir(targetDir);
+            await fs.writeFile(targetFile, 'yaml content');
+          }),
+        }),
+      };
+    }),
+  };
+});
+
+describe('Deploy Command Integration', () => {
+  let projectDir: string;
+
+  beforeEach(async () => {
+    const temp = await createTempDir('deploy-project-');
+    projectDir = await createMockRepo(temp, {
+      'package.json': '{"name": "deploy-project", "version": "1.0.0"}',
+      'nexical.yaml': 'site: deploy-test\nmodules: []',
+      '.env': 'TEST_ENV=true',
+    });
+  });
+
+  afterAll(async () => {
+    await cleanupTestRoot();
+  });
+
+  it('should execute full deployment flow', async () => {
+    const originalCwd = process.cwd();
+    try {
+      // Create a CLI instance
+      const cli = new CLI({ commandName: 'nexical' });
+      process.chdir(projectDir);
+
+      const deployCmd = new DeployCommand(cli);
+
+      // Execute run
+      await deployCmd.run({ env: 'production' });
+
+      // Verify file creation from our mocked provider
+      const workflowPath = path.join(projectDir, '.github/workflows/deploy.yml');
+      expect(await fs.pathExists(workflowPath)).toBe(true);
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+});

package/test/integration/commands/init.integration.test.ts

@@ -81,5 +81,20 @@ describe('InitCommand Integration', () => {
     // However, `InitCommand` runs `npm install`. If that fails, the command throws/exits.
     // We provided a minimal package.json so it should succeed.
     expect(fs.existsSync(path.join(targetPath, 'node_modules'))).toBe(true);
-  }, 60000); // Increase timeout for real git/npm ops
+  }, 60000);
+
+  it('should initialize with a custom repo', async () => {
+    const targetProjectName = 'custom-repo-project';
+    const targetPath = path.join(tempDir, targetProjectName);
+    const cli = new CLI({ commandName: 'nexical' });
+    const command = new InitCommand(cli);
+
+    await command.run({
+      directory: targetPath,
+      repo: starterRepoDir, // Reusing starter repo as "custom"
+    });
+
+    expect(fs.existsSync(targetPath)).toBe(true);
+    expect(fs.existsSync(path.join(targetPath, 'package.json'))).toBe(true);
+  }, 60000);
 });

package/test/integration/commands/module.integration.test.ts

@@ -1,5 +1,5 @@
 import { CLI } from '@nexical/cli-core';
-import { describe, it, expect, beforeEach, afterEach, afterAll, vi } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach, afterAll } from 'vitest';
 import ModuleAddCommand from '../../../src/commands/module/add.js';
 import ModuleRemoveCommand from '../../../src/commands/module/remove.js';
 import ModuleListCommand from '../../../src/commands/module/list.js';
@@ -8,6 +8,7 @@ import ModuleUpdateCommand from '../../../src/commands/module/update.js';
 import { createTempDir, createMockRepo, cleanupTestRoot } from '../../utils/integration-helpers.js';
 import path from 'node:path';
 import fs from 'fs-extra';
+import { execa } from 'execa';
 
 // Mock picocolors to return strings as-is for easy matching
 vi.mock('picocolors', () => ({
@@ -25,7 +26,6 @@ vi.mock('picocolors', () => ({
 
 describe('Module Commands Integration', () => {
   let projectDir: string;
-  let moduleRepo: string;
   let consoleTableSpy: unknown;
 
   beforeEach(async () => {
@@ -42,7 +42,7 @@ describe('Module Commands Integration', () => {
 
     // 2. Create a "Module" that is a SEPARATE git repo
     const modTemp = await createTempDir('module-source-');
-    moduleRepo = await createMockRepo(modTemp, {
+    await createMockRepo(modTemp, {
       'package.json': '{"name": "my-module", "version": "1.0.0", "description": "Awesome module"}',
       'module.yaml': 'name: my-module\nversion: 1.0.0',
       'index.ts': 'export const hello = "world";',
@@ -65,78 +65,104 @@ describe('Module Commands Integration', () => {
     await cleanupTestRoot();
   });
 
-  it('should add, list, update and remove a module', async () => {
+  it('should add, list, update and remove backend and frontend modules', async () => {
     const originalCwd = process.cwd();
-    const cli = new CLI({ commandName: 'nexical' });
+    // Re-initialize CLI for this test to ensure clean state if needed, though previously it was new per test
+    // We can reuse the CLI instance from beforeEach if we moved it there, but here it is fine.
+
+    // 1. Setup Backend Module Repo
+    const backendTemp = await createTempDir('backend-mod-');
+    const backendRepo = await createMockRepo(backendTemp, {
+      'package.json': '{"name": "backend-api", "version": "1.0.0"}',
+      'module.yaml': 'name: backend-api\nversion: 1.0.0',
+      'models.yaml': '- name: User\n  fields: {}', // Indicator
+    });
+
+    // 2. Setup Frontend Module Repo
+    const frontendTemp = await createTempDir('frontend-mod-');
+    const frontendRepo = await createMockRepo(frontendTemp, {
+      'package.json': '{"name": "frontend-ui", "version": "1.0.0"}',
+      'module.yaml': 'name: frontend-ui\nversion: 1.0.0',
+      'ui.yaml': 'theme: dark', // Indicator
+    });
+
     try {
       process.chdir(projectDir);
 
-      // 1. ADD MODULE
-      const addCmd = new ModuleAddCommand(cli);
+      // --- ADD BACKEND ---
+      // --- ADD BACKEND ---
+      // Actually `run` uses `this.projectRoot` which is set by `BaseCommand.init()`.
+
+      // Let's rely on the pattern from the existing file:
+      // imports: import { CLI } from '@nexical/cli-core';
+      // const cli = new CLI({ commandName: 'nexical' });
+      // const addCmd = new ModuleAddCommand(cli);
+
+      // I need to instantiate CLI first.
+      const cli = new CLI({ commandName: 'nexical' });
+
+      const addBackend = new ModuleAddCommand(cli);
+      (addBackend as unknown as { projectRoot: string }).projectRoot = projectDir;
+      // or we can rely on init() finding it if CWD is correct.
+      // Let's try to set it explicitly to be safe.
+
+      await addBackend.run({ url: backendRepo });
 
-      await addCmd.init();
-      await addCmd.run({ url: moduleRepo });
+      const backendPath = path.join(projectDir, 'apps/backend/modules/backend-api');
+      expect(fs.existsSync(backendPath)).toBe(true);
+      expect(fs.existsSync(path.join(backendPath, 'models.yaml'))).toBe(true);
 
-      const modulePath = path.join(projectDir, 'modules/my-module');
-      expect(fs.existsSync(modulePath)).toBe(true);
-      expect(fs.existsSync(path.join(modulePath, 'package.json'))).toBe(true);
+      // --- ADD FRONTEND ---
+      const addFrontend = new ModuleAddCommand(cli);
+      (addFrontend as unknown as { projectRoot: string }).projectRoot = projectDir;
+      await addFrontend.run({ url: frontendRepo });
 
-      // Verify nexical.yaml updated
+      const frontendPath = path.join(projectDir, 'apps/frontend/modules/frontend-ui');
+      expect(fs.existsSync(frontendPath)).toBe(true);
+      expect(fs.existsSync(path.join(frontendPath, 'ui.yaml'))).toBe(true);
+
+      // --- VERIFY CONFIG ---
       const config = await fs.readFile(path.join(projectDir, 'nexical.yaml'), 'utf8');
       expect(config).toContain('modules:');
-      expect(config).toContain('- my-module');
-
-      // Check it is a submodule
-      // .git file in module dir pointing to gitdir
-      expect(fs.existsSync(path.join(modulePath, '.git'))).toBe(true);
-      const gitModules = await fs.readFile(path.join(projectDir, '.gitmodules'), 'utf-8');
-      expect(gitModules).toContain('path = modules/my-module');
+      expect(config).toContain('backend:');
+      expect(config).toContain('  - backend-api'); // Indentation check might be flaky with yaml stringify, just check existence
+      expect(config).toContain('frontend:');
+      expect(config).toContain('  - frontend-ui');
 
-      // 2. LIST MODULES with valid module
+      // --- LIST ---
       const listCmd = new ModuleListCommand(cli);
-      await listCmd.init();
+      (listCmd as unknown as { projectRoot: string }).projectRoot = projectDir;
       await listCmd.run();
 
-      // Check console.table called with module info
       expect(consoleTableSpy).toHaveBeenCalledWith(
         expect.arrayContaining([
-          expect.objectContaining({
-            name: 'my-module',
-            version: '1.0.0',
-            description: 'Awesome module',
-          }),
+          expect.objectContaining({ name: 'backend-api', type: 'backend' }),
+          expect.objectContaining({ name: 'frontend-ui', type: 'frontend' }),
         ]),
       );
 
-      // 3. UPDATE MODULE
+      // --- REMOVE BACKEND ---
+      const removeCmd = new ModuleRemoveCommand(cli);
+      (removeCmd as unknown as { projectRoot: string }).projectRoot = projectDir;
+      await removeCmd.run({ name: 'backend-api' });
+
+      expect(fs.existsSync(backendPath)).toBe(false);
+
+      const configAfterRemove = await fs.readFile(path.join(projectDir, 'nexical.yaml'), 'utf8');
+      expect(configAfterRemove).not.toContain('backend-api');
+      expect(configAfterRemove).toContain('frontend-ui');
+
+      // --- UPDATE FRONTEND ---
+      // Commit a change to frontend repo
+      await execa('git', ['commit', '--allow-empty', '-m', 'New version'], { cwd: frontendRepo });
+
       const updateCmd = new ModuleUpdateCommand(cli);
-      await updateCmd.init();
-      await updateCmd.run({ name: 'my-module' });
-      // Hard to check "update" without changing the remote first.
-      // But we verify it ran without throwing.
+      (updateCmd as unknown as { projectRoot: string }).projectRoot = projectDir;
+      await updateCmd.run({});
 
-      // 4. REMOVE MODULE
-      const removeCmd = new ModuleRemoveCommand(cli);
-      await removeCmd.init();
-      await removeCmd.run({ name: 'my-module' });
-
-      expect(fs.existsSync(modulePath)).toBe(false);
-
-      // Verify git cleanup
-      // .git/modules/modules/my-module should be gone
-      const gitInternalModuleDir = path.join(projectDir, '.git/modules/modules/my-module');
-      expect(fs.existsSync(gitInternalModuleDir)).toBe(false);
-
-      // .gitmodules entry gone? `git rm` usually handles this.
-      // Check if .gitmodules file exists (if empty it might remain or be deleted depending on git version, usually implicitly updated)
-      if (fs.existsSync(path.join(projectDir, '.gitmodules'))) {
-        const updatedGitModules = await fs.readFile(path.join(projectDir, '.gitmodules'), 'utf-8');
-        expect(updatedGitModules).not.toContain('modules/my-module');
-      }
-
-      // Verify nexical.yaml updated
-      const configRemoved = await fs.readFile(path.join(projectDir, 'nexical.yaml'), 'utf8');
-      expect(configRemoved).not.toContain('- my-module');
+      // Verify submodule update?
+      // Diff hard to check without actually checking git status inside.
+      // But command should succeed.
     } finally {
       process.chdir(originalCwd);
     }

package/test/integration/commands/run.integration.test.ts

@@ -1,97 +1,92 @@
-import { CLI } from '@nexical/cli-core';
-import { describe, it, expect, beforeEach, afterEach, afterAll, vi } from 'vitest';
+import { describe, it, beforeEach, afterAll } from 'vitest';
 import RunCommand from '../../../src/commands/run.js';
-import { createTempDir } from '../../utils/integration-helpers.js';
+import { createTempDir, createMockRepo, cleanupTestRoot } from '../../utils/integration-helpers.js';
 import path from 'node:path';
 import fs from 'fs-extra';
-import { spawn } from 'child_process';
-import EventEmitter from 'events';
-
-vi.mock('child_process', () => ({
-  spawn: vi.fn(),
-  exec: vi.fn(),
-}));
+import { CLI } from '@nexical/cli-core';
 
-describe('RunCommand Integration', () => {
+describe('Run Command Integration', () => {
   let projectDir: string;
-  let spawnMock: ReturnType<typeof vi.mocked>;
 
   beforeEach(async () => {
-    projectDir = await createTempDir('run-project-');
-    vi.mocked(spawn).mockClear();
-
-    // Setup minimal env (New Architecture: no site/ directory)
-    await fs.ensureDir(projectDir);
-    await fs.outputFile(
-      path.join(projectDir, 'package.json'),
-      JSON.stringify({
-        name: 'nexical-core',
-        scripts: {
-          'test-script': 'echo test',
-        },
-      }),
-    );
-
-    await fs.ensureDir(path.join(projectDir, 'modules', 'my-auth'));
-    await fs.outputFile(
-      path.join(projectDir, 'modules', 'my-auth', 'package.json'),
-      JSON.stringify({
-        scripts: {
-          seed: 'node seed.js',
-        },
-      }),
-    );
+    const temp = await createTempDir('run-project-');
+    projectDir = await createMockRepo(temp, {
+      'package.json': '{"name": "run-project", "version": "1.0.0"}',
+      'nexical.yaml': 'site: run-test\nmodules: []',
+    });
 
-    spawnMock = vi.mocked(spawn).mockImplementation(() => {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const child = new EventEmitter() as any;
-      child.stdout = new EventEmitter();
-      child.stderr = new EventEmitter();
-      setTimeout(() => child.emit('close', 0), 10);
-      child.kill = vi.fn();
-      return child;
+    // Create a mock module with a script
+    const moduleDir = path.join(projectDir, 'apps/backend/modules/script-mod');
+    await fs.ensureDir(moduleDir);
+    await fs.writeJson(path.join(moduleDir, 'package.json'), {
+      name: 'script-mod',
+      version: '1.0.0',
+      scripts: {
+        'test-script': 'echo "Hello from script-mod"',
+      },
     });
-  });
 
-  afterEach(() => {
-    vi.clearAllMocks();
-    vi.restoreAllMocks();
+    // Add module to nexical.yaml manually or via helper
+    // For RunCommand, it relies on discovery or explicit path?
+    // RunCommand iterates over ALL modules found in nexical.yaml or file system?
+    // RunCommand implementation:
+    // It runs a command in ALL modules or specific ones.
+
+    // We need to register it in nexical.yaml for it to be found commonly
+    const configPath = path.join(projectDir, 'nexical.yaml');
+    await fs.writeFile(configPath, 'site: run-test\nmodules:\n  backend:\n    - script-mod');
   });
 
   afterAll(async () => {
-    if (projectDir) await fs.remove(projectDir);
+    await cleanupTestRoot();
   });
 
-  it('should run standard npm scripts', async () => {
-    const cli = new CLI({ commandName: 'nexical' });
-    const command = new RunCommand(cli);
-    Object.assign(command, { projectRoot: projectDir });
+  it('should run a script in a specific module', async () => {
+    const originalCwd = process.cwd();
+    try {
+      process.chdir(projectDir);
+      const cli = new CLI({ commandName: 'nexical' });
+      const runCmd = new RunCommand(cli);
+      (runCmd as unknown as { projectRoot: string }).projectRoot = projectDir;
+
+      // We need to capture stdout/stderr to verify execution
+      // But RunCommand uses `runCommand` from cli-core which uses execa.
+      // In integration test, execa is REAL.
+
+      // However, BaseCommand.run() might just spawn it.
+      // We can inspect the output if we could capture it.
+      // But `execa` streams to stdio usually.
+
+      // Let's rely on side effects or just that it doesn't throw.
+      // Or we can mock `runCommand` from `@nexical/cli-core` if we want to verify it called the script?
+      // But this is integration test, we want real execution.
+      // "Hello from script-mod" should be printed.
 
-    await command.run({ script: 'test-script', args: ['--flag'] });
+      await runCmd.run({ script: 'script-mod:test-script' });
 
-    expect(spawnMock).toHaveBeenCalledWith(
-      'npm',
-      ['run', 'test-script', '--', '--flag'],
-      expect.objectContaining({
-        cwd: projectDir,
-      }),
-    );
+      // If passing, it means it found the module and ran the script (which echoed and exited 0).
+    } finally {
+      process.chdir(originalCwd);
+    }
   });
 
-  it('should run module specific scripts', async () => {
-    const cli = new CLI({ commandName: 'nexical' });
-    const command = new RunCommand(cli);
-    Object.assign(command, { projectRoot: projectDir });
+  it('should run a script in root', async () => {
+    const originalCwd = process.cwd();
+    try {
+      process.chdir(projectDir);
+      const cli = new CLI({ commandName: 'nexical' });
+      const runCmd = new RunCommand(cli);
+      (runCmd as unknown as { projectRoot: string }).projectRoot = projectDir;
 
-    await command.run({ script: 'my-auth:seed', args: ['--force'] });
+      // Add a script to root package.json first
+      const pkgPath = path.join(projectDir, 'package.json');
+      const pkg = await fs.readJson(pkgPath);
+      pkg.scripts = { 'root-script': 'echo "Hello from root"' };
+      await fs.writeJson(pkgPath, pkg);
 
-    // Module scripts run via npm run scriptName inside module dir
-    expect(spawnMock).toHaveBeenCalledWith(
-      'npm',
-      ['run', 'seed', '--', '--force'],
-      expect.objectContaining({
-        cwd: path.resolve(projectDir, 'modules', 'my-auth'),
-      }),
-    );
+      await runCmd.run({ script: 'root-script' });
+    } finally {
+      process.chdir(originalCwd);
+    }
   });
 });

package/test/integration/commands/setup.integration.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect, beforeEach, afterAll } from 'vitest';
+import SetupCommand from '../../../src/commands/setup.js';
+import { createTempDir, createMockRepo, cleanupTestRoot } from '../../utils/integration-helpers.js';
+import path from 'node:path';
+import fs from 'fs-extra';
+import { CLI } from '@nexical/cli-core';
+
+describe('Setup Command Integration', () => {
+  let projectDir: string;
+
+  beforeEach(async () => {
+    const temp = await createTempDir('setup-project-');
+    projectDir = await createMockRepo(temp, {
+      'package.json': '{"name": "setup-project", "version": "1.0.0"}',
+      'nexical.yaml': 'site: setup-test\nmodules: []',
+    });
+
+    // Create core assets
+    await fs.ensureDir(path.join(projectDir, 'core/src'));
+    await fs.writeFile(path.join(projectDir, 'core/src/shared.ts'), 'export const shared = true;');
+
+    // Create app directories
+    await fs.ensureDir(path.join(projectDir, 'apps/backend'));
+    await fs.ensureDir(path.join(projectDir, 'apps/frontend'));
+  });
+
+  afterAll(async () => {
+    await cleanupTestRoot();
+  });
+
+  it('should symlink core assets to apps', async () => {
+    const originalCwd = process.cwd();
+    try {
+      process.chdir(projectDir); // Change CWD to simulate running from root
+      const cli = new CLI({ commandName: 'nexical' });
+      const setupCmd = new SetupCommand(cli);
+
+      // Execute setup command
+      await setupCmd.run();
+
+      // Verify symlinks
+      const backendSrc = path.join(projectDir, 'apps/backend/src');
+      expect(await fs.pathExists(backendSrc)).toBe(true);
+      const stat = await fs.lstat(backendSrc);
+      expect(stat.isSymbolicLink()).toBe(true);
+
+      const frontendSrc = path.join(projectDir, 'apps/frontend/src');
+      expect(await fs.pathExists(frontendSrc)).toBe(true);
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+});