@akash-chowdhury-24/deployhub 1.0.0

package/src/utils/github-actions.js

@@ -0,0 +1,389 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { PLATFORM_ENV_MAP, PLATFORM_CLI_MAP } from './platform-env.js';
+import { getWorkflowHeaderComment } from './author.js';
+
+/** @typedef {'aws'|'azure'|'gcp'|'gdrive'|'dropbox'|'local'|'ftp'|'ssh'} ProviderEnvKey */
+
+const PROVIDER_ENV_MAP = {
+  aws: [
+    'AWS_ACCESS_KEY_ID',
+    'AWS_SECRET_ACCESS_KEY',
+    'AWS_BUCKET',
+    'AWS_REGION',
+  ],
+  azure: ['AZURE_CONNECTION_STRING', 'AZURE_CONTAINER'],
+  gcp: ['GCP_PROJECT_ID', 'GCP_KEY_FILE', 'GCP_BUCKET'],
+  gdrive: [
+    'GDRIVE_CLIENT_ID',
+    'GDRIVE_CLIENT_SECRET',
+    'GDRIVE_REFRESH_TOKEN',
+    'GDRIVE_FOLDER_ID',
+  ],
+  dropbox: ['DROPBOX_ACCESS_TOKEN'],
+  local: [],
+  ftp: ['FTP_HOST', 'FTP_USER', 'FTP_PASSWORD'],
+  ssh: ['SSH_HOST', 'SSH_USER', 'SSH_KEY'],
+};
+
+const BACKEND_SSH_ENV_VARS = [
+  'SSH_DEPLOY_PATH',
+  'SSH_APP_NAME',
+  'SSH_PORT',
+];
+
+/**
+ * @param {string} cliSource
+ * @returns {string}
+ */
+export function getCliInstallSpec(cliSource) {
+  if (!cliSource || cliSource === 'npm:deployhub') {
+    return 'deployhub@latest';
+  }
+  if (cliSource.startsWith('github:')) {
+    return cliSource;
+  }
+  if (cliSource.startsWith('file:')) {
+    return cliSource;
+  }
+  return cliSource;
+}
+
+/**
+ * @param {import('../core/config.js').DeployHubConfig} [config]
+ * @returns {string[]}
+ */
+function getBackendSetupSteps(config) {
+  if (!config) return [];
+
+  const projectType = config.projectType || 'frontend';
+  if (projectType === 'frontend') return [];
+
+  /** @type {string[]} */
+  const steps = [];
+
+  if (projectType === 'backend' || projectType === 'both') {
+    const framework = config.backend?.framework || config.framework || 'express';
+    if (['express', 'nestjs', 'fastify', 'koa', 'nextjs'].includes(framework)) {
+      steps.push(`      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'`);
+    }
+    if (['fastapi', 'django', 'flask'].includes(framework)) {
+      steps.push(`      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'`);
+    }
+    if (['spring', 'java'].includes(framework)) {
+      steps.push(`      - uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'`);
+    }
+    if (framework === 'go') {
+      steps.push(`      - uses: actions/setup-go@v5
+        with:
+          go-version: '1.22'`);
+    }
+    if (framework === 'dotnet') {
+      steps.push(`      - uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '8.0.x'`);
+    }
+    if (framework === 'rails') {
+      steps.push(`      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.2'
+          bundler-cache: true`);
+    }
+  }
+
+  return steps;
+}
+
+/**
+ * @param {Record<string, unknown>[]} environments
+ * @returns {string[]}
+ */
+function getPlatformInstallSteps(environments) {
+  /** @type {Set<string>} */
+  const steps = new Set();
+
+  for (const env of environments) {
+    if (env.deploymentType !== 'platform' && env.frontendDeploymentType !== 'platform') {
+      continue;
+    }
+    const platform = env.platform;
+    if (!platform) continue;
+    const cli = PLATFORM_CLI_MAP[platform];
+    if (cli?.globalInstall) {
+      steps.add(`      - name: Install ${platform} CLI\n        run: ${cli.globalInstall}`);
+    }
+  }
+
+  return Array.from(steps);
+}
+
+/**
+ * @param {string[]} deployEnvironments
+ * @param {Record<string, Record<string, unknown>>} environments
+ */
+function collectPlatformEnvVars(deployEnvironments, environments) {
+  /** @type {Set<string>} */
+  const envVars = new Set();
+
+  for (const envName of deployEnvironments) {
+    const env = environments[envName];
+    if (!env) continue;
+
+    if (env.deploymentType === 'platform' || env.frontendDeploymentType === 'platform') {
+      const platform = env.platform;
+      if (!platform) continue;
+      const keys = PLATFORM_ENV_MAP[platform] || [];
+      for (const key of keys) {
+        envVars.add(`${key}: \${{ secrets.${key} }}`);
+      }
+    }
+  }
+
+  return envVars;
+}
+
+/**
+ * @param {string[]} storageProviders
+ * @param {string[]} deployEnvironments
+ * @param {Record<string, { type: string }>} environments
+ * @param {string} [cliSource]
+ * @param {import('../core/config.js').DeployHubConfig} [config]
+ * @returns {string}
+ */
+export function generateWorkflowYaml(
+  storageProviders,
+  deployEnvironments,
+  environments,
+  cliSource = 'npm:deployhub',
+  config = null
+) {
+  /** @type {Set<string>} */
+  const envVars = new Set(['DEPLOYHUB_ENV: production']);
+
+  for (const provider of storageProviders) {
+    const keys = PROVIDER_ENV_MAP[provider] || [];
+    for (const key of keys) {
+      envVars.add(`${key}: \${{ secrets.${key} }}`);
+    }
+  }
+
+  for (const envName of deployEnvironments) {
+    const env = environments[envName];
+    if (!env) continue;
+
+    if (env.deploymentType !== 'platform') {
+      const keys = PROVIDER_ENV_MAP[env.type] || [];
+      for (const key of keys) {
+        envVars.add(`${key}: \${{ secrets.${key} }}`);
+      }
+    }
+
+    if (env.type === 'ssh' && config) {
+      const projectType = config.projectType || 'frontend';
+      if (projectType === 'backend' || projectType === 'both') {
+        for (const key of BACKEND_SSH_ENV_VARS) {
+          envVars.add(`${key}: \${{ secrets.${key} }}`);
+        }
+      }
+    }
+  }
+
+  for (const line of collectPlatformEnvVars(deployEnvironments, environments)) {
+    envVars.add(line);
+  }
+
+  const envBlock = Array.from(envVars)
+    .map((line) => `          ${line}`)
+    .join('\n');
+
+  const installSpec = getCliInstallSpec(cliSource);
+  const backendSteps = getBackendSetupSteps(config);
+  const uniqueBackendSteps = [...new Set(backendSteps)].join('\n');
+
+  const envList = deployEnvironments
+    .map((name) => environments[name])
+    .filter(Boolean);
+  const platformSteps = getPlatformInstallSteps(envList).join('\n');
+
+  const projectType = config?.projectType || 'frontend';
+  const installDepsCommand =
+    projectType === 'backend' || projectType === 'both'
+      ? getInstallDepsCommand(config)
+      : 'npm install';
+
+  const workflow = `${getWorkflowHeaderComment()}name: DeployHub
+on:
+  push:
+    branches: [main]
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+${uniqueBackendSteps ? `${uniqueBackendSteps}\n` : ''}      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+      - name: Install project dependencies
+        run: ${installDepsCommand}
+${platformSteps ? `${platformSteps}\n` : ''}      - name: Install DeployHub CLI
+        run: npm install ${installSpec} --no-save
+      - run: npx deployhub build
+        env:
+${envBlock}
+`;
+
+  return workflow;
+}
+
+/**
+ * @param {import('../core/config.js').DeployHubConfig} [config]
+ * @returns {string}
+ */
+function getInstallDepsCommand(config) {
+  if (!config) return 'npm install';
+
+  const framework =
+    config.backend?.framework || config.framework || 'express';
+  const language = config.backend?.language || config.language;
+
+  if (language === 'python' || ['fastapi', 'django', 'flask'].includes(framework)) {
+    return 'pip install -r requirements.txt';
+  }
+  if (['laravel', 'symfony'].includes(framework)) {
+    return 'composer install --no-interaction';
+  }
+  if (framework === 'spring' || framework === 'java') {
+    return 'mvn dependency:resolve || true';
+  }
+  if (framework === 'go') {
+    return 'go mod download';
+  }
+  if (framework === 'dotnet') {
+    return 'dotnet restore';
+  }
+  if (framework === 'rails') {
+    return 'bundle install';
+  }
+  return 'npm install';
+}
+
+/**
+ * @param {string[]} storageProviders
+ * @param {string[]} deployEnvironments
+ * @param {Record<string, { type: string }>} environments
+ * @param {string} [cwd]
+ * @param {string} [cliSource]
+ * @param {import('../core/config.js').DeployHubConfig} [config]
+ */
+export async function writeWorkflowFile(
+  storageProviders,
+  deployEnvironments,
+  environments,
+  cwd = process.cwd(),
+  cliSource = 'npm:deployhub',
+  config = null
+) {
+  const workflowDir = path.join(cwd, '.github', 'workflows');
+  await fs.ensureDir(workflowDir);
+  const content = generateWorkflowYaml(
+    storageProviders,
+    deployEnvironments,
+    environments,
+    cliSource,
+    config
+  );
+  await fs.writeFile(path.join(workflowDir, 'deployhub.yml'), content);
+}
+
+/**
+ * @param {string} cliSource
+ * @param {string} [cwd]
+ */
+export async function addDeployhubToPackageJson(cliSource, cwd = process.cwd()) {
+  const pkgPath = path.join(cwd, 'package.json');
+  if (!(await fs.pathExists(pkgPath))) return;
+
+  const pkg = await fs.readJson(pkgPath);
+  pkg.devDependencies = pkg.devDependencies || {};
+  pkg.devDependencies.deployhub = getCliInstallSpec(cliSource);
+  pkg.scripts = pkg.scripts || {};
+  pkg.scripts['deployhub:build'] = 'deployhub build';
+  await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+}
+
+/**
+ * @param {string} [cwd]
+ * @returns {Promise<string>}
+ */
+export async function guessCliGithubRepo(cwd = process.cwd()) {
+  try {
+    const { execa } = await import('execa');
+    const { stdout } = await execa('git', ['remote', 'get-url', 'origin'], {
+      cwd,
+      stdio: 'pipe',
+    });
+    const match = stdout.match(/github\.com[:/](.+?)\/(.+?)(?:\.git)?$/);
+    if (match) {
+      return `github:${match[1]}/deployhub`;
+    }
+  } catch {
+    // ignore
+  }
+  return 'github:YOUR_USERNAME/deployhub';
+}
+
+/**
+ * @param {string[]} storageProviders
+ * @param {string[]} deployEnvironments
+ * @param {Record<string, { type: string }>} environments
+ * @param {import('../core/config.js').DeployHubConfig} [config]
+ * @returns {string[]}
+ */
+export function getRequiredSecrets(
+  storageProviders,
+  deployEnvironments,
+  environments,
+  config = null
+) {
+  /** @type {Set<string>} */
+  const secrets = new Set();
+
+  for (const provider of storageProviders) {
+    const keys = PROVIDER_ENV_MAP[provider] || [];
+    keys.forEach((k) => secrets.add(k));
+  }
+
+  for (const envName of deployEnvironments) {
+    const env = environments[envName];
+    if (!env) continue;
+
+    if (env.deploymentType === 'platform' || env.frontendDeploymentType === 'platform') {
+      const platform = env.platform;
+      if (platform) {
+        const keys = PLATFORM_ENV_MAP[platform] || [];
+        keys.forEach((k) => secrets.add(k));
+      }
+    } else {
+      const keys = PROVIDER_ENV_MAP[env.type] || [];
+      keys.forEach((k) => secrets.add(k));
+    }
+
+    if (env.type === 'ssh' && config) {
+      const projectType = config.projectType || 'frontend';
+      if (projectType === 'backend' || projectType === 'both') {
+        BACKEND_SSH_ENV_VARS.forEach((k) => secrets.add(k));
+      }
+    }
+  }
+
+  return Array.from(secrets);
+}
+
+export { PROVIDER_ENV_MAP };

package/src/utils/init-platform.js

@@ -0,0 +1,229 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import { execa } from 'execa';
+import {
+  PLATFORM_CHOICES,
+  PLATFORM_COMPARISON,
+  getPlatformEnvExample,
+} from './platform-env.js';
+import { ensureFirebaseJson } from './firebase-config-generator.js';
+import { appendEnv } from '../core/config.js';
+
+/**
+ * @param {string} platform
+ * @param {string} projectName
+ * @param {string} buildOutput
+ * @param {string} [cwd]
+ * @returns {Promise<Record<string, unknown>>}
+ */
+export async function promptPlatformQuestions(
+  platform,
+  projectName,
+  buildOutput,
+  cwd = process.cwd()
+) {
+  /** @type {Record<string, unknown>} */
+  const config = { platform };
+
+  switch (platform) {
+    case 'vercel': {
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'projectName',
+          message: 'Vercel project name:',
+          default: projectName,
+        },
+        {
+          type: 'confirm',
+          name: 'vercelLinked',
+          message: 'Have you already linked this project with Vercel?',
+          default: fs.existsSync(path.join(cwd, '.vercel', 'project.json')),
+        },
+      ]);
+      config.projectName = answers.projectName;
+
+      if (!answers.vercelLinked) {
+        console.log(chalk.gray('Running vercel link — follow the prompts...'));
+        try {
+          await execa('vercel', ['link'], { cwd, stdio: 'inherit' });
+        } catch {
+          console.log(
+            chalk.yellow(
+              'Could not run vercel link automatically. Run it manually, then add VERCEL_ORG_ID and VERCEL_PROJECT_ID to .env'
+            )
+          );
+        }
+      }
+      break;
+    }
+
+    case 'netlify': {
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'siteId',
+          message: 'Netlify site ID (from Netlify dashboard):',
+        },
+      ]);
+      config.siteId = answers.siteId;
+      break;
+    }
+
+    case 'cloudflare-pages': {
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'projectName',
+          message: 'Cloudflare Pages project name:',
+          default: projectName,
+        },
+        {
+          type: 'input',
+          name: 'accountId',
+          message: 'Cloudflare account ID (from dashboard):',
+        },
+      ]);
+      config.projectName = answers.projectName;
+      config.accountId = answers.accountId;
+      break;
+    }
+
+    case 'aws-amplify': {
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'appId',
+          message: 'Amplify App ID (from AWS console):',
+        },
+        {
+          type: 'input',
+          name: 'region',
+          message: 'AWS region:',
+          default: 'us-east-1',
+        },
+        {
+          type: 'confirm',
+          name: 'githubConnected',
+          message: 'GitHub already connected to Amplify?',
+          default: true,
+        },
+      ]);
+      config.appId = answers.appId;
+      config.region = answers.region;
+      config.githubConnected = answers.githubConnected;
+      break;
+    }
+
+    case 'azure-static-web-apps': {
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'resourceName',
+          message: 'Resource name:',
+          default: projectName,
+        },
+      ]);
+      config.resourceName = answers.resourceName;
+      break;
+    }
+
+    case 'firebase-hosting': {
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'projectId',
+          message: 'Firebase project ID:',
+          default: projectName,
+        },
+      ]);
+      config.projectId = answers.projectId;
+      await ensureFirebaseJson(buildOutput, cwd);
+      console.log(chalk.green('✓ firebase.json generated'));
+      break;
+    }
+
+    case 'firebase-app-hosting': {
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'projectId',
+          message: 'Firebase project ID:',
+          default: projectName,
+        },
+        {
+          type: 'input',
+          name: 'backendName',
+          message: 'Backend name:',
+          default: `${projectName}-backend`,
+        },
+      ]);
+      config.projectId = answers.projectId;
+      config.backendName = answers.backendName;
+      break;
+    }
+
+    default:
+      break;
+  }
+
+  return config;
+}
+
+/**
+ * @param {string} platform
+ * @param {string} [cwd]
+ */
+export async function appendPlatformEnvExample(platform, cwd = process.cwd()) {
+  const examples = getPlatformEnvExample(platform);
+  await appendEnv(examples, cwd);
+
+  const envExamplePath = path.join(cwd, '.env.example');
+  if (!(await fs.pathExists(envExamplePath))) return;
+
+  let content = await fs.readFile(envExamplePath, 'utf-8');
+  const sectionHeader = `\n# ${platform} deployment\n`;
+  const lines = Object.keys(examples)
+    .map((key) => `${key}=`)
+    .join('\n');
+
+  if (!content.includes(`${platform} deployment`)) {
+    content += `${sectionHeader}${lines}\n`;
+    await fs.writeFile(envExamplePath, content);
+  }
+}
+
+export function showPlatformComparison() {
+  console.log('');
+  console.log(chalk.bold('Platform comparison:'));
+  console.log(chalk.gray(PLATFORM_COMPARISON));
+  console.log('');
+}
+
+/**
+ * @param {string} platform
+ * @param {string} projectName
+ * @returns {string}
+ */
+export function suggestHealthUrl(platform, projectName) {
+  const urls = {
+    vercel: `https://${projectName}.vercel.app`,
+    netlify: `https://${projectName}.netlify.app`,
+    'cloudflare-pages': `https://${projectName}.pages.dev`,
+    'firebase-hosting': `https://${projectName}.web.app`,
+    'firebase-app-hosting': `https://${projectName}.web.app`,
+  };
+  return urls[platform] || '';
+}
+
+export { PLATFORM_CHOICES };
+
+export default {
+  promptPlatformQuestions,
+  appendPlatformEnvExample,
+  showPlatformComparison,
+  suggestHealthUrl,
+  PLATFORM_CHOICES,
+};

package/src/utils/nginx.js

@@ -0,0 +1,34 @@
+/**
+ * Generate nginx server block config for SPA frontend deployments.
+ *
+ * @param {string} projectName
+ * @param {string} deployPath - Absolute deploy path on the server
+ * @param {string} [buildOutput='dist']
+ * @returns {string}
+ */
+export function generateNginxConfig(projectName, deployPath, buildOutput = 'dist') {
+  const root = `${deployPath.replace(/\/$/, '')}/${buildOutput}`;
+
+  return `server {
+    listen 80;
+    server_name _;
+    root ${root};
+    index index.html;
+
+    location / {
+        try_files $uri $uri/ /index.html;
+    }
+}
+`;
+}
+
+/**
+ * @param {string} projectName
+ * @returns {string}
+ */
+export function getNginxSitePath(projectName) {
+  const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, '-');
+  return `/etc/nginx/sites-available/${safeName}`;
+}
+
+export default { generateNginxConfig, getNginxSitePath };