elestio 1.0.2 → 1.1.0

package/src/payloads/pipeline.js

@@ -0,0 +1,191 @@
+import { RUNTIME_PRESETS } from '../constants.js';
+import { EMPTY_LIFECYCLE } from '../templates/elestio-config.js';
+
+/**
+ * Builders for POST /api/cicd/createCiCdExistServer.
+ *
+ * The endpoint takes the dashboard's whole form state, so most of this file is
+ * the inert scaffolding it expects. Keep it in one place: every divergence
+ * between what we send and what the dashboard sends has produced a 500.
+ */
+
+export function emptyGitUserFormData() {
+  return {
+    selectedUser: '', searchGitUser: '',
+    gitOrgsFilteredList: { GITHUB: [], GITLAB: [] },
+    gitOrgsList: [], selectedRepo: {},
+    thirdPartyRepoInput: '', gitScopesUsers: [],
+    thirdPartyRepoScopeName: '',
+    getGitScopeUser: { GITHUB: [], GITLAB: [] },
+    thirdPartyRepoName: '', thirdPartyRepoPrivate: false,
+    loadSearch: false
+  };
+}
+
+export function defaultPorts(targetPort = 3001) {
+  return [{
+    protocol: 'HTTPS', targetProtocol: 'HTTP', listeningPort: '443',
+    targetPort: String(targetPort), public: true, targetIP: '172.17.0.1',
+    path: '/', isAuth: false, login: '', password: '', loginTitle: ''
+  }];
+}
+
+export function defaultExposedPorts(hostPort = '3000', containerPort = '3000') {
+  return [{ protocol: 'HTTP', hostPort: String(hostPort), containerPort: String(containerPort), interface: '172.17.0.1' }];
+}
+
+/**
+ * @param {object} opts
+ * @param {object} opts.target          CI/CD target, from resolveCicdTarget()
+ * @param {string} opts.projectId
+ * @param {string} opts.pipelineName
+ * @param {string} opts.cicdMode        GITHUB | GITLAB | DockerCompose
+ * @param {object} [opts.gitData]
+ * @param {object} [opts.imageData]
+ * @param {object} [opts.configData]
+ * @param {Array}  [opts.ports]
+ * @param {Array}  [opts.exposedPorts]
+ * @param {string} [opts.variables]     newline-separated KEY=VALUE, never an array
+ * @param {object} [opts.lifeCycleCommand]
+ * @param {Array}  [opts.copyCommandConfig]
+ * @param {string|null} [opts.authID]
+ * @param {boolean} [opts.isPublicGitRepo]
+ * @param {boolean} [opts.isNeedToCreateRepo]
+ */
+export function buildPipelinePayload(opts) {
+  const {
+    target, projectId, pipelineName, cicdMode,
+    gitData = {}, imageData = {}, configData = {},
+    ports, exposedPorts, variables = '',
+    lifeCycleCommand = {}, copyCommandConfig = [],
+    authID = null, isPublicGitRepo = false, isNeedToCreateRepo = false
+  } = opts;
+
+  if (!target) throw new Error('A CI/CD target is required');
+  if (!projectId) throw new Error('Project ID is required');
+  if (!pipelineName) throw new Error('Pipeline name is required');
+
+  return {
+    cluster: { isCluster: false, createNew: false, target },
+    gitData,
+    imageData,
+    configData: {
+      buildDir: configData.buildDir || '/',
+      rootDir: configData.rootDir || '/',
+      runTime: configData.runTime || 'NodeJs',
+      buildCmd: configData.buildCmd || '',
+      runCmd: configData.runCmd || '',
+      installCmd: configData.installCmd || '',
+      framework: configData.framework || 'NoFramework',
+      version: configData.version === undefined || configData.version === null ? '' : String(configData.version)
+    },
+    ports: ports && ports.length > 0 ? ports : defaultPorts(),
+    // The backend runs variables.trim(); anything but a string is a 500.
+    variables: typeof variables === 'string' ? variables : '',
+    isPublicGitRepo,
+    exposedPorts: exposedPorts && exposedPorts.length > 0 ? exposedPorts : defaultExposedPorts(),
+    gitVolumeConfig: [{}],
+    isNeedToCreateRepo,
+    gitUserFormData: emptyGitUserFormData(),
+    lifeCycleCommand: { ...EMPTY_LIFECYCLE, ...lifeCycleCommand },
+    monoRepoWorkSpaces: [''],
+    copyCommandConfig,
+    CICDMode: cicdMode,
+    projectID: String(projectId),
+    pipelineName,
+    isMovePipeline: false,
+    authID: authID === null || authID === undefined ? null : String(authID)
+  };
+}
+
+/**
+ * Pipeline running a Git repo, configured from the repo's elestio.yml when it
+ * has one and from the runtime preset otherwise.
+ */
+export function buildGitPipelinePayload({
+  target, projectId, pipelineName, gitType, repo, branch, repoID,
+  elestioConfig, authID, isPublicGitRepo, isNeedToCreateRepo, appType = 'static', overrides = {}
+}) {
+  const preset = RUNTIME_PRESETS[appType] || RUNTIME_PRESETS.static;
+  const gitHost = gitType === 'GITLAB' ? 'gitlab.com' : 'github.com';
+  const repoName = repo.split('/')[1];
+  const fromFile = elestioConfig && elestioConfig.hasConfig ? elestioConfig : null;
+
+  const configData = {
+    runTime: overrides.runTime || fromFile?.config.runTime || preset.runtime,
+    version: overrides.nodeVersion ?? fromFile?.config.version ?? preset.version,
+    framework: overrides.framework || fromFile?.config.framework || preset.framework,
+    buildDir: overrides.buildDir || fromFile?.config.buildDir || preset.buildDir,
+    rootDir: overrides.rootDir || fromFile?.config.rootDir || '/',
+    buildCmd: overrides.buildCmd ?? fromFile?.config.buildCmd ?? preset.buildCmd,
+    runCmd: overrides.runCmd ?? fromFile?.config.runCmd ?? preset.runCmd,
+    installCmd: overrides.installCmd ?? fromFile?.config.installCmd ?? preset.installCmd
+  };
+
+  return buildPipelinePayload({
+    target, projectId, pipelineName,
+    cicdMode: gitType,
+    gitData: {
+      projectName: pipelineName,
+      branch,
+      repoUrl: `https://${gitHost}/${repo}`,
+      cloneUrl: `https://${gitHost}/${repo}.git`,
+      repoID: repoID === undefined || repoID === null ? '' : String(repoID),
+      repo: repoName,
+      ...(isNeedToCreateRepo ? { createFromTemplate: true, gitTemplateName: repoName } : {})
+    },
+    imageData: { isPipelineTemplate: false },
+    configData,
+    ports: overrides.ports || fromFile?.ports,
+    exposedPorts: overrides.exposedPorts || fromFile?.exposedPorts,
+    variables: overrides.variables ?? fromFile?.variables ?? '',
+    lifeCycleCommand: fromFile?.lifeCycleCommand,
+    copyCommandConfig: fromFile?.copyCommandConfig || [],
+    authID,
+    isPublicGitRepo: !!isPublicGitRepo,
+    isNeedToCreateRepo: !!isNeedToCreateRepo
+  });
+}
+
+/**
+ * Pipeline running an inline docker-compose file, with no Git repo attached.
+ *
+ * Lifecycle hooks are deliberately dropped. There is no checkout, so the paths
+ * in elestio.yml do not exist, and the deployment agent chmods them before it
+ * runs anything: sending them fails the build with
+ * "chmod: cannot access './scripts/preInstall.sh'" before docker compose is
+ * even reached. Sending none lets the stack come up.
+ */
+export function buildComposePipelinePayload({
+  target, projectId, pipelineName, compose, elestioConfig, overrides = {}
+}) {
+  if (!compose) throw new Error('A docker-compose file is required for DockerCompose mode');
+  const fromFile = elestioConfig && elestioConfig.hasConfig ? elestioConfig : null;
+
+  return buildPipelinePayload({
+    target, projectId, pipelineName,
+    cicdMode: 'DockerCompose',
+    gitData: {},
+    imageData: { isPrivate: false, compose, dockerExample: '', repoName: 'CustomDocker' },
+    configData: {
+      runTime: 'NodeJs', framework: 'NoFramework', version: '20',
+      buildDir: '/', rootDir: '/', buildCmd: '', runCmd: '', installCmd: ''
+    },
+    ports: overrides.ports || fromFile?.ports,
+    exposedPorts: overrides.exposedPorts || fromFile?.exposedPorts,
+    variables: overrides.variables ?? fromFile?.variables ?? '',
+    lifeCycleCommand: {},
+    copyCommandConfig: fromFile?.copyCommandConfig || [],
+    authID: null,
+    isPublicGitRepo: false,
+    isNeedToCreateRepo: false
+  });
+}
+
+export const DEFAULT_COMPOSE = `services:
+  nginx:
+    image: nginx:alpine
+    ports:
+      - "172.17.0.1:3000:80"
+    volumes:
+      - ./html:/usr/share/nginx/html:ro`;

package/src/payloads/server.js

@@ -0,0 +1,130 @@
+import {
+  CLUSTER_MAX_NODES, CLUSTER_MODES, CICD_MODES,
+  minClusterNodes, supportsClustering, supportsMultiMaster
+} from '../constants.js';
+
+/**
+ * Builder and validation for POST /api/servers/createServer.
+ *
+ * Cluster deployments differ from single services by three fields only
+ * (serviceType, clusterNodes, isReplica) -- but getting them wrong bills VMs
+ * before the API rejects the request, so everything is validated upfront.
+ */
+
+/**
+ * @param {object} cluster
+ * @param {boolean} cluster.enabled
+ * @param {string}  cluster.mode   primary-replica | multi-master
+ * @param {number}  cluster.nodes  total nodes, primary included
+ * @param {object}  template       catalog template, needs at least { id, title }
+ * @returns {{nodes: number, isReplica: boolean, mode: string}}
+ */
+export function validateClusterOptions(cluster, template) {
+  const templateId = Number(template.id);
+
+  if (!supportsClustering(template)) {
+    throw new Error(
+      `"${template.title}" does not support clustering. ` +
+      'Run "elestio clusters templates" to list the software that does.'
+    );
+  }
+
+  const mode = cluster.mode || 'primary-replica';
+  if (!CLUSTER_MODES.includes(mode)) {
+    throw new Error(`Unknown cluster mode "${mode}". Expected one of: ${CLUSTER_MODES.join(', ')}`);
+  }
+
+  if (mode === 'multi-master' && !supportsMultiMaster(templateId)) {
+    throw new Error(`"${template.title}" does not support multi-master; use --cluster-mode primary-replica`);
+  }
+
+  const min = minClusterNodes(templateId);
+  const nodes = cluster.nodes === undefined || cluster.nodes === null ? min : Number(cluster.nodes);
+
+  if (!Number.isInteger(nodes)) {
+    throw new Error(`--nodes must be a whole number, got "${cluster.nodes}"`);
+  }
+  if (nodes < min) {
+    throw new Error(
+      `"${template.title}" needs at least ${min} nodes` +
+      (min === 3 ? ' (quorum-based software requires an odd number of nodes)' : '')
+    );
+  }
+  if (nodes > CLUSTER_MAX_NODES) {
+    throw new Error(`A cluster cannot exceed ${CLUSTER_MAX_NODES} nodes, got ${nodes}`);
+  }
+
+  return { nodes, isReplica: mode === 'primary-replica', mode };
+}
+
+/**
+ * @param {object} opts see deployService() for where each value comes from
+ */
+export function buildCreateServerPayload(opts) {
+  const {
+    template, projectId, serverName, serverType, datacenter, provider,
+    support, adminEmail, version, serviceType, cluster = null,
+    pipelineName = null
+  } = opts;
+
+  const payload = {
+    templateID: String(template.id),
+    serverType,
+    datacenter,
+    providerName: provider,
+    serverName,
+    appid: 'Cloudxx',
+    data: 'data',
+    support,
+    projectId: String(projectId),
+    version,
+    adminEmail,
+    deploymentServiceType: 'normal',
+    serviceType
+  };
+
+  if (serviceType === 'CICD') {
+    payload.cicdPayload = buildCicdPayload(pipelineName || serverName, opts.cicdMode);
+  }
+
+  if (cluster) {
+    payload.serviceType = 'Cluster';
+    payload.clusterNodes = cluster.nodes;
+    payload.isReplica = cluster.isReplica;
+  }
+
+  return payload;
+}
+
+/**
+ * createServer rejects a CI/CD target whose cicdPayload is incomplete. It needs
+ * both a pipelineName and a CICDMode, and the name has its own rules that the
+ * API only reports after the request is on the wire.
+ */
+export function buildCicdPayload(pipelineName, cicdMode = 'DockerCompose') {
+  const name = String(pipelineName).replace(/\s/g, '').replaceAll('_', '-');
+
+  if (!/^[a-z0-9-]+$/.test(name) || name.length > 24) {
+    throw new Error(
+      `Invalid pipeline name "${pipelineName}". Use at most 24 characters, ` +
+      'lowercase letters, digits and hyphens only.'
+    );
+  }
+
+  if (!CICD_MODES.includes(cicdMode)) {
+    throw new Error(`Unknown CI/CD mode "${cicdMode}". Expected one of: ${CICD_MODES.join(', ')}`);
+  }
+
+  return { pipelineName: name, CICDMode: cicdMode };
+}
+
+/**
+ * Human-readable summary of what a cluster deployment will actually create,
+ * used by both --dry-run and the confirmation line.
+ */
+export function describeCluster(cluster) {
+  if (!cluster) return '1 node';
+  return cluster.isReplica
+    ? `1 primary + ${cluster.nodes - 1} replica${cluster.nodes - 1 === 1 ? '' : 's'} (${cluster.nodes} VMs)`
+    : `${cluster.nodes} primaries, multi-master (${cluster.nodes} VMs)`;
+}