@nexical/cli 0.11.23 → 0.12.1

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

@@ -1,7 +1,8 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach, type Mock } from 'vitest';
 import { CloudflareProvider } from '../../../../src/deploy/providers/cloudflare.js';
 import { execAsync } from '../../../../src/deploy/utils.js';
 import { logger } from '@nexical/cli-core';
+import { DeploymentContext, AppConfig } from '../../../../src/deploy/types.js';
 
 vi.mock('../../../../src/deploy/utils.js');
 vi.mock('@nexical/cli-core', () => ({
@@ -9,29 +10,32 @@ vi.mock('@nexical/cli-core', () => ({
     info: vi.fn(),
     warn: vi.fn(),
     error: vi.fn(),
+    success: vi.fn(),
   },
 }));
 
 describe('CloudflareProvider', () => {
   let provider: CloudflareProvider;
-  let mockContext: { cwd: string; options: Record<string, unknown>; config: any };
+  let mockContext: DeploymentContext;
 
   beforeEach(() => {
     vi.resetAllMocks();
     provider = new CloudflareProvider();
     mockContext = {
       cwd: '/mock',
-      options: {}, // Env undefined by default to test 'production' fallback
+      options: {},
       config: {
         deploy: {
-          frontend: {
-            projectName: 'my-app',
-            // options intentionally undefined here to test fallback
+          apps: {
+            frontend: {
+              provider: 'cloudflare',
+              projectName: 'my-app',
+            },
           },
         },
-      },
+      } as any,
     };
-    (execAsync as unknown as { mockResolvedValue: any }).mockResolvedValue({
+    (execAsync as Mock).mockResolvedValue({
       stdout: '',
       stderr: '',
     });
@@ -41,28 +45,27 @@ describe('CloudflareProvider', () => {
     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(
+      const app = { name: 'frontend', provider: 'cloudflare' } as AppConfig;
+      await expect(provider.provision(mockContext, app)).rejects.toThrow(
         'Cloudflare project name not found',
       );
     });
 
     it('should handle dry run', async () => {
       mockContext.options.dryRun = true;
-      await provider.provision(mockContext);
+      const app = { name: 'frontend', provider: 'cloudflare', projectName: 'my-app' } as AppConfig;
+      await provider.provision(mockContext, app);
       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);
+      const app = { name: 'frontend', provider: 'cloudflare', projectName: 'my-app' } as AppConfig;
+      await provider.provision(mockContext, app);
       expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('credentials missing'));
       expect(execAsync).not.toHaveBeenCalled();
     });
@@ -70,8 +73,9 @@ describe('CloudflareProvider', () => {
     it('should provision successfully using default env vars', async () => {
       process.env.CLOUDFLARE_API_TOKEN = 'tok';
       process.env.CLOUDFLARE_ACCOUNT_ID = 'acc';
+      const app = { name: 'frontend', provider: 'cloudflare', projectName: 'my-app' } as AppConfig;
 
-      await provider.provision(mockContext);
+      await provider.provision(mockContext, app);
 
       expect(execAsync).toHaveBeenCalledWith(
         expect.stringContaining('wrangler pages project create my-app --production-branch main'),
@@ -82,14 +86,15 @@ describe('CloudflareProvider', () => {
     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'),
+      (execAsync as Mock).mockRejectedValueOnce(
+        new Error('A pages project with this name already exists.'),
       );
+      const app = { name: 'frontend', provider: 'cloudflare', projectName: 'my-app' } as AppConfig;
 
-      await provider.provision(mockContext);
+      await provider.provision(mockContext, app);
 
       expect(logger.info).toHaveBeenCalledWith(
-        expect.stringContaining('Cloudflare project might already exist'),
+        expect.stringContaining('Cloudflare project already exists'),
       );
     });
 
@@ -97,114 +102,108 @@ describe('CloudflareProvider', () => {
       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...
+      (execAsync as Mock).mockRejectedValueOnce(new Error('Critical error'));
+      const app = { name: 'frontend', provider: 'cloudflare', projectName: 'my-app' } as AppConfig;
 
-      await expect(provider.provision(mockContext)).rejects.toThrow('Critical');
-      expect(logger.warn).toHaveBeenCalledWith('Cloudflare setup failed.');
+      await expect(provider.provision(mockContext, app)).rejects.toThrow('Critical error');
     });
 
-    it('should handle non-production environment', async () => {
-      mockContext.options.env = 'staging';
-      mockContext.config.deploy.frontend.options = {}; // Ensure options exist
+    it('should link custom domains during provision', async () => {
       process.env.CLOUDFLARE_API_TOKEN = 'tok';
       process.env.CLOUDFLARE_ACCOUNT_ID = 'acc';
 
-      await provider.provision(mockContext);
+      const mockFetch = vi.fn();
+      vi.stubGlobal('fetch', mockFetch);
 
-      expect(execAsync).toHaveBeenCalledWith(
-        expect.stringContaining('wrangler pages project create my-app-staging'),
-        expect.anything(),
-      );
-    });
+      // First call (GET) - return one existing domain
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          success: true,
+          result: [{ domain: 'already-linked.com' }],
+        }),
+      });
+
+      // Second call (POST) - link new-domain.com
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          success: true,
+          result: { name: 'new-domain.com' },
+        }),
+      });
 
-    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';
+      const app = {
+        name: 'frontend',
+        provider: 'cloudflare',
+        projectName: 'my-app',
+        domain: ['already-linked.com', 'new-domain.com'],
+      } as AppConfig;
 
-      await provider.provision(mockContext);
+      await provider.provision(mockContext, app);
 
-      expect(execAsync).toHaveBeenCalledWith(
+      expect(mockFetch).toHaveBeenCalledTimes(2);
+      expect(mockFetch).toHaveBeenNthCalledWith(
+        1,
+        expect.stringContaining('/pages/projects/my-app/domains'),
         expect.anything(),
+      );
+      expect(mockFetch).toHaveBeenNthCalledWith(
+        2,
+        expect.stringContaining('/pages/projects/my-app/domains'),
         expect.objectContaining({
-          env: expect.objectContaining({
-            CLOUDFLARE_API_TOKEN: 'custom-tok',
-            CLOUDFLARE_ACCOUNT_ID: 'custom-acc',
-          }),
+          method: 'POST',
+          body: JSON.stringify({ name: 'new-domain.com' }),
         }),
       );
+      expect(logger.success).toHaveBeenCalledWith(
+        expect.stringContaining('Linked domain new-domain.com'),
+      );
+
+      vi.unstubAllGlobals();
     });
   });
 
   describe('getSecrets', () => {
-    it('should resolve secrets from default env vars', async () => {
+    it('should return default secrets', 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);
+      const app = { name: 'frontend', provider: 'cloudflare', projectName: 'my-app' } as AppConfig;
+
+      const secrets = await provider.getSecrets(mockContext, app);
       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 variable', async () => {
+      const app = { name: 'frontend', provider: 'cloudflare', projectName: 'my-app' } as AppConfig;
+      const vars = await provider.getVariables(mockContext, app);
+      expect(vars['CLOUDFLARE_PROJECT_NAME_FRONTEND']).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');
-    });
+  describe('deploy', () => {
+    it('should run wrangler deploy', async () => {
+      process.env.CLOUDFLARE_API_TOKEN = 'tok';
+      process.env.CLOUDFLARE_ACCOUNT_ID = 'acc';
+      const app = { name: 'frontend', provider: 'cloudflare', projectName: 'my-app' } as AppConfig;
 
-    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',
+      await provider.deploy(mockContext, app);
+
+      expect(execAsync).toHaveBeenCalledWith(
+        expect.stringContaining('wrangler pages deploy dist --project-name=my-app'),
+        expect.anything(),
       );
     });
-  });
 
-  describe('getCIConfig', () => {
-    it('should return config', () => {
-      const config = provider.getCIConfig();
-      expect(config.githubActionStep?.uses).toBe('cloudflare/wrangler-action@v3');
+    it('should handle dry run', async () => {
+      mockContext.options.dryRun = true;
+      const app = { name: 'frontend', provider: 'cloudflare', projectName: 'my-app' } as AppConfig;
+      await provider.deploy(mockContext, app);
+      expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('[Dry Run]'));
+      expect(execAsync).not.toHaveBeenCalled();
     });
   });
 });

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

@@ -0,0 +1,148 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import CloudflareDnsProvider from '../../../../src/deploy/providers/dns-cloudflare';
+import { DeploymentContext } from '../../../../src/deploy/types';
+
+describe('CloudflareDnsProvider', () => {
+  let provider: CloudflareDnsProvider;
+  let mockContext: DeploymentContext;
+
+  beforeEach(() => {
+    provider = new CloudflareDnsProvider();
+    mockContext = {
+      cwd: '/test/cwd',
+      config: {
+        deploy: {
+          dns: {
+            provider: 'cloudflare',
+            cloudflare: {
+              token: 'test-token',
+              zone: 'test-zone-id',
+            },
+          },
+        },
+      },
+      options: {},
+    };
+
+    // Reset env vars and mocks
+    delete process.env.CLOUDFLARE_API_TOKEN;
+    delete process.env.CLOUDFLARE_ZONE_ID;
+    vi.stubGlobal('fetch', vi.fn());
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('should be named cloudflare and use type dns', () => {
+    expect(provider.name).toBe('cloudflare');
+    expect(provider.type).toBe('dns');
+  });
+
+  it('should throw if api token is missing', async () => {
+    (
+      mockContext.config.deploy!.dns as {
+        cloudflare?: { token?: string };
+      }
+    ).cloudflare!.token = undefined;
+    await expect(
+      provider.provision(mockContext, [{ type: 'A', name: 'ex.com', content: '1.2.3.4' }]),
+    ).rejects.toThrow(/Cloudflare API token not found/);
+  });
+
+  it('should throw if zone id is missing', async () => {
+    (
+      mockContext.config.deploy!.dns as {
+        cloudflare?: { zone?: string };
+      }
+    ).cloudflare!.zone = undefined;
+    await expect(
+      provider.provision(mockContext, [{ type: 'A', name: 'ex.com', content: '1.2.3.4' }]),
+    ).rejects.toThrow(/Cloudflare Zone ID not found/);
+  });
+
+  it('should skip provisioning if no records are provided', async () => {
+    await provider.provision(mockContext, []);
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  it('should create new DNS record if it does not exist', async () => {
+    const mockFetch = vi.mocked(fetch);
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        success: true,
+        result: [], // No existing records
+      }),
+    } as unknown as Response);
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+    } as unknown as Response);
+
+    await provider.provision(mockContext, [{ type: 'A', name: 'test.com', content: '1.2.3.4' }]);
+
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      1,
+      'https://api.cloudflare.com/client/v4/zones/test-zone-id/dns_records',
+      expect.objectContaining({
+        headers: {
+          Authorization: 'Bearer test-token',
+          'Content-Type': 'application/json',
+        },
+      }),
+    );
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      2,
+      'https://api.cloudflare.com/client/v4/zones/test-zone-id/dns_records',
+      expect.objectContaining({
+        method: 'POST',
+        body: JSON.stringify({
+          type: 'A',
+          name: 'test.com',
+          content: '1.2.3.4',
+          proxied: true,
+          ttl: 1,
+        }),
+      }),
+    );
+  });
+
+  it('should update existing DNS record if content differs', async () => {
+    const mockFetch = vi.mocked(fetch);
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        success: true,
+        result: [
+          { id: 'rec-1', type: 'CNAME', name: 'app.com', content: 'old.target.com', proxied: true },
+        ],
+      }),
+    } as unknown as Response);
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+    } as unknown as Response);
+
+    await provider.provision(mockContext, [
+      { type: 'CNAME', name: 'app.com', content: 'new.target.com', proxied: false },
+    ]);
+
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      2,
+      'https://api.cloudflare.com/client/v4/zones/test-zone-id/dns_records/rec-1',
+      expect.objectContaining({
+        method: 'PUT',
+        body: JSON.stringify({
+          type: 'CNAME',
+          name: 'app.com',
+          content: 'new.target.com',
+          proxied: false,
+          ttl: 1,
+        }),
+      }),
+    );
+  });
+});

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

@@ -1,20 +1,23 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach, type Mock } 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';
+import { DeploymentContext } from '../../../../src/deploy/types.js';
 
 vi.mock('node:fs/promises');
 vi.mock('../../../../src/deploy/utils.js');
 vi.mock('@nexical/cli-core', () => ({
   logger: {
     info: vi.fn(),
+    error: vi.fn(),
+    success: vi.fn(),
   },
 }));
 
 describe('GitHubProvider', () => {
   let provider: GitHubProvider;
-  let mockContext: any;
+  let mockContext: DeploymentContext;
 
   beforeEach(() => {
     vi.resetAllMocks();
@@ -22,12 +25,17 @@ describe('GitHubProvider', () => {
     mockContext = {
       cwd: '/mock',
       options: {},
-      config: { deploy: { backend: {}, frontend: {} } },
-    } as unknown as any;
-    (execAsync as unknown as { mockResolvedValue: (val: unknown) => void }).mockResolvedValue({
+      config: { deploy: { repository: { provider: 'github' }, apps: {} } },
+    } as unknown as DeploymentContext;
+    (execAsync as Mock).mockResolvedValue({
       stdout: '',
       stderr: '',
     });
+    (fs.readFile as Mock).mockResolvedValue(
+      'name: ${APP_NAME}\non:\n  push:\n    branches: [main]\njobs:\n  deploy:\n    steps: []',
+    );
+    (fs.mkdir as Mock).mockResolvedValue(undefined);
+    (fs.writeFile as Mock).mockResolvedValue(undefined);
   });
 
   afterEach(() => {
@@ -76,64 +84,52 @@ describe('GitHubProvider', () => {
     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'],
-          }),
+          provider: {
+            name: 'railway',
+            getCIConfig: () => ({
+              installSteps: ['run install'],
+              deploySteps: ['run deploy'],
+              secrets: ['SEC'],
+              githubActionStep: { name: 'Action' },
+            }),
+          },
+          app: { name: 'rw', provider: 'railway' },
         },
       ] as unknown as any;
 
       await provider.generateWorkflow(mockContext, targets);
 
-      expect(fs.mkdir).toHaveBeenCalled();
-      expect(fs.writeFile).toHaveBeenCalledTimes(2);
+      expect(fs.writeFile).toHaveBeenCalled();
+      const content = (fs.writeFile as Mock).mock.calls[0][1];
+      expect(content).toContain('name: Deploy rw to railway');
     });
 
-    it('should skip if no config', async () => {
+    it('should support paths trigger', async () => {
       const targets = [
         {
-          type: 'frontend',
-          getCIConfig: () => null,
+          provider: {
+            name: 'frontend',
+            getCIConfig: () => ({}),
+          },
+          app: {
+            name: 'fe',
+            provider: 'cloudflare',
+            paths: ['apps/frontend/**'],
+          },
         },
       ] as unknown as any;
+
       await provider.generateWorkflow(mockContext, targets);
-      expect(fs.writeFile).not.toHaveBeenCalled();
+
+      expect(fs.writeFile).toHaveBeenCalled();
+      const content = (fs.writeFile as Mock).mock.calls[0][1];
+      expect(content).toContain('paths:');
+      expect(content).toContain('- apps/frontend/**');
     });
 
-    it('should handle no targets', async () => {
+    it('should skip if no targets provided', 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');
-    });
   });
 });