@akash-chowdhury-24/deployhub 1.0.16 → 2.0.2

package/src/deployment/providers/platforms/firebase-app-hosting.js

@@ -1,95 +0,0 @@
-import { createLogger } from '../../../logger/index.js';
-import {
-  runCli,
-  saveDeploymentRecord,
-  checkUrlHealth,
-} from './_shared.js';
-
-/**
- * @param {import('../../../core/config.js').DeployHubConfig} config
- * @param {string} envName
- * @param {Record<string, string>} [env]
- */
-export function createFirebaseAppHostingProvider(config, envName, env = process.env) {
-  const environment = config.environments[envName];
-  const log = createLogger('firebase-app-hosting');
-  const token = env.FIREBASE_TOKEN;
-  const projectId = environment?.projectId || env.FIREBASE_PROJECT_ID;
-  const backendName =
-    environment?.backendName || env.FIREBASE_APP_HOSTING_BACKEND || config.project;
-
-  async function deploy(artifactDir) {
-    if (!token || !projectId) {
-      throw new Error('FIREBASE_TOKEN and FIREBASE_PROJECT_ID are required');
-    }
-
-    log.info(`Deploying to Firebase App Hosting (${projectId}/${backendName})...`);
-
-    const createResult = await runCli(
-      `firebase apphosting:backends:list --project=${projectId} --token=${token} --non-interactive`,
-      process.cwd()
-    );
-
-    const backendExists =
-      createResult.exitCode === 0 && createResult.stdout.includes(backendName);
-
-    if (!backendExists) {
-      log.info(`Creating App Hosting backend "${backendName}"...`);
-      await runCli(
-        `firebase apphosting:backends:create --project=${projectId} --token=${token} --backend=${backendName} --non-interactive`,
-        process.cwd()
-      );
-    }
-
-    const result = await runCli(
-      `firebase deploy --only apphosting --token=${token} --project=${projectId} --non-interactive`,
-      process.cwd()
-    );
-
-    if (result.exitCode !== 0) {
-      throw new Error(`Firebase App Hosting deploy failed: ${result.stderr || result.stdout}`);
-    }
-
-    await saveDeploymentRecord(
-      artifactDir,
-      {
-        platform: 'firebase-app-hosting',
-        deploymentId: `apphosting-${Date.now()}`,
-        projectId,
-        backendName,
-        deploymentUrl: config.healthCheck?.url || '',
-      },
-      envName
-    );
-
-    log.success('Deployed to Firebase App Hosting');
-  }
-
-  async function rollback(artifactDir) {
-    log.info('Firebase App Hosting rollback — re-deploying previous artifact...');
-    await deploy(artifactDir);
-  }
-
-  async function healthCheck() {
-    const url = config.healthCheck?.url;
-    if (!url) return true;
-    return checkUrlHealth(url);
-  }
-
-  async function testConnection() {
-    if (!token || !projectId) {
-      throw new Error('FIREBASE_TOKEN and FIREBASE_PROJECT_ID are required');
-    }
-    const result = await runCli(
-      `firebase projects:list --token=${token} --non-interactive`,
-      process.cwd()
-    );
-    if (result.exitCode !== 0) {
-      throw new Error('Invalid FIREBASE_TOKEN');
-    }
-  }
-
-  return { deploy, rollback, healthCheck, testConnection };
-}
-
-export default { createFirebaseAppHostingProvider };

package/src/deployment/providers/platforms/firebase-hosting.js

@@ -1,99 +0,0 @@
-import { createLogger } from '../../../logger/index.js';
-import { ensureFirebaseJson } from '../../../utils/firebase-config-generator.js';
-import {
-  runCli,
-  saveDeploymentRecord,
-  readPreviousPlatformDeployment,
-  checkUrlHealth,
-  getBuildOutputDir,
-} from './_shared.js';
-
-/**
- * @param {import('../../../core/config.js').DeployHubConfig} config
- * @param {string} envName
- * @param {Record<string, string>} [env]
- */
-export function createFirebaseHostingProvider(config, envName, env = process.env) {
-  const environment = config.environments[envName];
-  const log = createLogger('firebase-hosting');
-  const token = env.FIREBASE_TOKEN;
-  const projectId = environment?.projectId || env.FIREBASE_PROJECT_ID;
-
-  async function deploy(artifactDir) {
-    if (!token || !projectId) {
-      throw new Error('FIREBASE_TOKEN and FIREBASE_PROJECT_ID are required');
-    }
-
-    const cwd = process.cwd();
-    const buildOutput = getBuildOutputDir(config);
-    await ensureFirebaseJson(buildOutput, cwd);
-
-    log.info(`Deploying to Firebase Hosting (${projectId})...`);
-    const result = await runCli(
-      `firebase deploy --only hosting --token=${token} --project=${projectId} --non-interactive`,
-      cwd
-    );
-
-    if (result.exitCode !== 0) {
-      throw new Error(`Firebase deploy failed: ${result.stderr || result.stdout}`);
-    }
-
-    const urlMatch = (result.stdout || '').match(/Hosting URL:\s*(https:\/\/\S+)/i);
-    const deploymentUrl = urlMatch?.[1] || config.healthCheck?.url || '';
-
-    await saveDeploymentRecord(
-      artifactDir,
-      {
-        platform: 'firebase-hosting',
-        deploymentUrl,
-        deploymentId: deploymentUrl,
-        projectId,
-      },
-      envName
-    );
-
-    log.success(`Deployed to Firebase Hosting: ${deploymentUrl || projectId}`);
-  }
-
-  async function rollback(artifactDir) {
-    if (!token || !projectId) {
-      throw new Error('FIREBASE_TOKEN and FIREBASE_PROJECT_ID are required');
-    }
-
-    log.info('Rolling back Firebase Hosting...');
-    const result = await runCli(
-      `firebase hosting:rollback --token=${token} --project=${projectId} --non-interactive`,
-      process.cwd()
-    );
-    if (result.exitCode !== 0) {
-      throw new Error(`Firebase rollback failed: ${result.stderr || result.stdout}`);
-    }
-    log.success('Firebase Hosting rollback complete');
-  }
-
-  async function healthCheck() {
-    const url = config.healthCheck?.url;
-    if (!url) return true;
-    return checkUrlHealth(url);
-  }
-
-  async function testConnection() {
-    if (!token || !projectId) {
-      throw new Error('FIREBASE_TOKEN and FIREBASE_PROJECT_ID are required');
-    }
-    const result = await runCli(
-      `firebase projects:list --token=${token} --non-interactive`,
-      process.cwd()
-    );
-    if (result.exitCode !== 0) {
-      throw new Error('Invalid FIREBASE_TOKEN');
-    }
-    if (!result.stdout.includes(projectId)) {
-      throw new Error(`Firebase project "${projectId}" not accessible`);
-    }
-  }
-
-  return { deploy, rollback, healthCheck, testConnection };
-}
-
-export default { createFirebaseHostingProvider };

package/src/deployment/providers/platforms/index.js

@@ -1,44 +0,0 @@
-import { createVercelProvider } from './vercel.js';
-import { createNetlifyProvider } from './netlify.js';
-import { createCloudflarePagesProvider } from './cloudflare-pages.js';
-import { createAwsAmplifyProvider } from './aws-amplify.js';
-import { createAzureStaticWebAppsProvider } from './azure-static-web-apps.js';
-import { createFirebaseHostingProvider } from './firebase-hosting.js';
-import { createFirebaseAppHostingProvider } from './firebase-app-hosting.js';
-
-/** @type {Record<string, Function>} */
-const PLATFORM_FACTORIES = {
-  vercel: createVercelProvider,
-  netlify: createNetlifyProvider,
-  'cloudflare-pages': createCloudflarePagesProvider,
-  'aws-amplify': createAwsAmplifyProvider,
-  'azure-static-web-apps': createAzureStaticWebAppsProvider,
-  'firebase-hosting': createFirebaseHostingProvider,
-  'firebase-app-hosting': createFirebaseAppHostingProvider,
-};
-
-/**
- * @param {string} platform
- * @param {import('../../../core/config.js').DeployHubConfig} config
- * @param {string} envName
- * @param {Record<string, string>} [env]
- */
-export function createPlatformProvider(platform, config, envName, env = process.env) {
-  const factory = PLATFORM_FACTORIES[platform];
-  if (!factory) {
-    throw new Error(`Unknown platform: ${platform}`);
-  }
-  return factory(config, envName, env);
-}
-
-export {
-  createVercelProvider,
-  createNetlifyProvider,
-  createCloudflarePagesProvider,
-  createAwsAmplifyProvider,
-  createAzureStaticWebAppsProvider,
-  createFirebaseHostingProvider,
-  createFirebaseAppHostingProvider,
-};
-
-export default { createPlatformProvider, PLATFORM_FACTORIES };

package/src/deployment/providers/platforms/netlify.js

@@ -1,102 +0,0 @@
-import axios from 'axios';
-import { createLogger } from '../../../logger/index.js';
-import {
-  runCli,
-  saveDeploymentRecord,
-  readPreviousPlatformDeployment,
-  checkUrlHealth,
-  resolveBuildOutputPath,
-} from './_shared.js';
-
-/**
- * @param {import('../../../core/config.js').DeployHubConfig} config
- * @param {string} envName
- * @param {Record<string, string>} [env]
- */
-export function createNetlifyProvider(config, envName, env = process.env) {
-  const environment = config.environments[envName];
-  const log = createLogger('netlify');
-  const authToken = env.NETLIFY_AUTH_TOKEN;
-  const siteId = environment?.siteId || env.NETLIFY_SITE_ID;
-
-  async function deploy(artifactDir) {
-    if (!authToken || !siteId) {
-      throw new Error('NETLIFY_AUTH_TOKEN and NETLIFY_SITE_ID are required');
-    }
-
-    const buildDir = resolveBuildOutputPath(config);
-    log.info(`Deploying to Netlify from ${buildDir}...`);
-
-    const result = await runCli(
-      `netlify deploy --prod --dir="${buildDir}" --auth=${authToken} --site=${siteId}`,
-      process.cwd()
-    );
-
-    if (result.exitCode !== 0) {
-      throw new Error(`Netlify deploy failed: ${result.stderr || result.stdout}`);
-    }
-
-    const deployIdMatch = (result.stdout || '').match(/Deploy ID:\s*(\S+)/i);
-    const urlMatch = (result.stdout || '').match(/Website URL:\s*(https:\/\/\S+)/i);
-    const deployId = deployIdMatch?.[1] || '';
-    const deploymentUrl = urlMatch?.[1] || config.healthCheck?.url || '';
-
-    await saveDeploymentRecord(
-      artifactDir,
-      {
-        platform: 'netlify',
-        deploymentUrl,
-        deploymentId: deployId,
-        siteId,
-      },
-      envName
-    );
-
-    log.success(`Deployed to Netlify: ${deploymentUrl || siteId}`);
-  }
-
-  async function rollback(artifactDir) {
-    if (!authToken || !siteId) {
-      throw new Error('NETLIFY_AUTH_TOKEN and NETLIFY_SITE_ID are required');
-    }
-
-    const previous = await readPreviousPlatformDeployment(artifactDir);
-    const deployId = previous?.deploymentId;
-    if (!deployId) {
-      throw new Error('No previous Netlify deployment ID found for rollback');
-    }
-
-    log.info(`Restoring Netlify deploy ${deployId}...`);
-    await axios.post(
-      `https://api.netlify.com/api/v1/sites/${siteId}/deploys/${deployId}/restore`,
-      {},
-      { headers: { Authorization: `Bearer ${authToken}` } }
-    );
-    log.success('Netlify rollback complete');
-  }
-
-  async function healthCheck() {
-    const url = config.healthCheck?.url;
-    if (!url) return true;
-    return checkUrlHealth(url);
-  }
-
-  async function testConnection() {
-    if (!authToken) throw new Error('NETLIFY_AUTH_TOKEN is required');
-    const response = await axios.get('https://api.netlify.com/api/v1/user', {
-      headers: { Authorization: `Bearer ${authToken}` },
-    });
-    if (!response.data?.email) {
-      throw new Error('Invalid NETLIFY_AUTH_TOKEN');
-    }
-    if (siteId) {
-      await axios.get(`https://api.netlify.com/api/v1/sites/${siteId}`, {
-        headers: { Authorization: `Bearer ${authToken}` },
-      });
-    }
-  }
-
-  return { deploy, rollback, healthCheck, testConnection };
-}
-
-export default { createNetlifyProvider };

package/src/deployment/providers/platforms/vercel.js

@@ -1,92 +0,0 @@
-import { createLogger } from '../../../logger/index.js';
-import {
-  runCli,
-  saveDeploymentRecord,
-  readPreviousPlatformDeployment,
-  checkUrlHealth,
-} from './_shared.js';
-
-/**
- * @param {import('../../../core/config.js').DeployHubConfig} config
- * @param {string} envName
- * @param {Record<string, string>} [env]
- */
-export function createVercelProvider(config, envName, env = process.env) {
-  const log = createLogger('vercel');
-  const token = env.VERCEL_TOKEN;
-  const orgId = env.VERCEL_ORG_ID;
-  const projectId = env.VERCEL_PROJECT_ID;
-
-  async function deploy(artifactDir) {
-    if (!token) throw new Error('VERCEL_TOKEN is required');
-
-    log.info('Deploying to Vercel...');
-    const cwd = process.cwd();
-    const deployEnv = {
-      VERCEL_ORG_ID: orgId || '',
-      VERCEL_PROJECT_ID: projectId || '',
-    };
-
-    const result = await runCli(
-      `vercel deploy --prod --token=${token} --yes`,
-      cwd,
-      deployEnv
-    );
-
-    if (result.exitCode !== 0) {
-      throw new Error(`Vercel deploy failed: ${result.stderr || result.stdout}`);
-    }
-
-    const output = result.stdout || '';
-    const urlMatch = output.match(/https:\/\/[^\s]+\.vercel\.app/);
-    const deploymentUrl = urlMatch ? urlMatch[0] : config.healthCheck?.url || '';
-
-    await saveDeploymentRecord(
-      artifactDir,
-      {
-        platform: 'vercel',
-        deploymentUrl,
-        deploymentId: deploymentUrl,
-      },
-      envName
-    );
-
-    log.success(`Deployed to Vercel: ${deploymentUrl || 'production'}`);
-  }
-
-  async function rollback(artifactDir) {
-    if (!token) throw new Error('VERCEL_TOKEN is required');
-
-    const previous = await readPreviousPlatformDeployment(artifactDir);
-    const deploymentUrl = previous?.deploymentUrl || previous?.deploymentId;
-
-    log.info('Rolling back on Vercel...');
-    const cmd = deploymentUrl
-      ? `vercel rollback ${deploymentUrl} --token=${token} --yes`
-      : `vercel rollback --token=${token} --yes`;
-
-    const result = await runCli(cmd, process.cwd());
-    if (result.exitCode !== 0) {
-      throw new Error(`Vercel rollback failed: ${result.stderr || result.stdout}`);
-    }
-    log.success('Vercel rollback complete');
-  }
-
-  async function healthCheck() {
-    const url = config.healthCheck?.url;
-    if (!url) return true;
-    return checkUrlHealth(url);
-  }
-
-  async function testConnection() {
-    if (!token) throw new Error('VERCEL_TOKEN is required');
-    const result = await runCli(`vercel whoami --token=${token}`, process.cwd());
-    if (result.exitCode !== 0) {
-      throw new Error('Invalid VERCEL_TOKEN');
-    }
-  }
-
-  return { deploy, rollback, healthCheck, testConnection };
-}
-
-export default { createVercelProvider };

package/src/rollback/engine.js

@@ -1,102 +0,0 @@
-import { downloadFromFirst } from '../storage/index.js';
-import { createPlatformProvider } from '../deployment/providers/platforms/index.js';
-import { extractArtifact } from '../artifact/engine.js';
-import { createLogger } from '../logger/index.js';
-import fs from 'fs-extra';
-import path from 'path';
-
-/**
- * @param {import('../core/config.js').DeployHubConfig} config
- * @param {string} artifactDir
- * @param {string} envName
- */
-async function rollbackPlatformTarget(config, artifactDir, envName) {
-  const envConfig = config.environments[envName];
-  if (!envConfig) {
-    throw new Error(`Environment "${envName}" not found in config`);
-  }
-
-  const deploymentPath = path.join(artifactDir, 'deployment.json');
-  if (await fs.pathExists(deploymentPath)) {
-    const data = await fs.readJson(deploymentPath);
-    const deployments = data.deployments || data.platformDeployments || [];
-    const record = deployments.find((d) => d.environmentName === envName) || data.lastDeployment;
-    if (record?.platform) {
-      const log = createLogger('rollback');
-      log.info(
-        `Rolling back ${envName} on ${record.platform} (deploy ${record.deployId || record.deploymentId || 'previous'})...`
-      );
-    }
-  }
-
-  if (envConfig.deploymentType === 'platform' || envConfig.frontendDeploymentType === 'platform') {
-    const platform = envConfig.platform;
-    if (!platform) {
-      throw new Error(`No platform configured for environment "${envName}"`);
-    }
-    const provider = createPlatformProvider(platform, config, envName);
-    await provider.rollback(artifactDir);
-    return;
-  }
-
-  if (
-    envConfig.frontendDeploymentType === 'platform' &&
-    (envConfig.backendDeploymentType === 'server' || envConfig.type)
-  ) {
-    const platformProvider = createPlatformProvider(envConfig.platform, config, envName);
-    await platformProvider.rollback(artifactDir);
-    const { getDeploymentProvider } = await import('../deployment/index.js');
-    const serverProvider = getDeploymentProvider(envConfig.type, config, envName);
-    await serverProvider.rollback(artifactDir);
-    return;
-  }
-
-  const { getDeploymentProvider } = await import('../deployment/index.js');
-  const provider = getDeploymentProvider(envConfig.type, config, envName);
-  await provider.rollback(artifactDir);
-}
-
-/**
- * @param {import('../core/config.js').DeployHubConfig} config
- * @param {string} version
- * @param {string} [cwd]
- */
-export async function rollbackToVersion(config, version, cwd = process.cwd()) {
-  const log = createLogger('rollback');
-  const remoteKey = `${config.project}/v${version}/artifact.zip`;
-  const restoreDir = path.join(cwd, '.deployhub-restore', `v${version}`);
-  const artifactDir = path.join(restoreDir, 'artifact');
-
-  log.info(`Downloading artifact v${version}...`);
-  await fs.emptyDir(restoreDir);
-  await fs.ensureDir(artifactDir);
-
-  const zipPath = path.join(artifactDir, 'artifact.zip');
-  await downloadFromFirst(config.storage, remoteKey, zipPath);
-
-  log.info('Extracting artifact for rollback...');
-  const extractedDir = path.join(artifactDir, '_extracted');
-  await fs.emptyDir(extractedDir);
-  await extractArtifact(artifactDir, extractedDir);
-
-  const extractedDeployment = path.join(extractedDir, 'deployment.json');
-  if (await fs.pathExists(extractedDeployment)) {
-    await fs.copy(extractedDeployment, path.join(artifactDir, 'deployment.json'));
-  }
-
-  const targets = config.deploy || [];
-  if (targets.length === 0) {
-    log.warn('No deployment targets configured');
-    return artifactDir;
-  }
-
-  log.info('Executing platform-specific rollback from deployment.json...');
-  for (const envName of targets) {
-    await rollbackPlatformTarget(config, artifactDir, envName);
-  }
-
-  log.success(`Rollback to v${version} complete`);
-  return artifactDir;
-}
-
-export default { rollbackToVersion };

package/src/utils/firebase-config-generator.js

@@ -1,35 +0,0 @@
-/**
- * Generate firebase.json for Firebase Hosting if missing.
- *
- * @param {string} buildOutput
- * @returns {object}
- */
-export function generateFirebaseHostingConfig(buildOutput = 'dist') {
-  return {
-    hosting: {
-      public: buildOutput,
-      ignore: ['firebase.json', '**/.*', '**/node_modules/**'],
-      rewrites: [{ source: '**', destination: '/index.html' }],
-    },
-  };
-}
-
-/**
- * @param {string} buildOutput
- * @param {string} [cwd]
- */
-export async function ensureFirebaseJson(buildOutput = 'dist', cwd = process.cwd()) {
-  const fs = (await import('fs-extra')).default;
-  const path = (await import('path')).default;
-  const firebasePath = path.join(cwd, 'firebase.json');
-
-  if (await fs.pathExists(firebasePath)) {
-    return firebasePath;
-  }
-
-  const config = generateFirebaseHostingConfig(buildOutput);
-  await fs.writeJson(firebasePath, config, { spaces: 2 });
-  return firebasePath;
-}
-
-export default { generateFirebaseHostingConfig, ensureFirebaseJson };