@nexical/cli 0.11.7 → 0.11.9

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

@@ -1,7 +1,6 @@
 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
@@ -13,25 +12,8 @@ describe('SetupCommand', () => {
   // 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();
+    vi.resetAllMocks();
     mockCli = new CLI({ commandName: 'test-cli' });
     command = new SetupCommand(mockCli);
 
@@ -46,7 +28,7 @@ describe('SetupCommand', () => {
 
     // Mock process.exit
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+    exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {}) as unknown as any);
   });
 
   afterEach(() => {
@@ -54,7 +36,6 @@ describe('SetupCommand', () => {
   });
 
   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();
@@ -66,12 +47,11 @@ describe('SetupCommand', () => {
   });
 
   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
+      if (pStr.endsWith('apps/backend')) return false;
       return false;
     });
 
@@ -82,65 +62,33 @@ describe('SetupCommand', () => {
   });
 
   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);
+    vi.mocked(fs.lstatSync).mockReturnValue({ isSymbolicLink: () => true } as unknown 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']
-
-    const assets = ['prisma', 'src', 'public', 'locales', 'scripts'];
-
-    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(fs.removeSync).toHaveBeenCalled();
+    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;
     });
 
@@ -149,15 +97,15 @@ describe('SetupCommand', () => {
     expect(command.warn).toHaveBeenCalledWith('Source asset prisma not found in core.');
   });
 
-  it('should throw error if removal fails with non-ENOENT', async () => {
+  it('should log 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);
+    vi.mocked(fs.lstatSync).mockReturnValue({ isSymbolicLink: () => true } as unknown 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(() => {
+     
+    (error as unknown as { code: string }).code = 'EACCES';
+    vi.mocked(fs.removeSync).mockImplementationOnce(() => {
       throw error;
     });
 
@@ -166,14 +114,25 @@ describe('SetupCommand', () => {
     expect(command.error).toHaveBeenCalledWith(expect.stringContaining('Failed to symlink'));
   });
 
-  it('should log error if symlink fails', async () => {
+  it('should log error if symlink fails with Error object', 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'));
+    vi.mocked(fs.lstatSync).mockReturnValue({ isSymbolicLink: () => true } as unknown as any);
+    vi.mocked(fs.symlink).mockRejectedValueOnce(new Error('Symlink failed'));
 
     await command.run();
 
     expect(command.error).toHaveBeenCalledWith(expect.stringContaining('Failed to symlink'));
   });
+
+  it('should log error if symlink fails with non-Error object', async () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(fs.lstatSync).mockReturnValue({ isSymbolicLink: () => true } as unknown as any);
+    vi.mocked(fs.symlink).mockRejectedValueOnce('String symlink fail');
+
+    await command.run();
+
+    expect(command.error).toHaveBeenCalledWith(expect.stringContaining('String symlink fail'));
+  });
 });

package/test/unit/deploy/config-manager.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ConfigManager } from '../../../src/deploy/config-manager.js';
+import fs from 'node:fs/promises';
+import { NexicalConfig } from '../../../src/deploy/types.js';
+
+vi.mock('node:fs/promises');
+
+describe('ConfigManager', () => {
+  let manager: ConfigManager;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    manager = new ConfigManager('/mock');
+  });
+
+  it('should load config', async () => {
+    const mockConfig: NexicalConfig = {
+      deploy: {
+        backend: {
+          provider: 'railway',
+        },
+      },
+    };
+    vi.mocked(fs.readFile).mockResolvedValue('deploy:\n  backend:\n    provider: railway');
+    const config = await manager.load();
+    expect(config).toEqual(mockConfig);
+  });
+
+  it('should return empty object if config missing', async () => {
+    const error = new Error('not found');
+    (error as unknown as { code: string }).code = 'ENOENT';
+    vi.mocked(fs.readFile).mockRejectedValue(error);
+    const config = await manager.load();
+    expect(config).toEqual({});
+  });
+
+  it('should throw on other load errors', async () => {
+    vi.mocked(fs.readFile).mockRejectedValue(new Error('crash'));
+    await expect(manager.load()).rejects.toThrow('crash');
+  });
+
+  it('should save config', async () => {
+    const mockConfig: NexicalConfig = {
+      deploy: {
+        frontend: {
+          provider: 'cloudflare',
+        },
+      },
+    };
+    await manager.save(mockConfig);
+    expect(fs.writeFile).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.stringContaining('provider: cloudflare'),
+      'utf-8',
+    );
+  });
+
+  it('should check existence', async () => {
+    vi.mocked(fs.access).mockResolvedValue(undefined);
+    expect(await manager.exists()).toBe(true);
+
+    vi.mocked(fs.access).mockRejectedValue(new Error());
+    expect(await manager.exists()).toBe(false);
+  });
+});

package/test/unit/deploy/providers/cloudflare.test.ts

@@ -0,0 +1,210 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { CloudflareProvider } from '../../../../src/deploy/providers/cloudflare.js';
+import { execAsync } from '../../../../src/deploy/utils.js';
+import { logger } from '@nexical/cli-core';
+
+vi.mock('../../../../src/deploy/utils.js');
+vi.mock('@nexical/cli-core', () => ({
+  logger: {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  },
+}));
+
+describe('CloudflareProvider', () => {
+  let provider: CloudflareProvider;
+  let mockContext: { cwd: string; options: Record<string, unknown>; config: any };
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    provider = new CloudflareProvider();
+    mockContext = {
+      cwd: '/mock',
+      options: {}, // Env undefined by default to test 'production' fallback
+      config: {
+        deploy: {
+          frontend: {
+            projectName: 'my-app',
+            // options intentionally undefined here to test fallback
+          },
+        },
+      },
+    };
+    (execAsync as unknown as { mockResolvedValue: any }).mockResolvedValue({
+      stdout: '',
+      stderr: '',
+    });
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+    delete process.env.CLOUDFLARE_API_TOKEN;
+    delete process.env.CLOUDFLARE_ACCOUNT_ID;
+    delete process.env.CUSTOM_CF_TOKEN;
+    delete process.env.CUSTOM_CF_ACC;
+  });
+
+  describe('provision', () => {
+    it('should error if project name is missing', async () => {
+      mockContext.config.deploy.frontend.projectName = undefined;
+      await expect(provider.provision(mockContext)).rejects.toThrow(
+        'Cloudflare project name not found',
+      );
+    });
+
+    it('should handle dry run', async () => {
+      mockContext.options.dryRun = true;
+      await provider.provision(mockContext);
+      expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('[Dry Run]'));
+      expect(execAsync).not.toHaveBeenCalled();
+    });
+
+    it('should skip if credentials missing', async () => {
+      // No env vars set
+      await provider.provision(mockContext);
+      expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('credentials missing'));
+      expect(execAsync).not.toHaveBeenCalled();
+    });
+
+    it('should provision successfully using default env vars', async () => {
+      process.env.CLOUDFLARE_API_TOKEN = 'tok';
+      process.env.CLOUDFLARE_ACCOUNT_ID = 'acc';
+
+      await provider.provision(mockContext);
+
+      expect(execAsync).toHaveBeenCalledWith(
+        expect.stringContaining('wrangler pages project create my-app --production-branch main'),
+        expect.anything(),
+      );
+    });
+
+    it('should swallow "project already exists" error', async () => {
+      process.env.CLOUDFLARE_API_TOKEN = 'tok';
+      process.env.CLOUDFLARE_ACCOUNT_ID = 'acc';
+      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
+        new Error('Already exists'),
+      );
+
+      await provider.provision(mockContext);
+
+      expect(logger.info).toHaveBeenCalledWith(
+        expect.stringContaining('Cloudflare project might already exist'),
+      );
+    });
+
+    it('should rethrow critical provisioning errors', async () => {
+      process.env.CLOUDFLARE_API_TOKEN = 'tok';
+      process.env.CLOUDFLARE_ACCOUNT_ID = 'acc';
+
+      (logger.info as unknown as { mockImplementationOnce: any }).mockImplementationOnce(() => {}); // Config...
+      (logger.info as unknown as { mockImplementationOnce: any }).mockImplementationOnce(() => {
+        throw new Error('Critical');
+      }); // Ensuring...
+
+      await expect(provider.provision(mockContext)).rejects.toThrow('Critical');
+      expect(logger.warn).toHaveBeenCalledWith('Cloudflare setup failed.');
+    });
+
+    it('should handle non-production environment', async () => {
+      mockContext.options.env = 'staging';
+      mockContext.config.deploy.frontend.options = {}; // Ensure options exist
+      process.env.CLOUDFLARE_API_TOKEN = 'tok';
+      process.env.CLOUDFLARE_ACCOUNT_ID = 'acc';
+
+      await provider.provision(mockContext);
+
+      expect(execAsync).toHaveBeenCalledWith(
+        expect.stringContaining('wrangler pages project create my-app-staging'),
+        expect.anything(),
+      );
+    });
+
+    it('should use configured env vars for credentials', async () => {
+      mockContext.config.deploy.frontend.options = {
+        apiTokenEnvVar: 'CUSTOM_CF_TOKEN',
+        accountIdEnvVar: 'CUSTOM_CF_ACC',
+      };
+      process.env.CUSTOM_CF_TOKEN = 'custom-tok';
+      process.env.CUSTOM_CF_ACC = 'custom-acc';
+
+      await provider.provision(mockContext);
+
+      expect(execAsync).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.objectContaining({
+          env: expect.objectContaining({
+            CLOUDFLARE_API_TOKEN: 'custom-tok',
+            CLOUDFLARE_ACCOUNT_ID: 'custom-acc',
+          }),
+        }),
+      );
+    });
+  });
+
+  describe('getSecrets', () => {
+    it('should resolve secrets from default env vars', async () => {
+      process.env.CLOUDFLARE_API_TOKEN = 'tok';
+      process.env.CLOUDFLARE_ACCOUNT_ID = 'acc';
+      // options undefined by default in beforeEach
+      const secrets = await provider.getSecrets(mockContext);
+      expect(secrets['CLOUDFLARE_API_TOKEN']).toBe('tok');
+      expect(secrets['CLOUDFLARE_ACCOUNT_ID']).toBe('acc');
+    });
+
+    it('should resolve secrets from configured env vars', async () => {
+      mockContext.config.deploy.frontend.options = {
+        apiTokenEnvVar: 'CUSTOM_CF_TOKEN',
+        accountIdEnvVar: 'CUSTOM_CF_ACC',
+      };
+      process.env.CUSTOM_CF_TOKEN = 'custom-tok';
+      process.env.CUSTOM_CF_ACC = 'custom-acc';
+
+      const secrets = await provider.getSecrets(mockContext);
+      expect(secrets['CLOUDFLARE_API_TOKEN']).toBe('custom-tok');
+      expect(secrets['CLOUDFLARE_ACCOUNT_ID']).toBe('custom-acc');
+    });
+
+    it('should error if API Token missing', async () => {
+      // No env vars
+      await expect(provider.getSecrets(mockContext)).rejects.toThrow(
+        'Cloudflare API Token not found',
+      );
+    });
+
+    it('should error if Account ID missing', async () => {
+      process.env.CLOUDFLARE_API_TOKEN = 'tok';
+      // No account ID
+      await expect(provider.getSecrets(mockContext)).rejects.toThrow(
+        'Cloudflare Account ID not found',
+      );
+    });
+  });
+
+  describe('getVariables', () => {
+    it('should return project name for production', async () => {
+      const vars = await provider.getVariables(mockContext);
+      expect(vars['CLOUDFLARE_PROJECT_NAME']).toBe('my-app');
+    });
+
+    it('should return project name for staging', async () => {
+      mockContext.options.env = 'staging';
+      const vars = await provider.getVariables(mockContext);
+      expect(vars['CLOUDFLARE_PROJECT_NAME']).toBe('my-app-staging');
+    });
+
+    it('should error if project name missing', async () => {
+      mockContext.config.deploy.frontend.projectName = undefined;
+      await expect(provider.getVariables(mockContext)).rejects.toThrow(
+        'Cloudflare project name not found',
+      );
+    });
+  });
+
+  describe('getCIConfig', () => {
+    it('should return config', () => {
+      const config = provider.getCIConfig();
+      expect(config.githubActionStep?.uses).toBe('cloudflare/wrangler-action@v3');
+    });
+  });
+});

package/test/unit/deploy/providers/github.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { GitHubProvider } from '../../../../src/deploy/providers/github.js';
+import { execAsync } from '../../../../src/deploy/utils.js';
+import { logger } from '@nexical/cli-core';
+import fs from 'node:fs/promises';
+
+vi.mock('node:fs/promises');
+vi.mock('../../../../src/deploy/utils.js');
+vi.mock('@nexical/cli-core', () => ({
+  logger: {
+    info: vi.fn(),
+  },
+}));
+
+describe('GitHubProvider', () => {
+  let provider: GitHubProvider;
+  let mockContext: any;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    provider = new GitHubProvider();
+    mockContext = {
+      cwd: '/mock',
+      options: {},
+      config: { deploy: { backend: {}, frontend: {} } },
+    } as unknown as any;
+    (execAsync as unknown as { mockResolvedValue: (val: unknown) => void }).mockResolvedValue({
+      stdout: '',
+      stderr: '',
+    });
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('configureSecrets', () => {
+    it('should set secrets', async () => {
+      await provider.configureSecrets(mockContext, { KEY: 'VALUE' });
+      expect(execAsync).toHaveBeenCalledWith(expect.stringContaining('gh secret set KEY'));
+    });
+
+    it('should skip empty secrets', async () => {
+      await provider.configureSecrets(mockContext, { KEY: '' });
+      expect(execAsync).not.toHaveBeenCalled();
+    });
+
+    it('should handle dry run', async () => {
+      mockContext.options.dryRun = true;
+      await provider.configureSecrets(mockContext, { KEY: 'VALUE' });
+      expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('[Dry Run]'));
+      expect(execAsync).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('configureVariables', () => {
+    it('should set variables', async () => {
+      await provider.configureVariables(mockContext, { KEY: 'VALUE' });
+      expect(execAsync).toHaveBeenCalledWith(expect.stringContaining('gh variable set KEY'));
+    });
+
+    it('should skip empty variables', async () => {
+      await provider.configureVariables(mockContext, { KEY: '' });
+      expect(execAsync).not.toHaveBeenCalled();
+    });
+
+    it('should handle dry run', async () => {
+      mockContext.options.dryRun = true;
+      await provider.configureVariables(mockContext, { KEY: 'VALUE' });
+      expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('[Dry Run]'));
+      expect(execAsync).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('generateWorkflow', () => {
+    it('should generate workflow file', async () => {
+      const targets = [
+        {
+          type: 'frontend',
+          name: 'cf',
+          getCIConfig: () => ({
+            installSteps: ['run install'],
+            deploySteps: ['run deploy'],
+            secrets: ['SEC'],
+            githubActionStep: { name: 'Action' },
+          }),
+        },
+        {
+          type: 'backend',
+          name: 'rw',
+          getCIConfig: () => ({
+            deploySteps: ['run backend'],
+          }),
+        },
+      ] as unknown as any;
+
+      await provider.generateWorkflow(mockContext, targets);
+
+      expect(fs.mkdir).toHaveBeenCalled();
+      expect(fs.writeFile).toHaveBeenCalledTimes(2);
+    });
+
+    it('should skip if no config', async () => {
+      const targets = [
+        {
+          type: 'frontend',
+          getCIConfig: () => null,
+        },
+      ] as unknown as any;
+      await provider.generateWorkflow(mockContext, targets);
+      expect(fs.writeFile).not.toHaveBeenCalled();
+    });
+
+    it('should handle no targets', async () => {
+      await provider.generateWorkflow(mockContext, []);
+      expect(fs.writeFile).not.toHaveBeenCalled();
+    });
+
+    it('should handle target with no deploy steps', async () => {
+      const targets = [
+        {
+          type: 'backend',
+          name: 'test',
+          getCIConfig: () => ({
+            // explicit undefined deploySteps
+            deploySteps: undefined,
+            secrets: [],
+          }),
+        },
+      ] as unknown as any;
+
+      await provider.generateWorkflow(mockContext, targets);
+      expect(fs.writeFile).toHaveBeenCalled();
+      // Verify content doesn't crash
+      const content = (fs.writeFile as unknown as { mock: { calls: any[][] } }).mock.calls[0][1];
+      expect(content).toContain('Deploy Backend to test');
+    });
+  });
+});