@nexical/cli 0.11.4 → 0.11.5

package/dist/src/deploy/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexical/cli",
-  "version": "0.11.4",
+  "version": "0.11.5",
   "type": "module",
   "bin": {
     "nexical": "./dist/index.js"
@@ -29,30 +29,32 @@
   },
   "dependencies": {
     "@nexical/cli-core": "^0.1.12",
-    "yaml": "^2.3.4",
-    "fast-glob": "^3.3.3"
+    "dotenv": "^17.3.1",
+    "fast-glob": "^3.3.3",
+    "jiti": "^2.6.1",
+    "yaml": "^2.3.4"
   },
   "devDependencies": {
+    "@eslint/js": "^9.39.2",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^20.10.0",
     "@vitest/coverage-v8": "^4.0.15",
-    "execa": "^9.6.1",
-    "fs-extra": "^11.3.2",
-    "tsup": "^8.0.1",
-    "tsx": "^4.21.0",
-    "typescript": "^5.3.3",
-    "vitest": "^4.0.15",
-    "@eslint/js": "^9.39.2",
     "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-astro": "^1.5.0",
     "eslint-plugin-jsx-a11y": "^6.10.2",
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-react-hooks": "^7.0.1",
+    "execa": "^9.6.1",
+    "fs-extra": "^11.3.2",
     "globals": "^17.2.0",
     "husky": "^9.1.7",
     "lint-staged": "^16.2.7",
     "prettier": "^3.8.1",
-    "typescript-eslint": "^8.54.0"
+    "tsup": "^8.0.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.3.3",
+    "typescript-eslint": "^8.54.0",
+    "vitest": "^4.0.15"
   }
 }

package/src/commands/deploy.ts

@@ -1,238 +1,170 @@
-import { BaseCommand } from '@nexical/cli-core';
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
 import path from 'node:path';
+import dotenv from 'dotenv';
+import { BaseCommand } from '@nexical/cli-core';
+import { ConfigManager } from '../deploy/config-manager';
+import { ProviderRegistry } from '../deploy/registry';
+import { DeploymentContext } from '../deploy/types';
+
+export default class DeployCommand extends BaseCommand {
+  static description = `Deploy the application based on nexical.yaml configuration.
 
-const execAsync = promisify(exec);
+This command orchestrates the deployment of your frontend and backend applications 
+by interacting with the providers specified in your configuration file.
 
-interface DeployOptions {
-  dryRun: boolean;
-  railwayToken?: string;
-  railwayName?: string;
-  backendName: string;
-  frontendName: string;
-  cloudflareToken?: string;
-  cloudflareAccount?: string;
-}
+CONFIGURATION:
+- Requires a 'nexical.yaml' file in the project root.
+- If the file or specific sections are missing, the CLI will prompt you to run an interactive setup 
+  and save the configuration for future uses.
+- Supports loading environment variables from a .env file in the project root.
 
-export default class DeployCommand extends BaseCommand {
-  static description = `Deploy the application to Railway and Cloudflare.
-
-ENVIRONMENT SETUP & PREREQUISITES:
-1. Install Required CLIs:
-   - Railway CLI: npm i -g @railway/cli
-   - Wrangler (Cloudflare): npm i -g wrangler
-   - GitHub CLI: https://cli.github.com/
-
-2. Authentication:
-   - Railway: Run 'railway login'
-   - GitHub: Run 'gh auth login'
-   - Cloudflare: Obtain an API Token (with Pages edit permissions) and your Account ID from the dashboard.
-
-3. Configuration:
-   Run this command with --cloudflare-token and --cloudflare-account to automate the full setup.
-   Optional: Use --railway-token if you prefer not to use the interactive login.
-   Optional: Use --railway-name to specify a custom Railway project name.
-   Optional: Use --backend-name to specify the Railway service name (default: nexical-backend).
-   Optional: Use --frontend-name to specify the Cloudflare Pages project name (default: nexical-frontend).
+PROVIDERS:
+- Backend: Railway, etc.
+- Frontend: Cloudflare Pages, etc.
+- Repository: GitHub, GitLab, etc.
 
 PROCESS:
-- Provisions a PostgreSQL database on Railway (if missing).
-- Creates a Cloudflare Pages project for the frontend.
-- Syncs all necessary deployment secrets and variables to GitHub for CI/CD automation.`;
+1. Loads environment variables from '.env'.
+2. Loads configuration from 'nexical.yaml'.
+3. Provisions resources via the selected providers.
+4. Configures the repository (secrets/variables) for CI/CD.
+5. Generates CI/CD workflow files.`;
 
   static args = {
     options: [
       {
-        name: '--dry-run',
-        description: 'Simulate the deployment process without making changes.',
-        default: false,
-      },
-      {
-        name: '--railway-token <token>',
-        description: 'Railway Project Token (optional if already logged in).',
-      },
-      {
-        name: '--railway-name <name>',
-        description: 'Railway Project Name (used during initialization).',
+        name: '--backend <provider>',
+        description: 'Override backend provider',
       },
       {
-        name: '--backend-name <name>',
-        description: 'Backend service name on Railway.',
-        default: 'nexical-backend',
+        name: '--frontend <provider>',
+        description: 'Override frontend provider',
       },
       {
-        name: '--frontend-name <name>',
-        description: 'Frontend project name on Cloudflare.',
-        default: 'nexical-frontend',
+        name: '--repo <provider>',
+        description: 'Override repositroy provider',
       },
       {
-        name: '--cloudflare-token <token>',
-        description: 'Cloudflare API Token.',
-      },
-      {
-        name: '--cloudflare-account <id>',
-        description: 'Cloudflare Account ID.',
+        name: '--dry-run',
+        description: 'Simulate the deployment process',
+        default: false,
       },
     ],
   };
 
-  async run(options: DeployOptions) {
-    this.info('Starting Nexical Deployment Automation...');
+  async run(options: Record<string, unknown>) {
+    this.info('Starting Nexical Deployment...');
 
-    if (options.dryRun) {
-      this.notice('DRY RUN MODE ENABLED');
-    }
+    // Load environment variables from .env
+    dotenv.config({ path: path.join(process.cwd(), '.env') });
 
-    try {
-      // 1. Railway Setup
-      await this.setupRailway(options);
-
-      // 2. Cloudflare Setup
-      await this.setupCloudflare(options);
-
-      // 3. GitHub Configuration (Secrets & Variables)
-      await this.setupGitHubConfig(options);
-
-      this.success('Deployment setup complete! Your application is being deployed.');
-    } catch (error: unknown) {
-      if (error instanceof Error) {
-        this.error(`Deployment failed: ${error.message}`);
-      } else {
-        this.error(`Deployment failed: ${String(error)}`);
-      }
-      process.exit(1);
-    }
-  }
+    const configManager = new ConfigManager(process.cwd());
+    const config = await configManager.load();
+    const registry = new ProviderRegistry();
 
-  private async setupRailway(options: DeployOptions) {
-    this.info('Configuring Railway...');
+    // Register core and local providers
+    await registry.loadCoreProviders();
+    await registry.loadLocalProviders(process.cwd());
 
-    if (options.dryRun) {
-      const initCmd = options.railwayName
-        ? `railway init --name ${options.railwayName}`
-        : 'railway init';
-      this.info(`[Dry Run] Would run: ${initCmd}`);
-      this.info('[Dry Run] Would run: railway add --database postgres');
-      return;
+    // Resolve providers (CLI flags > Config > Error)
+    const backendProviderName =
+      (options.backend as string | undefined) || config.deploy?.backend?.provider;
+    if (!backendProviderName) {
+      this.error(
+        "Backend provider not specified. Use --backend flag or configure 'deploy.backend.provider' in nexical.yaml.",
+      );
     }
 
-    try {
-      // Check if railway project exists or init
-      // Note: railway init might be interactive, so we might need to handle that or assume user has linked.
-      // For now, let's assume we use 'railway link' if they passed a token or have it set.
-
-      this.info('Ensuring Railway project is linked...');
-      // Note: We intentionally DO NOT set process.env.RAILWAY_TOKEN here.
-      // Management commands (init, status, add) require an interactive session (railway login).
-      // The provided --railway-token is reserved for GitHub Secrets setup (CI/CD).
-
-      const backendDir = path.join(process.cwd(), 'apps/backend');
-
-      try {
-        await execAsync('railway status', { cwd: backendDir });
-      } catch {
-        const initCmd = options.railwayName
-          ? `railway init --name ${options.railwayName}`
-          : 'railway init';
-        this.info(`No Railway project detected in apps/backend. Initializing with: ${initCmd}`);
-        await execAsync(initCmd, { cwd: backendDir });
-      }
-
-      this.info(`Adding PostgreSQL service if missing for "${options.backendName}"...`);
-      const { stdout: status } = await execAsync('railway status', { cwd: backendDir });
-      if (!status.includes('postgres')) {
-        await execAsync('railway add --database postgres', { cwd: backendDir });
-      }
-    } catch (e: unknown) {
-      this.warn(
-        'Railway setup encountered an issue. Ensure you are logged in with `railway login`.',
+    const frontendProviderName =
+      (options.frontend as string | undefined) || config.deploy?.frontend?.provider;
+    if (!frontendProviderName) {
+      this.error(
+        "Frontend provider not specified. Use --frontend flag or configure 'deploy.frontend.provider' in nexical.yaml.",
       );
-      throw e;
     }
-  }
-
-  private async setupCloudflare(options: DeployOptions) {
-    this.info('Configuring Cloudflare Pages...');
 
-    if (options.dryRun) {
-      this.info(`[Dry Run] Would run: wrangler pages project create ${options.frontendName}`);
-      return;
+    const repoProviderName =
+      (options.repo as string | undefined) || config.deploy?.repository?.provider;
+    if (!repoProviderName) {
+      this.error(
+        "Repository provider not specified. Use --repo flag or configure 'deploy.repository.provider' in nexical.yaml.",
+      );
     }
 
-    if (!options.cloudflareToken || !options.cloudflareAccount) {
-      this.warn('Cloudflare credentials missing. Skipping automated Cloudflare setup.');
-      this.info('You can manually set up Cloudflare Pages and add the secrets to GitHub.');
-      return;
+    const backendProvider = registry.getDeploymentProvider(backendProviderName!);
+    const frontendProvider = registry.getDeploymentProvider(frontendProviderName!);
+    const repoProvider = registry.getRepositoryProvider(repoProviderName!);
+
+    if (!backendProvider) throw new Error(`Backend provider '${backendProviderName}' not found.`);
+    if (!frontendProvider)
+      throw new Error(`Frontend provider '${frontendProviderName}' not found.`);
+    if (!repoProvider) throw new Error(`Repository provider '${repoProviderName}' not found.`);
+
+    const context: DeploymentContext = {
+      cwd: process.cwd(),
+      config,
+      options,
+    };
+
+    // Provision
+    this.info(`Provisioning Backend with ${backendProvider.name}...`);
+    await backendProvider.provision(context);
+
+    this.info(`Provisioning Frontend with ${frontendProvider.name}...`);
+    await frontendProvider.provision(context);
+
+    // Configure Repo
+    this.info(`Configuring Repository with ${repoProvider.name}...`);
+
+    const secrets: Record<string, string> = {};
+
+    // Collect secrets from Backend Provider
+    this.info(`Resolving secrets from ${backendProvider.name}...`);
+    try {
+      const backendSecrets = await backendProvider.getSecrets(context);
+      Object.assign(secrets, backendSecrets);
+    } catch (e: unknown) {
+      const message = e instanceof Error ? e.message : String(e);
+      this.error(`Failed to resolve secrets for ${backendProvider.name}: ${message}`);
     }
 
+    // Collect secrets from Frontend Provider
+    this.info(`Resolving secrets from ${frontendProvider.name}...`);
     try {
-      // Use wrangler to create project if it doesn't exist
-      const projectName = options.frontendName;
-      this.info(`Ensuring Cloudflare Pages project "${projectName}" exists...`);
-
-      try {
-        await execAsync(`wrangler pages project create ${projectName} --production-branch main`, {
-          env: {
-            ...process.env,
-            CLOUDFLARE_API_TOKEN: options.cloudflareToken,
-            CLOUDFLARE_ACCOUNT_ID: options.cloudflareAccount,
-          },
-        });
-      } catch {
-        this.info('Cloudflare project might already exist.');
-      }
+      const frontendSecrets = await frontendProvider.getSecrets(context);
+      Object.assign(secrets, frontendSecrets);
     } catch (e: unknown) {
-      this.warn('Cloudflare setup failed.');
-      throw e;
+      const message = e instanceof Error ? e.message : String(e);
+      this.error(`Failed to resolve secrets for ${frontendProvider.name}: ${message}`);
     }
-  }
 
-  private async setupGitHubConfig(options: DeployOptions) {
-    this.info('Configuring GitHub Secrets and Variables...');
+    await repoProvider.configureSecrets(context, secrets);
 
-    if (options.dryRun) {
-      this.info('[Dry Run] Would run: gh secret set RAILWAY_TOKEN');
-      this.info('[Dry Run] Would run: gh secret set CLOUDFLARE_API_TOKEN');
-      this.info('[Dry Run] Would run: gh secret set CLOUDFLARE_ACCOUNT_ID');
-      this.info(
-        `[Dry Run] Would run: gh variable set RAILWAY_SERVICE_NAME --body "${options.backendName}"`,
-      );
-      this.info(
-        `[Dry Run] Would run: gh variable set CLOUDFLARE_PROJECT_NAME --body "${options.frontendName}"`,
-      );
-      return;
+    const variables: Record<string, string> = {};
+
+    // Collect variables from Backend Provider
+    try {
+      const backendVars = await backendProvider.getVariables(context);
+      Object.assign(variables, backendVars);
+    } catch (e: unknown) {
+      const message = e instanceof Error ? e.message : String(e);
+      this.error(`Failed to resolve variables for ${backendProvider.name}: ${message}`);
     }
 
+    // Collect variables from Frontend Provider
     try {
-      if (options.railwayToken) {
-        this.info('Setting RAILWAY_TOKEN in GitHub...');
-        await execAsync(`gh secret set RAILWAY_TOKEN --body "${options.railwayToken}"`);
-      }
-
-      if (options.cloudflareToken) {
-        this.info('Setting CLOUDFLARE_API_TOKEN in GitHub...');
-        await execAsync(`gh secret set CLOUDFLARE_API_TOKEN --body "${options.cloudflareToken}"`);
-      }
-
-      if (options.cloudflareAccount) {
-        this.info('Setting CLOUDFLARE_ACCOUNT_ID in GitHub...');
-        await execAsync(
-          `gh secret set CLOUDFLARE_ACCOUNT_ID --body "${options.cloudflareAccount}"`,
-        );
-      }
-
-      // Set variables
-      this.info(`Setting RAILWAY_SERVICE_NAME to "${options.backendName}" in GitHub...`);
-      await execAsync(`gh variable set RAILWAY_SERVICE_NAME --body "${options.backendName}"`);
-
-      this.info(`Setting CLOUDFLARE_PROJECT_NAME to "${options.frontendName}" in GitHub...`);
-      await execAsync(`gh variable set CLOUDFLARE_PROJECT_NAME --body "${options.frontendName}"`);
+      const frontendVars = await frontendProvider.getVariables(context);
+      Object.assign(variables, frontendVars);
     } catch (e: unknown) {
-      this.warn(
-        'GitHub configuration failed. Ensure you have the GitHub CLI (gh) installed and are logged in.',
-      );
-      throw e;
+      const message = e instanceof Error ? e.message : String(e);
+      this.error(`Failed to resolve variables for ${frontendProvider.name}: ${message}`);
     }
+
+    await repoProvider.configureVariables(context, variables);
+
+    // Generate Workflows
+    this.info('Generating CI/CD Workflows...');
+    await repoProvider.generateWorkflow(context, [backendProvider, frontendProvider]);
+
+    this.success('Deployment configuration complete!');
   }
 }

package/src/deploy/config-manager.ts

@@ -0,0 +1,41 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import YAML from 'yaml';
+import { NexicalConfig } from './types';
+
+export class ConfigManager {
+  private configPath: string;
+
+  constructor(cwd: string) {
+    this.configPath = path.join(cwd, 'nexical.yaml');
+  }
+
+  async load(): Promise<NexicalConfig> {
+    try {
+      const content = await fs.readFile(this.configPath, 'utf-8');
+      return YAML.parse(content) as NexicalConfig;
+    } catch (error: unknown) {
+      if (
+        error &&
+        typeof error === 'object' &&
+        'code' in error &&
+        (error as { code: unknown }).code === 'ENOENT'
+      ) {
+        return {};
+      }
+      throw error;
+    }
+  }
+
+  async save(config: NexicalConfig): Promise<void> {
+    const content = YAML.stringify(config);
+    await fs.writeFile(this.configPath, content, 'utf-8');
+  }
+
+  exists(): Promise<boolean> {
+    return fs
+      .access(this.configPath)
+      .then(() => true)
+      .catch(() => false);
+  }
+}

package/src/deploy/providers/cloudflare.ts

@@ -0,0 +1,143 @@
+import { logger } from '@nexical/cli-core';
+import { DeploymentProvider, DeploymentContext, CIConfig } from '../types';
+import { execAsync } from '../utils';
+
+export class CloudflareProvider implements DeploymentProvider {
+  name = 'cloudflare';
+  type = 'frontend' as const;
+
+  async provision(context: DeploymentContext): Promise<void> {
+    const projectName = context.config.deploy?.frontend?.projectName;
+
+    if (!projectName) {
+      throw new Error(
+        "Cloudflare project name not found in nexical.yaml. Please configure 'deploy.frontend.projectName'.",
+      );
+    }
+
+    const options = context.config.deploy?.frontend?.options || {};
+
+    // Resolve credentials:
+    // 1. CLI flag (options)
+    // 2. Env var defined in config (options.apiTokenEnvVar)
+    // 3. Default env var (CLOUDFLARE_API_TOKEN)
+    const apiTokenEnvVar =
+      typeof options.apiTokenEnvVar === 'string' ? options.apiTokenEnvVar : undefined;
+    const apiToken =
+      (typeof context.options.cloudflareToken === 'string'
+        ? context.options.cloudflareToken
+        : undefined) ||
+      (apiTokenEnvVar ? process.env[apiTokenEnvVar] : undefined) ||
+      process.env.CLOUDFLARE_API_TOKEN;
+
+    const accountIdEnvVar =
+      typeof options.accountIdEnvVar === 'string' ? options.accountIdEnvVar : undefined;
+    const accountId =
+      (typeof context.options.cloudflareAccount === 'string'
+        ? context.options.cloudflareAccount
+        : undefined) ||
+      (accountIdEnvVar ? process.env[accountIdEnvVar] : undefined) ||
+      process.env.CLOUDFLARE_ACCOUNT_ID;
+
+    logger.info('Configuring Cloudflare Pages...');
+
+    if (context.options.dryRun) {
+      logger.info('[Dry Run] Would check Cloudflare Pages project and create if missing.');
+      return;
+    }
+
+    if (!apiToken || !accountId) {
+      logger.warn('Cloudflare credentials missing. Skipping automated Cloudflare setup.');
+      logger.info('You can manually set up Cloudflare Pages and add the secrets to GitHub.');
+      return;
+    }
+
+    try {
+      logger.info(`Ensuring Cloudflare Pages project "${projectName}" exists...`);
+      try {
+        await execAsync(`wrangler pages project create ${projectName} --production-branch main`, {
+          env: {
+            ...process.env,
+            CLOUDFLARE_API_TOKEN: apiToken,
+            CLOUDFLARE_ACCOUNT_ID: accountId,
+          },
+        });
+      } catch {
+        logger.info('Cloudflare project might already exist.');
+      }
+    } catch (e: unknown) {
+      logger.warn('Cloudflare setup failed.');
+      throw e;
+    }
+  }
+
+  async getSecrets(context: DeploymentContext): Promise<Record<string, string>> {
+    const options = context.config.deploy?.frontend?.options || {};
+    const secrets: Record<string, string> = {};
+
+    // Resolve API Token
+    const apiTokenEnvVar =
+      typeof options.apiTokenEnvVar === 'string' ? options.apiTokenEnvVar : undefined;
+    const apiToken =
+      (apiTokenEnvVar ? process.env[apiTokenEnvVar] : undefined) ||
+      process.env.CLOUDFLARE_API_TOKEN;
+
+    if (!apiToken) {
+      throw new Error(
+        `Cloudflare API Token not found. Please provide it via:\n` +
+          `1. Configuring 'deploy.frontend.options.apiTokenEnvVar' in nexical.yaml and setting that env var in .env\n` +
+          `2. Setting CLOUDFLARE_API_TOKEN in .env`,
+      );
+    }
+    secrets['CLOUDFLARE_API_TOKEN'] = apiToken;
+
+    // Resolve Account ID
+    const accountIdEnvVar =
+      typeof options.accountIdEnvVar === 'string' ? options.accountIdEnvVar : undefined;
+    const accountId =
+      (accountIdEnvVar ? process.env[accountIdEnvVar] : undefined) ||
+      process.env.CLOUDFLARE_ACCOUNT_ID;
+
+    if (!accountId) {
+      throw new Error(
+        `Cloudflare Account ID not found. Please provide it via:\n` +
+          `1. Configuring 'deploy.frontend.options.accountIdEnvVar' in nexical.yaml and setting that env var in .env\n` +
+          `2. Setting CLOUDFLARE_ACCOUNT_ID in .env`,
+      );
+    }
+    secrets['CLOUDFLARE_ACCOUNT_ID'] = accountId;
+
+    return secrets;
+  }
+
+  async getVariables(context: DeploymentContext): Promise<Record<string, string>> {
+    const projectName = context.config.deploy?.frontend?.projectName;
+
+    if (!projectName) {
+      throw new Error(
+        "Cloudflare project name not found in nexical.yaml. Please configure 'deploy.frontend.projectName'.",
+      );
+    }
+    return {
+      CLOUDFLARE_PROJECT_NAME: projectName,
+    };
+  }
+
+  getCIConfig(): CIConfig {
+    return {
+      secrets: ['CLOUDFLARE_API_TOKEN', 'CLOUDFLARE_ACCOUNT_ID'],
+      variables: ['CLOUDFLARE_PROJECT_NAME'],
+      deploySteps: [], // Handled by action
+      githubActionStep: {
+        name: 'Deploy to Cloudflare Pages',
+        uses: 'cloudflare/wrangler-action@v3',
+        with: {
+          apiToken: '${{ secrets.CLOUDFLARE_API_TOKEN }}',
+          accountId: '${{ secrets.CLOUDFLARE_ACCOUNT_ID }}',
+          command: 'pages deploy dist --project-name=${{ vars.CLOUDFLARE_PROJECT_NAME }}',
+          workingDirectory: 'apps/frontend',
+        },
+      },
+    };
+  }
+}