genesis-compiler 1.2.12 → 1.2.13

package/src/index/stack-deployment.js

@@ -1,259 +0,0 @@
-import { GenesisError } from './errors.js';
-import {
-  isCanonicalProjectWorkdir,
-  isSafeProcessExecutable,
-  parseBacktickedArguments,
-} from './stack-process.js';
-
-const RUNTIME_ID = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
-const STEP_LINE = /^- (Prepare|Build|Migrate|Serve) `([^`\r\n]+)`:[ \t]+(.+)$/u;
-const RESTORE_PATHS_PREFIX = '- Recreate on restore: ';
-const STEP_ROLE_ORDER = Object.freeze({
-  prepare: 0,
-  build: 1,
-  migrate: 2,
-  serve: 3,
-});
-
-function invalid(deploymentPath, message, line, details = {}) {
-  throw new GenesisError('STACK_DEPLOYMENT_INVALID', message, {
-    path: deploymentPath,
-    ...(line === undefined ? {} : { line }),
-    ...details,
-  });
-}
-
-function oneToken(source, prefix, deploymentPath, label, line) {
-  const values = parseBacktickedArguments(source.slice(prefix.length));
-  if (!values || values.length !== 1) {
-    invalid(deploymentPath, `${label} accepts exactly one backticked value.`, line);
-  }
-  return values[0];
-}
-
-function parseRuntimes(source, deploymentPath, line) {
-  const values = parseBacktickedArguments(source.slice('- Runtimes: '.length));
-  if (!values || values.some((value) => !RUNTIME_ID.test(value))) {
-    invalid(
-      deploymentPath,
-      'Deployment runtimes must be separate backticked technology ids.',
-      line,
-    );
-  }
-  if (new Set(values).size !== values.length) {
-    invalid(deploymentPath, 'Deployment contains a duplicate runtime.', line);
-  }
-  return values;
-}
-
-function parseDisposablePaths(source, deploymentPath, line) {
-  const values = parseBacktickedArguments(source.slice(RESTORE_PATHS_PREFIX.length));
-  if (!values || values.length === 0) {
-    invalid(
-      deploymentPath,
-      'Deployment Recreate on restore paths must be separate non-empty backticked values.',
-      line,
-    );
-  }
-  const normalized = values.map((value) => String(value || '').trim());
-  if (normalized.some((value) => (
-    !value
-    || value.startsWith('/')
-    || value.includes('\\')
-    || value.includes('***')
-    || /[?\[\]{}!]/u.test(value)
-    || value.split('/').some((segment) => !segment || ['.', '..'].includes(segment))
-  ))) {
-    invalid(
-      deploymentPath,
-      'Deployment Recreate on restore paths must be canonical project-relative globs using only * and ** wildcards.',
-      line,
-    );
-  }
-  if (new Set(normalized).size !== normalized.length) {
-    invalid(deploymentPath, 'Deployment contains a duplicate Recreate on restore path.', line);
-  }
-  return normalized;
-}
-
-function parseUrlPath(value, deploymentPath, line) {
-  const normalized = String(value || '').trim();
-  if (!normalized.startsWith('/') || normalized.startsWith('//') || /[\\?#]/u.test(normalized)) {
-    invalid(
-      deploymentPath,
-      'Deployment readiness path must begin with one slash and contain no query or fragment.',
-      line,
-    );
-  }
-  return normalized;
-}
-
-function parseReadiness(source, deploymentPath, line) {
-  const match = source.match(/^- Ready when: `GET` `([^`\r\n]+)` returns `([0-9]{3})`$/u);
-  if (!match) {
-    invalid(
-      deploymentPath,
-      'Deployment readiness must use `- Ready when: `GET` `/path` returns `200``.',
-      line,
-    );
-  }
-  const status = Number(match[2]);
-  if (!Number.isInteger(status) || status < 200 || status > 399) {
-    invalid(deploymentPath, 'Deployment readiness status must be from 200 through 399.', line);
-  }
-  return {
-    kind: 'http',
-    method: 'GET',
-    path: parseUrlPath(match[1], deploymentPath, line),
-    status,
-  };
-}
-
-function parseStep(match, deploymentPath, line) {
-  const label = match[2].trim();
-  const argv = parseBacktickedArguments(match[3]);
-  if (!label || /[\0\r\n]/u.test(label)) {
-    invalid(deploymentPath, 'Deployment step labels must be non-empty single lines.', line);
-  }
-  if (!argv || argv.some((value) => value.includes('\0')) || !isSafeProcessExecutable(argv[0])) {
-    invalid(
-      deploymentPath,
-      'Deployment command and arguments must be separate non-empty backticked values with a safe executable.',
-      line,
-    );
-  }
-  return {
-    label,
-    argv,
-    role: match[1].toLowerCase(),
-  };
-}
-
-export function parseStackDeploymentLines(lines, {
-  path: deploymentPath = 'stack deployment',
-} = {}) {
-  if (lines === undefined) return null;
-  const entries = lines.map((line) => line.trim()).filter(Boolean);
-  if (entries.length === 1 && entries[0] === '- Nothing.') {
-    return { version: 2, artifact: { disposablePaths: [] }, steps: [] };
-  }
-
-  const result = {
-    version: 2,
-    artifact: {
-      disposablePaths: [],
-    },
-    workdir: '.',
-    runtimeRequirements: [],
-    readiness: null,
-    steps: [],
-  };
-  const seen = new Set();
-  for (let index = 0; index < lines.length; index += 1) {
-    const source = lines[index].trim();
-    if (!source) continue;
-    const line = index + 1;
-    if (source.startsWith('- Workdir: ')) {
-      if (seen.has('workdir')) invalid(deploymentPath, 'Duplicate Deployment Workdir.', line);
-      seen.add('workdir');
-      const workdir = oneToken(source, '- Workdir: ', deploymentPath, 'Deployment Workdir', line);
-      if (!isCanonicalProjectWorkdir(workdir)) {
-        invalid(deploymentPath, 'Deployment workdir must be a canonical project-relative directory.', line);
-      }
-      result.workdir = workdir;
-      continue;
-    }
-    if (source.startsWith('- Runtimes: ')) {
-      if (seen.has('runtimes')) invalid(deploymentPath, 'Duplicate Deployment Runtimes.', line);
-      seen.add('runtimes');
-      result.runtimeRequirements = parseRuntimes(source, deploymentPath, line);
-      continue;
-    }
-    if (source.startsWith(RESTORE_PATHS_PREFIX)) {
-      if (seen.has('restore-paths')) {
-        invalid(deploymentPath, 'Duplicate Deployment Recreate on restore entry.', line);
-      }
-      seen.add('restore-paths');
-      result.artifact.disposablePaths = parseDisposablePaths(source, deploymentPath, line);
-      continue;
-    }
-    if (source.startsWith('- Ready when: ')) {
-      if (seen.has('readiness')) invalid(deploymentPath, 'Duplicate Deployment Ready when.', line);
-      seen.add('readiness');
-      result.readiness = parseReadiness(source, deploymentPath, line);
-      continue;
-    }
-    const step = source.match(STEP_LINE);
-    if (step) {
-      result.steps.push(parseStep(step, deploymentPath, line));
-      continue;
-    }
-    invalid(deploymentPath, `Unknown Deployment entry: ${source}.`, line);
-  }
-  if (result.steps.length === 0) {
-    invalid(deploymentPath, '## Deployment needs at least one command or exactly `- Nothing.`.');
-  }
-  const serveSteps = result.steps.filter(({ role }) => role === 'serve');
-  if (serveSteps.length !== 1 || result.steps.at(-1).role !== 'serve') {
-    invalid(deploymentPath, 'Deployment needs exactly one final Serve step.');
-  }
-  for (let index = 1; index < result.steps.length; index += 1) {
-    if (STEP_ROLE_ORDER[result.steps[index].role] < STEP_ROLE_ORDER[result.steps[index - 1].role]) {
-      invalid(
-        deploymentPath,
-        'Deployment steps must be ordered Prepare, Build, Migrate, then Serve.',
-      );
-    }
-  }
-  if (!result.readiness) {
-    invalid(deploymentPath, 'Deployment needs one Ready when entry.');
-  }
-  if (
-    result.artifact.disposablePaths.length > 0
-    && !result.steps.some(({ role }) => role === 'prepare')
-  ) {
-    invalid(
-      deploymentPath,
-      'Deployment may recreate paths on restore only when it declares a Prepare step.',
-    );
-  }
-  return result;
-}
-
-export function composeStackDeployment(components, projectDeployment) {
-  if (projectDeployment) return { ...projectDeployment, source: 'project', diagnostics: [] };
-  const declarations = components
-    .filter((component) => component.deployment?.steps?.length > 0)
-    .map((component) => ({
-      ...component.deployment,
-      source: `component:${component.id}`,
-    }));
-  if (declarations.length === 0) {
-    return {
-      version: 2,
-      artifact: { disposablePaths: [] },
-      workdir: '.',
-      runtimeRequirements: [],
-      readiness: null,
-      steps: [],
-      source: null,
-      diagnostics: [],
-    };
-  }
-  if (declarations.length === 1) return { ...declarations[0], diagnostics: [] };
-  const sources = declarations.map(({ source }) => source).sort();
-  return {
-    version: 2,
-    artifact: { disposablePaths: [] },
-    workdir: '.',
-    runtimeRequirements: [],
-    readiness: null,
-    steps: [],
-    source: null,
-    diagnostics: [{
-      code: 'STACK_DEPLOYMENT_AMBIGUOUS',
-      message: `Selected Stack components provide competing Deployment recipes: ${sources.join(', ')}. Add one project ## Deployment section to choose the exact recipe.`,
-      details: { sources },
-    }],
-  };
-}