@akash-chowdhury-24/deployhub 1.0.0

package/src/core/stages.js

@@ -0,0 +1,210 @@
+import { detectFramework } from '../detectors/index.js';
+import { getAdapter } from '../adapters/index.js';
+import { createArtifact, repackArtifactZip } from '../artifact/engine.js';
+import { uploadToAll } from '../storage/index.js';
+import { deployToAll } from '../deployment/index.js';
+import { sendNotifications } from '../notifications/index.js';
+import axios from 'axios';
+import fs from 'fs-extra';
+import path from 'path';
+import { getProjectVersion } from '../utils/version.js';
+
+/**
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {string} cwd
+ * @param {Record<string, unknown>} state
+ */
+export function buildPipelineStages(config, cwd, state) {
+  /** @type {import('../core/pipeline.js').PipelineStage[]} */
+  const stages = [
+    {
+      name: 'detect',
+      async run(ctx) {
+        const detected = await detectFramework(ctx.cwd);
+        if (detected) {
+          if (!ctx.config.framework) ctx.config.framework = detected.framework;
+          if (!ctx.config.projectType && detected.projectType) {
+            ctx.config.projectType = detected.projectType;
+          }
+          if (!ctx.config.language && detected.language) {
+            ctx.config.language = detected.language;
+          }
+          if (ctx.config.buildCommand === undefined && detected.buildCommand !== undefined) {
+            ctx.config.buildCommand = detected.buildCommand;
+          }
+          if (!ctx.config.buildOutput && detected.buildOutput) {
+            ctx.config.buildOutput = detected.buildOutput;
+          }
+          if (!ctx.config.startCommand && detected.startCommand) {
+            ctx.config.startCommand = detected.startCommand;
+          }
+          if (!ctx.config.port && detected.port) {
+            ctx.config.port = detected.port;
+          }
+        }
+        ctx.state.framework = ctx.config.framework;
+        ctx.state.projectType = ctx.config.projectType || 'frontend';
+      },
+    },
+    {
+      name: 'install',
+      async run(ctx) {
+        const adapter = getAdapter(ctx.config.framework, ctx.config, ctx.cwd);
+        await adapter.install();
+      },
+    },
+    {
+      name: 'test',
+      enabled: (ctx) => ctx.config.pipeline.test === true,
+      async run(ctx) {
+        const adapter = getAdapter(ctx.config.framework, ctx.config, ctx.cwd);
+        await adapter.test();
+      },
+    },
+    {
+      name: 'build',
+      async run(ctx) {
+        if (ctx.config.projectType === 'both') {
+          if (ctx.config.frontend?.buildCommand) {
+            const frontendAdapter = getAdapter(
+              ctx.config.frontend.framework,
+              ctx.config,
+              ctx.cwd
+            );
+            const saved = ctx.config.buildCommand;
+            ctx.config.buildCommand = ctx.config.frontend.buildCommand;
+            await frontendAdapter.build();
+            ctx.config.buildCommand = saved;
+          }
+          if (ctx.config.backend?.buildCommand) {
+            const backendAdapter = getAdapter(
+              ctx.config.backend.framework,
+              ctx.config,
+              ctx.cwd
+            );
+            const saved = ctx.config.buildCommand;
+            ctx.config.buildCommand = ctx.config.backend.buildCommand;
+            await backendAdapter.build();
+            ctx.config.buildCommand = saved;
+          }
+          return;
+        }
+
+        const adapter = getAdapter(ctx.config.framework, ctx.config, ctx.cwd);
+        await adapter.build();
+      },
+    },
+    {
+      name: 'docker',
+      enabled: (ctx) =>
+        ctx.config.pipeline.docker === true && ctx.config.docker === true,
+      async run(ctx) {
+        const adapter = getAdapter(ctx.config.framework, ctx.config, ctx.cwd);
+        await adapter.docker();
+      },
+    },
+    {
+      name: 'artifact',
+      enabled: (ctx) => ctx.config.artifact !== false,
+      async run(ctx) {
+        ctx.config.version = await getProjectVersion(ctx.cwd);
+        const result = await createArtifact(
+          ctx.config,
+          /** @type {string[]} */ (ctx.state.deployedTargets || []),
+          ctx.cwd
+        );
+        ctx.state.artifactDir = result.artifactDir;
+        ctx.state.zipPath = result.zipPath;
+      },
+    },
+    {
+      name: 'storage',
+      enabled: (ctx) => {
+        const willDeploy =
+          ctx.config.pipeline.deploy === true && (ctx.config.deploy?.length || 0) > 0;
+        if (willDeploy && (!ctx.config.storage || ctx.config.storage.length === 0)) {
+          ctx.config.storage = ['local'];
+        }
+        return (ctx.config.storage?.length || 0) > 0;
+      },
+      async run(ctx) {
+        const zipPath = /** @type {string} */ (ctx.state.zipPath);
+        if (!zipPath) throw new Error('No artifact to upload');
+        await uploadToAll(ctx.config.storage, zipPath, ctx.config);
+        ctx.state.storageCompleted = true;
+      },
+    },
+    {
+      name: 'deploy',
+      enabled: (ctx) =>
+        ctx.config.pipeline.deploy === true && (ctx.config.deploy?.length || 0) > 0,
+      async run(ctx) {
+        if (!ctx.state.storageCompleted) {
+          throw new Error(
+            'Storage upload must complete before deploy. Enable at least one storage provider.'
+          );
+        }
+        const artifactDir = /** @type {string} */ (ctx.state.artifactDir);
+        if (!artifactDir) throw new Error('No artifact to deploy');
+        const deployed = await deployToAll(ctx.config, artifactDir);
+        ctx.state.deployedTargets = deployed;
+
+        const deploymentPath = path.join(artifactDir, 'deployment.json');
+        if (await fs.pathExists(deploymentPath)) {
+          const data = await fs.readJson(deploymentPath);
+          const last = data.lastDeployment;
+          if (last?.deployUrl || last?.deploymentUrl) {
+            ctx.state.lastDeployUrl = last.deployUrl || last.deploymentUrl;
+          }
+        }
+
+        await repackArtifactZip(artifactDir);
+        const zipPath = /** @type {string} */ (ctx.state.zipPath);
+        if (zipPath) {
+          await uploadToAll(ctx.config.storage, zipPath, ctx.config);
+        }
+      },
+    },
+    {
+      name: 'verify',
+      enabled: (ctx) =>
+        ctx.config.pipeline.verify === true && !!ctx.config.healthCheck?.url,
+      async run(ctx) {
+        const url = ctx.config.healthCheck.url;
+        const timeout = (ctx.config.healthCheck.timeout || 30) * 1000;
+        const start = Date.now();
+        const response = await axios.get(url, {
+          timeout,
+          validateStatus: () => true,
+        });
+        const elapsed = Date.now() - start;
+        if (response.status < 200 || response.status >= 400) {
+          throw new Error(
+            `Health check failed: HTTP ${response.status} (${elapsed}ms)`
+          );
+        }
+        ctx.state.healthCheck = { status: response.status, elapsed };
+      },
+    },
+    {
+      name: 'notify',
+      enabled: (ctx) => ctx.config.pipeline.notify === true,
+      async run(ctx) {
+        const lastDeploy = ctx.state.lastDeployUrl;
+        await sendNotifications(ctx.config, {
+          success: !ctx.state.failure,
+          version: ctx.config.version,
+          message: ctx.state.failure
+            ? String(ctx.state.failure)
+            : 'Build and deploy completed',
+          deployUrl: typeof lastDeploy === 'string' ? lastDeploy : ctx.config.healthCheck?.url,
+          environment: process.env.DEPLOYHUB_ENV || 'production',
+        });
+      },
+    },
+  ];
+
+  return stages;
+}
+
+export default { buildPipelineStages };

package/src/deployment/index.js

@@ -0,0 +1,156 @@
+import { createSshProvider } from './providers/ssh.js';
+import { createDockerProvider } from './providers/docker.js';
+import { createEc2Provider } from './providers/ec2.js';
+import { createAzureVmProvider } from './providers/azure-vm.js';
+import { createGcpVmProvider } from './providers/gcp-vm.js';
+import { createKubernetesProvider } from './providers/kubernetes.js';
+import { createPlatformProvider } from './providers/platforms/index.js';
+import { createLogger } from '../logger/index.js';
+
+/** @type {Record<string, Function>} */
+const PROVIDER_FACTORIES = {
+  ssh: createSshProvider,
+  docker: createDockerProvider,
+  ec2: createEc2Provider,
+  'azure-vm': createAzureVmProvider,
+  'gcp-vm': createGcpVmProvider,
+  kubernetes: createKubernetesProvider,
+};
+
+/**
+ * @param {Record<string, unknown>} environment
+ * @returns {boolean}
+ */
+function isPlatformDeployment(environment) {
+  return environment.deploymentType === 'platform';
+}
+
+/**
+ * @param {Record<string, unknown>} environment
+ * @returns {boolean}
+ */
+function isHybridEnvironment(environment) {
+  return (
+    environment.frontendDeploymentType === 'platform' &&
+    (environment.backendDeploymentType === 'server' || !!environment.type)
+  );
+}
+
+/**
+ * @param {string} type
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {string} envName
+ * @param {Record<string, string>} [env]
+ */
+export function getDeploymentProvider(type, config, envName, env = process.env) {
+  const environment = config.environments[envName];
+  if (!environment) {
+    throw new Error(`Environment "${envName}" not found in config`);
+  }
+
+  if (isPlatformDeployment(environment)) {
+    return createPlatformProvider(environment.platform, config, envName, env);
+  }
+
+  const providerType = type || environment.type;
+  const factory = PROVIDER_FACTORIES[providerType];
+  if (!factory) {
+    throw new Error(`Unknown deployment provider: ${providerType}`);
+  }
+  return factory(config, envName, env);
+}
+
+/**
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {string} artifactDir
+ * @param {string[]} [envNames]
+ */
+export async function deployToAll(config, artifactDir, envNames) {
+  const log = createLogger('deploy');
+  const targets = envNames || config.deploy || [];
+
+  if (targets.length === 0) {
+    log.warn('No deployment targets configured, skipping');
+    return [];
+  }
+
+  const deployed = [];
+  for (const envName of targets) {
+    const envConfig = config.environments[envName];
+    if (!envConfig) {
+      throw new Error(`Environment "${envName}" not found in config`);
+    }
+
+    if (isHybridEnvironment(envConfig)) {
+      log.info(`Deploying hybrid target ${envName} (platform frontend + server backend)...`);
+
+      const platformProvider = createPlatformProvider(
+        envConfig.platform,
+        config,
+        envName
+      );
+      await platformProvider.deploy(artifactDir);
+      log.success(`Frontend deployed to ${envConfig.platform}`);
+
+      const serverProvider = getDeploymentProvider(envConfig.type, config, envName);
+      await serverProvider.deploy(artifactDir);
+      log.success(`Backend deployed via ${envConfig.type}`);
+
+      deployed.push(envName);
+      continue;
+    }
+
+    if (isPlatformDeployment(envConfig)) {
+      const provider = createPlatformProvider(envConfig.platform, config, envName);
+      log.info(`Deploying to ${envName} (${envConfig.platform})...`);
+      await provider.deploy(artifactDir);
+      deployed.push(envName);
+      log.success(`Deployed to ${envName}`);
+      continue;
+    }
+
+    const provider = getDeploymentProvider(envConfig.type, config, envName);
+    log.info(`Deploying to ${envName} (${envConfig.type})...`);
+    await provider.deploy(artifactDir);
+    deployed.push(envName);
+    log.success(`Deployed to ${envName}`);
+  }
+
+  return deployed;
+}
+
+/**
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {string} artifactDir
+ * @param {string[]} [envNames]
+ */
+export async function rollbackAll(config, artifactDir, envNames) {
+  const targets = envNames || config.deploy || [];
+  for (const envName of targets) {
+    const envConfig = config.environments[envName];
+
+    if (isHybridEnvironment(envConfig)) {
+      const platformProvider = createPlatformProvider(
+        envConfig.platform,
+        config,
+        envName
+      );
+      await platformProvider.rollback(artifactDir);
+
+      const serverProvider = getDeploymentProvider(envConfig.type, config, envName);
+      await serverProvider.rollback(artifactDir);
+      continue;
+    }
+
+    if (isPlatformDeployment(envConfig)) {
+      const provider = createPlatformProvider(envConfig.platform, config, envName);
+      await provider.rollback(artifactDir);
+      continue;
+    }
+
+    const provider = getDeploymentProvider(envConfig.type, config, envName);
+    await provider.rollback(artifactDir);
+  }
+}
+
+export default { getDeploymentProvider, deployToAll, rollbackAll };

package/src/deployment/providers/azure-vm.js

@@ -0,0 +1,7 @@
+import { createSshProvider } from './ssh.js';
+
+export function createAzureVmProvider(config, envName, env) {
+  return createSshProvider(config, envName, env);
+}
+
+export default { createAzureVmProvider };

package/src/deployment/providers/docker.js

@@ -0,0 +1,30 @@
+import { execa } from 'execa';
+import { createLogger } from '../../logger/index.js';
+
+export function createDockerProvider(config, envName) {
+  const log = createLogger('docker');
+
+  async function deploy(artifactDir) {
+    log.info('Deploying via Docker...');
+    await execa('docker', ['compose', 'up', '-d', '--build'], {
+      cwd: artifactDir,
+      stdio: 'inherit',
+    });
+  }
+
+  async function rollback(artifactDir) {
+    await deploy(artifactDir);
+  }
+
+  async function healthCheck() {
+    return true;
+  }
+
+  async function testConnection() {
+    await execa('docker', ['info'], { stdio: 'pipe' });
+  }
+
+  return { deploy, rollback, healthCheck, testConnection };
+}
+
+export default { createDockerProvider };

package/src/deployment/providers/ec2.js

@@ -0,0 +1,7 @@
+import { createSshProvider } from './ssh.js';
+
+export function createEc2Provider(config, envName, env) {
+  return createSshProvider(config, envName, env);
+}
+
+export default { createEc2Provider };

package/src/deployment/providers/gcp-vm.js

@@ -0,0 +1,7 @@
+import { createSshProvider } from './ssh.js';
+
+export function createGcpVmProvider(config, envName, env) {
+  return createSshProvider(config, envName, env);
+}
+
+export default { createGcpVmProvider };

package/src/deployment/providers/kubernetes.js

@@ -0,0 +1,30 @@
+import { execa } from 'execa';
+import { createLogger } from '../../logger/index.js';
+
+export function createKubernetesProvider(config, envName) {
+  const log = createLogger('kubernetes');
+
+  async function deploy(artifactDir) {
+    log.info('Deploying to Kubernetes...');
+    await execa('kubectl', ['apply', '-f', '.'], {
+      cwd: artifactDir,
+      stdio: 'inherit',
+    });
+  }
+
+  async function rollback(artifactDir) {
+    await deploy(artifactDir);
+  }
+
+  async function healthCheck() {
+    return true;
+  }
+
+  async function testConnection() {
+    await execa('kubectl', ['cluster-info'], { stdio: 'pipe' });
+  }
+
+  return { deploy, rollback, healthCheck, testConnection };
+}
+
+export default { createKubernetesProvider };

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

@@ -0,0 +1,167 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { execa } from 'execa';
+
+/**
+ * @param {import('../../../core/config.js').DeployHubConfig} config
+ * @returns {string}
+ */
+export function getBuildOutputDir(config) {
+  if (config.projectType === 'both' && config.frontend?.buildOutput) {
+    return config.frontend.buildOutput;
+  }
+  return config.buildOutput || 'dist';
+}
+
+/**
+ * @param {import('../../../core/config.js').DeployHubConfig} config
+ * @param {string} [cwd]
+ * @returns {string}
+ */
+export function resolveBuildOutputPath(config, cwd = process.cwd()) {
+  return path.join(cwd, getBuildOutputDir(config));
+}
+
+/**
+ * @param {string} artifactDir
+ * @param {Record<string, unknown>} record
+ * @param {string} [environmentName]
+ */
+export async function saveDeploymentRecord(artifactDir, record, environmentName = '') {
+  const deploymentPath = path.join(artifactDir, 'deployment.json');
+  let existing = { targets: [], deployedAt: new Date().toISOString(), deployments: [] };
+
+  if (await fs.pathExists(deploymentPath)) {
+    existing = await fs.readJson(deploymentPath);
+  }
+
+  const timestamp = new Date().toISOString();
+  const envName = record.environmentName || environmentName || record.envName || '';
+
+  /** @type {Record<string, unknown>} */
+  const entry = {
+    ...record,
+    platform: record.platform,
+    deployId: record.deployId || record.deploymentId || '',
+    deployUrl: record.deployUrl || record.deploymentUrl || '',
+    deploymentId: record.deploymentId || record.deployId || '',
+    deploymentUrl: record.deploymentUrl || record.deployUrl || '',
+    timestamp,
+    environmentName: envName,
+  };
+
+  const deployments = existing.deployments || existing.platformDeployments || [];
+  deployments.push(entry);
+
+  await fs.writeJson(
+    deploymentPath,
+    {
+      ...existing,
+      deployments,
+      platformDeployments: deployments,
+      lastDeployment: entry,
+      deployedAt: timestamp,
+    },
+    { spaces: 2 }
+  );
+}
+
+/**
+ * @param {string} artifactDir
+ * @returns {Promise<Record<string, unknown>|null>}
+ */
+export async function readLastPlatformDeployment(artifactDir) {
+  const deploymentPath = path.join(artifactDir, 'deployment.json');
+  if (!(await fs.pathExists(deploymentPath))) return null;
+  const data = await fs.readJson(deploymentPath);
+  const deployments = data.deployments || data.platformDeployments || [];
+  return data.lastDeployment || deployments.at(-1) || null;
+}
+
+/**
+ * @param {string} artifactDir
+ * @returns {Promise<Record<string, unknown>|null>}
+ */
+export async function readPreviousPlatformDeployment(artifactDir) {
+  const deploymentPath = path.join(artifactDir, 'deployment.json');
+  if (!(await fs.pathExists(deploymentPath))) return null;
+  const data = await fs.readJson(deploymentPath);
+  const deployments = data.deployments || data.platformDeployments || [];
+  if (deployments.length < 2) return null;
+  return deployments[deployments.length - 2];
+}
+
+/**
+ * @param {string} artifactDir
+ * @param {string} [environmentName]
+ * @returns {Promise<Record<string, unknown>|null>}
+ */
+export async function readDeploymentForEnvironment(artifactDir, environmentName) {
+  const deploymentPath = path.join(artifactDir, 'deployment.json');
+  if (!(await fs.pathExists(deploymentPath))) return null;
+  const data = await fs.readJson(deploymentPath);
+  const deployments = data.deployments || data.platformDeployments || [];
+  if (environmentName) {
+    const match = deployments.filter((d) => d.environmentName === environmentName);
+    return match.at(-1) || null;
+  }
+  return data.lastDeployment || deployments.at(-1) || null;
+}
+
+/**
+ * @param {string} command
+ * @param {string} [cwd]
+ * @param {Record<string, string>} [env]
+ */
+export async function runCli(command, cwd = process.cwd(), env = process.env) {
+  const [cmd, ...args] = command.split(' ');
+  const result = await execa(cmd, args, {
+    cwd,
+    env: { ...process.env, ...env },
+    shell: true,
+    reject: false,
+  });
+  return result;
+}
+
+/**
+ * @param {string} binary
+ * @returns {Promise<boolean>}
+ */
+export async function isCliInstalled(binary) {
+  try {
+    const result = await execa(binary, ['--version'], { reject: false });
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @param {string} url
+ * @returns {Promise<boolean>}
+ */
+export async function checkUrlHealth(url) {
+  try {
+    const axios = (await import('axios')).default;
+    const response = await axios.get(url, {
+      timeout: 30000,
+      validateStatus: () => true,
+    });
+    return response.status >= 200 && response.status < 400;
+  } catch {
+    return false;
+  }
+}
+
+export default {
+  getBuildOutputDir,
+  resolveBuildOutputPath,
+  saveDeploymentRecord,
+  readLastPlatformDeployment,
+  readPreviousPlatformDeployment,
+  readDeploymentForEnvironment,
+  runCli,
+  isCliInstalled,
+  checkUrlHealth,
+};