@akash-chowdhury-24/deployhub 1.0.15 → 2.0.0

package/src/deployment/index.js

@@ -4,7 +4,6 @@ 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>} */
@@ -17,25 +16,6 @@ const PROVIDER_FACTORIES = {
   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
@@ -48,10 +28,6 @@ export function getDeploymentProvider(type, config, envName, env = process.env)
     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) {
@@ -81,34 +57,6 @@ export async function deployToAll(config, artifactDir, envNames) {
       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);
@@ -128,26 +76,6 @@ 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);
   }

package/src/rollback/engine.js

@@ -1,5 +1,5 @@
 import { downloadFromFirst } from '../storage/index.js';
-import { createPlatformProvider } from '../deployment/providers/platforms/index.js';
+import { getDeploymentProvider } from '../deployment/index.js';
 import { extractArtifact } from '../artifact/engine.js';
 import { createLogger } from '../logger/index.js';
 import fs from 'fs-extra';
@@ -10,48 +10,15 @@ import path from 'path';
  * @param {string} artifactDir
  * @param {string} envName
  */
-async function rollbackPlatformTarget(config, artifactDir, envName) {
+async function rollbackTarget(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 log = createLogger('rollback');
+  log.info(`Rolling back ${envName} (${envConfig.type || 'server'})...`);
 
-  const { getDeploymentProvider } = await import('../deployment/index.js');
   const provider = getDeploymentProvider(envConfig.type, config, envName);
   await provider.rollback(artifactDir);
 }
@@ -90,9 +57,9 @@ export async function rollbackToVersion(config, version, cwd = process.cwd()) {
     return artifactDir;
   }
 
-  log.info('Executing platform-specific rollback from deployment.json...');
+  log.info('Redeploying previous artifact to server targets...');
   for (const envName of targets) {
-    await rollbackPlatformTarget(config, artifactDir, envName);
+    await rollbackTarget(config, artifactDir, envName);
   }
 
   log.success(`Rollback to v${version} complete`);

package/src/utils/github-actions.js

@@ -1,11 +1,5 @@
 import fs from 'fs-extra';
 import path from 'path';
-import {
-  PLATFORM_ENV_MAP,
-  PLATFORM_CLI_MAP,
-  PLATFORM_CHOICES,
-  getPlatformEnvExample,
-} from './platform-env.js';
 import { getWorkflowHeaderComment } from './author.js';
 
 /** @typedef {'aws'|'azure'|'gcp'|'gdrive'|'dropbox'|'local'|'ftp'|'ssh'} ProviderEnvKey */
@@ -47,10 +41,6 @@ const PROVIDER_LABELS = {
   ssh: 'SSH Deployment',
 };
 
-const PLATFORM_LABELS = Object.fromEntries(
-  PLATFORM_CHOICES.map(({ name, value }) => [value, name])
-);
-
 const ENV_VAR_DEFAULTS = {
   AWS_REGION: 'us-east-1',
   FTP_PORT: '21',
@@ -208,54 +198,6 @@ function getBackendSetupSteps(config) {
   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
@@ -285,11 +227,9 @@ export function generateWorkflowYaml(
     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} }}`);
-      }
+    const keys = PROVIDER_ENV_MAP[env.type] || [];
+    for (const key of keys) {
+      envVars.add(`${key}: \${{ secrets.${key} }}`);
     }
 
     if (env.type === 'ssh' && config) {
@@ -302,10 +242,6 @@ export function generateWorkflowYaml(
     }
   }
 
-  for (const line of collectPlatformEnvVars(deployEnvironments, environments)) {
-    envVars.add(line);
-  }
-
   const envBlock = Array.from(envVars)
     .map((line) => `          ${line}`)
     .join('\n');
@@ -317,11 +253,6 @@ export function generateWorkflowYaml(
     ? `${getGithubGitConfigStep()}\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'
@@ -342,7 +273,7 @@ ${uniqueBackendSteps ? `${uniqueBackendSteps}\n` : ''}      - uses: actions/setu
           node-version: '20'
 ${githubGitConfigStep}      - name: Install project dependencies
         run: ${installDepsCommand}
-${platformSteps ? `${platformSteps}\n` : ''}      - name: Install DeployHub CLI
+      - name: Install DeployHub CLI
         run: npm install ${installSpec} --no-save
       - run: ${getCliBuildCommand()}
         env:
@@ -481,16 +412,8 @@ export function getRequiredSecrets(
     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));
-    }
+    const keys = PROVIDER_ENV_MAP[env.type] || [];
+    keys.forEach((k) => secrets.add(k));
 
     if (env.type === 'ssh' && config) {
       const projectType = config.projectType || 'frontend';
@@ -560,19 +483,6 @@ export function generateEnvExampleContent(
     const env = environments[envName];
     if (!env) continue;
 
-    if (env.deploymentType === 'platform' || env.frontendDeploymentType === 'platform') {
-      const platform = env.platform;
-      if (platform) {
-        const examples = getPlatformEnvExample(platform);
-        addSection(
-          PLATFORM_LABELS[platform] || platform,
-          Object.keys(examples),
-          examples
-        );
-      }
-      continue;
-    }
-
     const keys = PROVIDER_ENV_MAP[env.type] || [];
     if (keys.length > 0) {
       addSection(PROVIDER_LABELS[env.type] || env.type, keys);

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

@@ -1,167 +0,0 @@
-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,
-};