@akash-chowdhury-24/deployhub 2.0.4 → 2.0.6

package/src/utils/kubernetes-manifests.js

@@ -0,0 +1,168 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * @param {string} name
+ * @returns {string}
+ */
+export function sanitizeK8sName(name) {
+  const sanitized = String(name)
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 63);
+  return sanitized || 'app';
+}
+
+/**
+ * @param {string} cwd
+ * @returns {Promise<boolean>}
+ */
+export async function hasKubernetesManifests(cwd) {
+  if (await fs.pathExists(path.join(cwd, 'k8s'))) {
+    return true;
+  }
+
+  let files = [];
+  try {
+    files = await fs.readdir(cwd);
+  } catch {
+    return false;
+  }
+
+  for (const file of files) {
+    if (!/\.ya?ml$/i.test(file)) continue;
+    const content = await fs.readFile(path.join(cwd, file), 'utf-8');
+    if (/^\s*apiVersion:/m.test(content) && /^\s*kind:/m.test(content)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * @param {object} options
+ * @param {string} options.appName
+ * @param {string} options.imageName
+ * @param {string} [options.imageTag]
+ * @param {number} options.port
+ * @param {string} options.namespace
+ * @param {string} [options.imagePullSecret]
+ * @returns {{ deploymentYaml: string, serviceYaml: string }}
+ */
+export function generateKubernetesManifests({
+  appName,
+  imageName,
+  imageTag = 'latest',
+  port,
+  namespace,
+  imagePullSecret = '',
+}) {
+  const name = sanitizeK8sName(appName);
+  const image = imageName.includes(':') ? imageName : `${imageName}:${imageTag}`;
+  const pullSecretBlock = imagePullSecret
+    ? `      imagePullSecrets:\n      - name: ${imagePullSecret}\n`
+    : '';
+
+  const deploymentYaml = `apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: ${name}
+  namespace: ${namespace}
+spec:
+  # Adjust replica count as needed
+  replicas: 1
+  selector:
+    matchLabels:
+      app: ${name}
+  template:
+    metadata:
+      labels:
+        app: ${name}
+    spec:
+${pullSecretBlock}      containers:
+      - name: ${name}
+        image: ${image}
+        ports:
+        - containerPort: ${port}
+        resources:
+          requests:
+            memory: "128Mi"
+            cpu: "100m"
+          limits:
+            memory: "512Mi"
+            cpu: "500m"
+`;
+
+  const servicePort = port === 80 ? 80 : 80;
+  const targetPort = port;
+
+  const serviceYaml = `apiVersion: v1
+kind: Service
+metadata:
+  name: ${name}
+  namespace: ${namespace}
+spec:
+  type: ClusterIP
+  selector:
+    app: ${name}
+  ports:
+  - port: ${servicePort}
+    targetPort: ${targetPort}
+`;
+
+  return { deploymentYaml, serviceYaml };
+}
+
+/**
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {Record<string, Record<string, unknown>>} [environments]
+ * @returns {{ appName: string, imageName: string, imageTag: string, port: number, namespace: string, imagePullSecret: string }}
+ */
+export function resolveKubernetesManifestOptions(config, environments = {}) {
+  const envList = Object.values(environments);
+  const k8sEnv = envList.find((env) => env.type === 'kubernetes') || {};
+
+  const appName = config.project || 'app';
+  const imageName =
+    /** @type {string} */ (k8sEnv.dockerImageName) ||
+    process.env.DOCKER_IMAGE_NAME ||
+    appName;
+  const imageTag =
+    process.env.DOCKER_IMAGE_TAG || config.version || 'latest';
+  const namespace =
+    /** @type {string} */ (k8sEnv.kubeNamespace) ||
+    process.env.KUBE_NAMESPACE ||
+    appName ||
+    'default';
+  const imagePullSecret =
+    /** @type {string} */ (k8sEnv.kubeImagePullSecret) ||
+    process.env.KUBE_IMAGE_PULL_SECRET ||
+    '';
+
+  let port = 3000;
+  if (config.projectType === 'both' && config.backend?.port) {
+    port = config.backend.port;
+  } else if (config.port) {
+    port = config.port;
+  } else if (config.backend?.port) {
+    port = config.backend.port;
+  }
+
+  return {
+    appName,
+    imageName,
+    imageTag,
+    port,
+    namespace,
+    imagePullSecret,
+  };
+}
+
+export default {
+  sanitizeK8sName,
+  hasKubernetesManifests,
+  generateKubernetesManifests,
+  resolveKubernetesManifestOptions,
+};

package/src/utils/scaffold.js

@@ -0,0 +1,231 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import {
+  generateDockerfile,
+  generateDockerignore,
+  getDockerfileFrameworkLabel,
+  resolveDockerSettings,
+} from './dockerfile.js';
+import {
+  generateKubernetesManifests,
+  hasKubernetesManifests,
+  resolveKubernetesManifestOptions,
+} from './kubernetes-manifests.js';
+
+/**
+ * @param {Record<string, Record<string, unknown>>} environments
+ * @returns {Set<string>}
+ */
+export function getDeployTypes(environments) {
+  return new Set(
+    Object.values(environments)
+      .map((env) => /** @type {string} */ (env.type))
+      .filter(Boolean)
+  );
+}
+
+/**
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {Record<string, Record<string, unknown>>} [environments]
+ */
+export function needsDockerfile(config, environments = config.environments || {}) {
+  const deployTypes = getDeployTypes(environments);
+  return deployTypes.has('docker') || deployTypes.has('kubernetes');
+}
+
+/**
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {Record<string, Record<string, unknown>>} [environments]
+ */
+export function needsKubernetesManifests(
+  config,
+  environments = config.environments || {}
+) {
+  return getDeployTypes(environments).has('kubernetes');
+}
+
+/**
+ * @param {string} cwd
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {{ silent?: boolean }} [options]
+ * @returns {Promise<{ generated: boolean }>}
+ */
+export async function ensureDockerignore(cwd, config, options = {}) {
+  const dockerignorePath = path.join(cwd, '.dockerignore');
+  if (await fs.pathExists(dockerignorePath)) {
+    return { generated: false };
+  }
+
+  if (!needsDockerfile(config)) {
+    return { generated: false };
+  }
+
+  await fs.writeFile(dockerignorePath, generateDockerignore(config));
+
+  if (!options.silent) {
+    console.log(
+      chalk.yellow(
+        'No .dockerignore found — generated one at ./.dockerignore to keep node_modules and build caches out of the Docker build context.'
+      )
+    );
+  }
+
+  return { generated: true };
+}
+
+/**
+ * @param {string} cwd
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {{ silent?: boolean }} [options]
+ * @returns {Promise<{ generated: boolean, framework?: string, dockerignoreGenerated?: boolean }>}
+ */
+export async function ensureDockerfile(cwd, config, options = {}) {
+  const dockerfilePath = path.join(cwd, 'Dockerfile');
+  let generated = false;
+  /** @type {string|undefined} */
+  let framework;
+
+  if (!(await fs.pathExists(dockerfilePath)) && needsDockerfile(config)) {
+    const settings = resolveDockerSettings(config);
+    const content = generateDockerfile(config);
+    await fs.writeFile(dockerfilePath, content);
+    generated = true;
+    framework = settings.framework;
+
+    if (!options.silent) {
+      const label = getDockerfileFrameworkLabel(settings.framework);
+      console.log(
+        chalk.yellow(
+          `No Dockerfile found — generated a starter Dockerfile at ./Dockerfile based on your detected ${label}. Review it before deploying, especially the exposed port and start command.`
+        )
+      );
+    }
+  }
+
+  // Always pair Dockerfile generation path with .dockerignore (never overwrite existing)
+  const dockerignoreResult = await ensureDockerignore(cwd, config, options);
+
+  return {
+    generated,
+    framework,
+    dockerignoreGenerated: dockerignoreResult.generated,
+  };
+}
+
+/**
+ * @param {string} cwd
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {Record<string, Record<string, unknown>>} [environments]
+ * @param {{ silent?: boolean }} [options]
+ * @returns {Promise<{ generated: boolean }>}
+ */
+export async function ensureKubernetesManifests(
+  cwd,
+  config,
+  environments = config.environments || {},
+  options = {}
+) {
+  if (!needsKubernetesManifests(config, environments)) {
+    return { generated: false };
+  }
+
+  if (await hasKubernetesManifests(cwd)) {
+    return { generated: false };
+  }
+
+  const manifestOptions = resolveKubernetesManifestOptions(config, environments);
+  const { deploymentYaml, serviceYaml } = generateKubernetesManifests(manifestOptions);
+
+  const k8sDir = path.join(cwd, 'k8s');
+  await fs.ensureDir(k8sDir);
+  await fs.writeFile(path.join(k8sDir, 'deployment.yaml'), deploymentYaml);
+  await fs.writeFile(path.join(k8sDir, 'service.yaml'), serviceYaml);
+
+  if (!options.silent) {
+    console.log(
+      chalk.yellow(
+        'No Kubernetes manifests found — generated starter manifests at ./k8s/deployment.yaml and ./k8s/service.yaml. Review resource limits, replica count, and any environment-specific settings before deploying.'
+      )
+    );
+  }
+
+  return { generated: true };
+}
+
+/**
+ * @param {string} cwd
+ * @param {import('../core/config.js').DeployHubConfig} config
+ * @param {Record<string, Record<string, unknown>>} [environments]
+ * @param {{ silent?: boolean }} [options]
+ * @returns {Promise<{ dockerfile: boolean, kubernetes: boolean }>}
+ */
+export async function ensureDeployScaffold(
+  cwd,
+  config,
+  environments = config.environments || {},
+  options = {}
+) {
+  const dockerResult = await ensureDockerfile(cwd, config, options);
+  const k8sResult = await ensureKubernetesManifests(cwd, config, environments, options);
+  return {
+    dockerfile: dockerResult.generated,
+    dockerignore: Boolean(dockerResult.dockerignoreGenerated),
+    kubernetes: k8sResult.generated,
+  };
+}
+
+/**
+ * @param {string} srcDir
+ * @param {string} destDir
+ */
+export async function copyKubernetesManifestsIfPresent(srcDir, destDir) {
+  const k8sSrc = path.join(srcDir, 'k8s');
+  if (await fs.pathExists(k8sSrc)) {
+    await fs.copy(k8sSrc, path.join(destDir, 'k8s'));
+    return;
+  }
+
+  let files = [];
+  try {
+    files = await fs.readdir(srcDir);
+  } catch {
+    return;
+  }
+
+  for (const file of files) {
+    if (!/\.ya?ml$/i.test(file)) continue;
+    const srcFile = path.join(srcDir, file);
+    const content = await fs.readFile(srcFile, 'utf-8');
+    if (/^\s*apiVersion:/m.test(content) && /^\s*kind:/m.test(content)) {
+      await fs.copy(srcFile, path.join(destDir, file));
+    }
+  }
+}
+
+/**
+ * Copy deploy-time assets from staging into artifactDir (alongside artifact.zip).
+ * @param {string} stagingDir
+ * @param {string} artifactDir
+ */
+export async function copyDeployAssetsToArtifactDir(stagingDir, artifactDir) {
+  for (const file of ['Dockerfile', 'docker-compose.yml']) {
+    const src = path.join(stagingDir, file);
+    if (await fs.pathExists(src)) {
+      await fs.copy(src, path.join(artifactDir, file));
+    }
+  }
+
+  await copyKubernetesManifestsIfPresent(stagingDir, artifactDir);
+}
+
+export default {
+  ensureDockerfile,
+  ensureDockerignore,
+  ensureKubernetesManifests,
+  ensureDeployScaffold,
+  needsDockerfile,
+  needsKubernetesManifests,
+  copyKubernetesManifestsIfPresent,
+  copyDeployAssetsToArtifactDir,
+};