@nexical/cli 0.11.23 → 0.12.1

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

@@ -5,6 +5,10 @@ import path from 'node:path';
 import fs from 'fs-extra';
 import { CLI } from '@nexical/cli-core';
 
+const mocks = vi.hoisted(() => ({
+  dnsProvision: vi.fn().mockResolvedValue(undefined),
+}));
+
 // Mock ConfigManager and Registry to control provider behavior without relying on real files or dynamic imports
 vi.mock('../../../src/deploy/config-manager.js', () => {
   return {
@@ -12,8 +16,11 @@ vi.mock('../../../src/deploy/config-manager.js', () => {
       return {
         load: vi.fn().mockResolvedValue({
           deploy: {
-            backend: { provider: 'railway' },
-            frontend: { provider: 'cloudflare' },
+            apps: {
+              api: { provider: 'railway', domain: 'api.test.com' },
+              web: { provider: 'cloudflare' },
+            },
+            dns: { provider: 'cloudflare' },
             repository: { provider: 'github' },
           },
         }),
@@ -28,13 +35,14 @@ vi.mock('../../../src/deploy/registry.js', () => {
       return {
         loadCoreProviders: vi.fn(),
         loadLocalProviders: vi.fn(),
-        getDeploymentProvider: vi.fn().mockImplementation((name) => {
+        getHostingProvider: 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' }),
+              getDefaultDnsTarget: vi.fn().mockReturnValue('deploy.railway.app'),
             };
           }
           if (name === 'cloudflare') {
@@ -43,6 +51,7 @@ vi.mock('../../../src/deploy/registry.js', () => {
               provision: vi.fn().mockResolvedValue(undefined),
               getSecrets: vi.fn().mockResolvedValue({ C_SEC: 'val' }),
               getVariables: vi.fn().mockResolvedValue({ C_VAR: 'val' }),
+              getDefaultDnsTarget: vi.fn().mockReturnValue('test.pages.dev'),
             };
           }
           return undefined;
@@ -59,6 +68,10 @@ vi.mock('../../../src/deploy/registry.js', () => {
             await fs.writeFile(targetFile, 'yaml content');
           }),
         }),
+        getDnsProvider: vi.fn().mockReturnValue({
+          name: 'cloudflare',
+          provision: mocks.dnsProvision,
+        }),
       };
     }),
   };
@@ -99,4 +112,67 @@ describe('Deploy Command Integration', () => {
       process.chdir(originalCwd);
     }
   });
+
+  it('should filter applications when --apps is specified', async () => {
+    const originalCwd = process.cwd();
+    try {
+      const cli = new CLI({ commandName: 'nexical' });
+      process.chdir(projectDir);
+
+      const deployCmd = new DeployCommand(cli);
+
+      // Execute run with only backend
+      await deployCmd.run({ env: 'production', apps: 'api' });
+
+      // Verification: The mock ProviderRegistry.getDeploymentProvider was only called for 'backend'
+      // and NOT for 'frontend'. In this simpler verification, we just check no error was thrown.
+      const workflowPath = path.join(projectDir, '.github/workflows/deploy.yml');
+      expect(await fs.pathExists(workflowPath)).toBe(true);
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+
+  it('should throw error if specified application does not exist', async () => {
+    const originalCwd = process.cwd();
+    const mockExit = vi.spyOn(process, 'exit').mockImplementation((code) => {
+      throw new Error(`Process exited with code ${code}`);
+    });
+
+    try {
+      const cli = new CLI({ commandName: 'nexical' });
+      process.chdir(projectDir);
+
+      const deployCmd = new DeployCommand(cli);
+
+      // Execute run with non-existent app
+      // We expect the 'process.exit unexpectedly called' error OR our custom error
+      // Depending on how vitest/cli-core interacts.
+      await expect(deployCmd.run({ env: 'production', apps: 'invalid-app' })).rejects.toThrow(
+        /The following applications were not found in nexical.yaml: invalid-app|Process exited with code 1/,
+      );
+    } finally {
+      mockExit.mockRestore();
+      process.chdir(originalCwd);
+    }
+  });
+
+  it('should provision DNS records successfully', async () => {
+    const originalCwd = process.cwd();
+    try {
+      const cli = new CLI({ commandName: 'nexical' });
+      process.chdir(projectDir);
+
+      const deployCmd = new DeployCommand(cli);
+
+      // We expect this to execute our mock DnsProvider since it's in the simulated config
+      await deployCmd.run({ env: 'production' });
+
+      expect(mocks.dnsProvision).toHaveBeenCalledWith(expect.anything(), [
+        { type: 'CNAME', name: 'api.test.com', content: 'deploy.railway.app', proxied: true },
+      ]);
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
 });

package/test/unit/commands/deploy.test.ts

@@ -2,15 +2,16 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import dotenv from 'dotenv';
 import DeployCommand from '../../../src/commands/deploy.js';
 
-// Fully mock the modules to return classes
 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' },
+            apps: {
+              api: { provider: 'railway' },
+              web: { provider: 'vercel' },
+            },
             repository: { provider: 'github' },
           },
         }),
@@ -25,8 +26,9 @@ vi.mock('../../../src/deploy/registry.js', () => {
       return {
         loadCoreProviders: vi.fn(),
         loadLocalProviders: vi.fn(),
-        getDeploymentProvider: vi.fn(),
+        getHostingProvider: vi.fn(),
         getRepositoryProvider: vi.fn(),
+        getDnsProvider: vi.fn(),
       };
     }),
   };
@@ -47,32 +49,33 @@ vi.mock('@nexical/cli-core', async (importOriginal) => {
   };
 });
 
-// Import them after vi.mock to get the mocked versions
 import { ConfigManager } from '../../../src/deploy/config-manager.js';
 import { ProviderRegistry } from '../../../src/deploy/registry.js';
 
 describe('DeployCommand', () => {
   let command: DeployCommand;
   let mockRegistry: {
-    loadCoreProviders: any;
-    loadLocalProviders: any;
-    getDeploymentProvider: any;
-    getRepositoryProvider: any;
+    loadCoreProviders: ReturnType<typeof vi.fn>;
+    loadLocalProviders: ReturnType<typeof vi.fn>;
+    getHostingProvider: ReturnType<typeof vi.fn>;
+    getRepositoryProvider: ReturnType<typeof vi.fn>;
+    getDnsProvider: ReturnType<typeof vi.fn>;
   };
-  let mockConfigManager: { load: any };
+  let mockConfigManager: { load: ReturnType<typeof vi.fn> };
 
   beforeEach(() => {
     vi.clearAllMocks();
 
-    command = new DeployCommand({} as unknown as any, { rootDir: '/mock/root' });
+    command = new DeployCommand({} as never, { rootDir: '/mock/root' } as never);
     (command as unknown as { projectRoot: string }).projectRoot = '/mock/root';
 
-    // Get the instance that will be returned by the constructor
     mockConfigManager = {
       load: vi.fn().mockResolvedValue({
         deploy: {
-          backend: { provider: 'railway' },
-          frontend: { provider: 'cloudflare' },
+          apps: {
+            api: { provider: 'railway' },
+            web: { provider: 'vercel' },
+          },
           repository: { provider: 'github' },
         },
       }),
@@ -84,8 +87,9 @@ describe('DeployCommand', () => {
     mockRegistry = {
       loadCoreProviders: vi.fn(),
       loadLocalProviders: vi.fn(),
-      getDeploymentProvider: vi.fn(),
+      getHostingProvider: vi.fn(),
       getRepositoryProvider: vi.fn(),
+      getDnsProvider: vi.fn(),
     };
     vi.mocked(ProviderRegistry).mockImplementation(function () {
       return mockRegistry;
@@ -96,6 +100,7 @@ describe('DeployCommand', () => {
       throw new Error('CLI ERROR');
     });
     vi.spyOn(command, 'success').mockImplementation(() => {});
+    vi.spyOn(command, 'warn').mockImplementation(() => {});
   });
 
   afterEach(() => {
@@ -103,17 +108,17 @@ describe('DeployCommand', () => {
   });
 
   it('should run a full deployment successfully', async () => {
-    const mockBackend = {
+    const mockApi = {
       name: 'railway',
       provision: vi.fn().mockResolvedValue(undefined),
-      getSecrets: vi.fn().mockResolvedValue({ B_SEC: 'val' }),
-      getVariables: vi.fn().mockResolvedValue({ B_VAR: 'val' }),
+      getSecrets: vi.fn().mockResolvedValue({ API_SEC: 'val' }),
+      getVariables: vi.fn().mockResolvedValue({ API_VAR: 'val' }),
     };
-    const mockFrontend = {
-      name: 'cloudflare',
+    const mockWeb = {
+      name: 'vercel',
       provision: vi.fn().mockResolvedValue(undefined),
-      getSecrets: vi.fn().mockResolvedValue({ F_SEC: 'val' }),
-      getVariables: vi.fn().mockResolvedValue({ F_VAR: 'val' }),
+      getSecrets: vi.fn().mockResolvedValue({ WEB_SEC: 'val' }),
+      getVariables: vi.fn().mockResolvedValue({ WEB_VAR: 'val' }),
     };
     const mockRepo = {
       name: 'github',
@@ -122,9 +127,9 @@ describe('DeployCommand', () => {
       generateWorkflow: vi.fn().mockResolvedValue(undefined),
     };
 
-    mockRegistry.getDeploymentProvider.mockImplementation((name: string) => {
-      if (name === 'railway') return mockBackend;
-      if (name === 'cloudflare') return mockFrontend;
+    mockRegistry.getHostingProvider.mockImplementation((name: string) => {
+      if (name === 'railway') return mockApi;
+      if (name === 'vercel') return mockWeb;
       return undefined;
     });
     mockRegistry.getRepositoryProvider.mockReturnValue(mockRepo);
@@ -132,224 +137,117 @@ describe('DeployCommand', () => {
     await command.run({ env: 'production' });
 
     expect(dotenv.config).toHaveBeenCalled();
-    expect(mockBackend.provision).toHaveBeenCalled();
-    expect(mockFrontend.provision).toHaveBeenCalled();
-    expect(mockRepo.configureSecrets).toHaveBeenCalled();
-    expect(mockRepo.configureVariables).toHaveBeenCalled();
+    expect(mockApi.provision).toHaveBeenCalled();
+    expect(mockWeb.provision).toHaveBeenCalled();
+    expect(mockRepo.configureSecrets).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ API_SEC: 'val', WEB_SEC: 'val' }),
+    );
+    expect(mockRepo.configureVariables).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ API_VAR: 'val', WEB_VAR: 'val' }),
+    );
     expect(mockRepo.generateWorkflow).toHaveBeenCalled();
     expect(command.success).toHaveBeenCalledWith('Deployment configuration complete!');
   });
 
-  it('should error if backend provider is missing', async () => {
-    mockConfigManager.load.mockResolvedValue({ deploy: { frontend: { provider: 'cf' } } });
-    await expect(command.run({})).rejects.toThrow('CLI ERROR');
-  });
-
-  it('should error if frontend provider is missing', async () => {
-    mockConfigManager.load.mockResolvedValue({ deploy: { backend: { provider: 'rw' } } });
-    await expect(command.run({})).rejects.toThrow('CLI ERROR');
-  });
-
-  it('should error if repo provider is missing', async () => {
-    mockConfigManager.load.mockResolvedValue({
-      deploy: { backend: { provider: 'rw' }, frontend: { provider: 'cf' } },
-    });
-    await expect(command.run({})).rejects.toThrow('CLI ERROR');
-  });
-
-  it('should throw if provider is not found in registry', async () => {
-    mockRegistry.getDeploymentProvider.mockReturnValue(undefined);
-    await expect(command.run({ backend: 'unknown' })).rejects.toThrow(
-      "Backend provider 'unknown' not found.",
-    );
-  });
-
-  it('should handle errors during secret resolution', async () => {
-    const mockBackend = {
+  it('should filter apps if --apps is provided', async () => {
+    const mockApi = {
       name: 'railway',
       provision: vi.fn(),
-      getSecrets: vi.fn().mockRejectedValue(new Error('Secret fail')),
+      getSecrets: vi.fn().mockResolvedValue({}),
       getVariables: vi.fn().mockResolvedValue({}),
     };
-    mockRegistry.getDeploymentProvider.mockReturnValue(mockBackend);
+    mockRegistry.getHostingProvider.mockReturnValue(mockApi);
     mockRegistry.getRepositoryProvider.mockReturnValue({
       configureSecrets: vi.fn(),
       configureVariables: vi.fn(),
       generateWorkflow: vi.fn(),
     });
 
-    await expect(command.run({})).rejects.toThrow('CLI ERROR');
+    await command.run({ apps: 'api' });
+    expect(mockApi.provision).toHaveBeenCalledTimes(1);
+    expect(command.success).toHaveBeenCalledWith('Deployment configuration complete!');
   });
 
-  it('should handle non-Error exceptions during secret resolution', async () => {
-    const mockBackend = {
-      name: 'railway',
-      provision: vi.fn(),
-      getSecrets: vi.fn().mockRejectedValue('String error'),
-      getVariables: vi.fn().mockResolvedValue({}),
-    };
-    mockRegistry.getDeploymentProvider.mockReturnValue(mockBackend);
-    mockRegistry.getRepositoryProvider.mockReturnValue({
-      configureSecrets: vi.fn(),
-      configureVariables: vi.fn(),
-      generateWorkflow: vi.fn(),
-    });
-
+  it('should error if no apps found', async () => {
+    mockConfigManager.load.mockResolvedValue({ deploy: {} });
     await expect(command.run({})).rejects.toThrow('CLI ERROR');
+    expect(command.error).toHaveBeenCalledWith(
+      'No applications found in nexical.yaml. Please configure [deploy.apps].',
+    );
   });
 
-  it('should handle errors during variable resolution', async () => {
-    const mockBackend = {
-      name: 'railway',
-      provision: vi.fn(),
-      getSecrets: vi.fn().mockResolvedValue({}),
-      getVariables: vi.fn().mockRejectedValue(new Error('Var fail')),
-    };
-    mockRegistry.getDeploymentProvider.mockReturnValue(mockBackend);
-    mockRegistry.getRepositoryProvider.mockReturnValue({
-      configureSecrets: vi.fn(),
-      configureVariables: vi.fn(),
-      generateWorkflow: vi.fn(),
-    });
-
-    await expect(command.run({})).rejects.toThrow('CLI ERROR');
+  it('should error if requested app is missing', async () => {
+    await expect(command.run({ apps: 'missing' })).rejects.toThrow('CLI ERROR');
+    expect(command.error).toHaveBeenCalledWith(
+      'The following applications were not found in nexical.yaml: missing',
+    );
   });
 
-  it('should handle non-Error exceptions during variable resolution', async () => {
-    const mockBackend = {
-      name: 'railway',
-      provision: vi.fn(),
-      getSecrets: vi.fn().mockResolvedValue({}),
-      getVariables: vi.fn().mockRejectedValue('String var fail'),
-    };
-    mockRegistry.getDeploymentProvider.mockReturnValue(mockBackend);
-    mockRegistry.getRepositoryProvider.mockReturnValue({
-      configureSecrets: vi.fn(),
-      configureVariables: vi.fn(),
-      generateWorkflow: vi.fn(),
+  it('should error if repo provider is missing', async () => {
+    mockConfigManager.load.mockResolvedValue({
+      deploy: { apps: { api: { provider: 'pw' } } },
     });
-
     await expect(command.run({})).rejects.toThrow('CLI ERROR');
+    expect(command.error).toHaveBeenCalledWith(
+      expect.stringContaining('Repository provider not specified'),
+    );
   });
-  it('should handle errors during frontend secret resolution', async () => {
-    const mockBackend = {
-      name: 'railway',
-      provision: vi.fn(),
-      getSecrets: vi.fn().mockResolvedValue({}),
-      getVariables: vi.fn().mockResolvedValue({}),
-    };
-    const mockFrontend = {
-      name: 'cloudflare',
-      provision: vi.fn(),
-      getSecrets: vi.fn().mockRejectedValue(new Error('Front secret fail')),
-      getVariables: vi.fn().mockResolvedValue({}),
-    };
-    mockRegistry.getDeploymentProvider.mockImplementation((name: string) => {
-      if (name === 'railway') return mockBackend;
-      if (name === 'cloudflare') return mockFrontend;
-    });
-    mockRegistry.getRepositoryProvider.mockReturnValue({
-      configureSecrets: vi.fn(),
-      configureVariables: vi.fn(),
-      generateWorkflow: vi.fn(),
-    });
 
+  it('should throw if provider is not found for an app', async () => {
+    mockRegistry.getHostingProvider.mockReturnValue(undefined);
+    mockRegistry.getRepositoryProvider.mockReturnValue({});
     await expect(command.run({})).rejects.toThrow('CLI ERROR');
+    expect(command.error).toHaveBeenCalledWith(
+      "Provider 'railway' not found for application 'api'.",
+    );
   });
 
-  it('should handle non-Error exceptions during frontend secret resolution', async () => {
-    const mockBackend = {
-      name: 'railway',
+  it('should throw if repo provider is not found in registry', async () => {
+    mockRegistry.getHostingProvider.mockReturnValue({
       provision: vi.fn(),
       getSecrets: vi.fn().mockResolvedValue({}),
       getVariables: vi.fn().mockResolvedValue({}),
-    };
-    const mockFrontend = {
-      name: 'cloudflare',
-      provision: vi.fn(),
-      getSecrets: vi.fn().mockRejectedValue('String front secret fail'),
-      getVariables: vi.fn().mockResolvedValue({}),
-    };
-    mockRegistry.getDeploymentProvider.mockImplementation((name: string) => {
-      if (name === 'railway') return mockBackend;
-      if (name === 'cloudflare') return mockFrontend;
     });
-    mockRegistry.getRepositoryProvider.mockReturnValue({
-      configureSecrets: vi.fn(),
-      configureVariables: vi.fn(),
-      generateWorkflow: vi.fn(),
-    });
-
-    await expect(command.run({})).rejects.toThrow('CLI ERROR');
+    mockRegistry.getRepositoryProvider.mockReturnValue(undefined);
+    await expect(command.run({})).rejects.toThrow("Repository provider 'github' not found.");
   });
 
-  it('should handle errors during frontend variable resolution', async () => {
-    const mockBackend = {
-      name: 'railway',
-      provision: vi.fn(),
-      getSecrets: vi.fn().mockResolvedValue({}),
-      getVariables: vi.fn().mockResolvedValue({}),
-    };
-    const mockFrontend = {
-      name: 'cloudflare',
-      provision: vi.fn(),
-      getSecrets: vi.fn().mockResolvedValue({}),
-      getVariables: vi.fn().mockRejectedValue(new Error('Front var fail')),
-    };
-    mockRegistry.getDeploymentProvider.mockImplementation((name: string) => {
-      if (name === 'railway') return mockBackend;
-      if (name === 'cloudflare') return mockFrontend;
-    });
-    mockRegistry.getRepositoryProvider.mockReturnValue({
-      configureSecrets: vi.fn(),
-      configureVariables: vi.fn(),
-      generateWorkflow: vi.fn(),
+  it('should handle DNS provisioning if configured', async () => {
+    mockConfigManager.load.mockResolvedValue({
+      deploy: {
+        apps: {
+          web: { provider: 'vercel', domain: 'example.com' },
+        },
+        repository: { provider: 'github' },
+        dns: { provider: 'cloudflare' },
+      },
     });
 
-    await expect(command.run({})).rejects.toThrow('CLI ERROR');
-  });
-
-  it('should handle non-Error exceptions during frontend variable resolution', async () => {
-    const mockBackend = {
-      name: 'railway',
-      provision: vi.fn(),
+    const mockWeb = {
+      name: 'vercel',
+      provision: vi.fn().mockResolvedValue(undefined),
       getSecrets: vi.fn().mockResolvedValue({}),
       getVariables: vi.fn().mockResolvedValue({}),
+      getDefaultDnsTarget: vi.fn().mockReturnValue('proxy.com'),
     };
-    const mockFrontend = {
-      name: 'cloudflare',
-      provision: vi.fn(),
-      getSecrets: vi.fn().mockResolvedValue({}),
-      getVariables: vi.fn().mockRejectedValue('String front var fail'),
-    };
-    mockRegistry.getDeploymentProvider.mockImplementation((name: string) => {
-      if (name === 'railway') return mockBackend;
-      if (name === 'cloudflare') return mockFrontend;
-    });
+    mockRegistry.getHostingProvider.mockReturnValue(mockWeb);
     mockRegistry.getRepositoryProvider.mockReturnValue({
       configureSecrets: vi.fn(),
       configureVariables: vi.fn(),
       generateWorkflow: vi.fn(),
     });
+    const mockDns = {
+      name: 'cloudflare',
+      provision: vi.fn().mockResolvedValue(undefined),
+    };
+    mockRegistry.getDnsProvider.mockReturnValue(mockDns);
 
-    await expect(command.run({})).rejects.toThrow('CLI ERROR');
-  });
-
-  it('should throw if frontend provider is not found in registry', async () => {
-    mockRegistry.getDeploymentProvider.mockImplementation((name: string) => {
-      if (name === 'railway') return { name: 'railway' };
-      return undefined;
-    });
-    await expect(command.run({ frontend: 'unknown' })).rejects.toThrow(
-      "Frontend provider 'unknown' not found.",
-    );
-  });
+    await command.run({});
 
-  it('should throw if repo provider is not found in registry', async () => {
-    mockRegistry.getDeploymentProvider.mockReturnValue({ name: 'mock' });
-    mockRegistry.getRepositoryProvider.mockReturnValue(undefined);
-    await expect(command.run({ repo: 'unknown' })).rejects.toThrow(
-      "Repository provider 'unknown' not found.",
-    );
+    expect(mockDns.provision).toHaveBeenCalledWith(expect.anything(), [
+      { type: 'CNAME', name: 'example.com', content: 'proxy.com', proxied: true },
+    ]);
   });
 });

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

@@ -16,12 +16,14 @@ describe('ConfigManager', () => {
   it('should load config', async () => {
     const mockConfig: NexicalConfig = {
       deploy: {
-        backend: {
-          provider: 'railway',
+        apps: {
+          backend: { provider: 'railway' },
         },
       },
     };
-    vi.mocked(fs.readFile).mockResolvedValue('deploy:\n  backend:\n    provider: railway');
+    vi.mocked(fs.readFile).mockResolvedValue(
+      'deploy:\n  apps:\n    backend:\n      provider: railway',
+    );
     const config = await manager.load();
     expect(config).toEqual(mockConfig);
   });
@@ -42,8 +44,10 @@ describe('ConfigManager', () => {
   it('should save config', async () => {
     const mockConfig: NexicalConfig = {
       deploy: {
-        frontend: {
-          provider: 'cloudflare',
+        apps: {
+          frontend: {
+            provider: 'cloudflare',
+          },
         },
       },
     };