@storm-software/k8s-tools/dist/chunk-U6GM7OXA.mjs

Tools for managing Kubernetes (k8s) infrastructure within a Nx workspace.

import {
  getPackageInfo
} from "./chunk-WS2G4IWW.mjs";
import {
  applyWorkspaceTokens
} from "./chunk-C4ZGS3L3.mjs";
import {
  findWorkspaceRoot,
  getConfig
} from "./chunk-TOP3LZ4E.mjs";

// src/executors/container-publish/executor.ts
import {
  parseTargetString,
  runExecutor
} from "@nx/devkit";

// ../workspace-tools/src/utils/apply-workspace-tokens.ts
var applyWorkspaceExecutorTokens = async (option, tokenizerOptions) => {
  let result = option;
  if (!result) {
    return result;
  }
  let projectName;
  let projectRoot;
  let sourceRoot;
  if (tokenizerOptions?.projectName) {
    const context = tokenizerOptions;
    projectName = context.projectName;
    projectRoot = context.root;
    sourceRoot = context.sourceRoot;
  } else {
    const projectConfig = tokenizerOptions;
    projectRoot = projectConfig.root;
    if (projectConfig.name) {
      projectName = projectConfig.name;
    }
    if (projectConfig.sourceRoot) {
      sourceRoot = projectConfig.sourceRoot;
    }
  }
  if (tokenizerOptions.config) {
    const configKeys = Object.keys(tokenizerOptions.config);
    if (configKeys.some((configKey) => result.includes(`{${configKey}}`))) {
      for (const configKey of configKeys) {
        if (result.includes(`{${configKey}}`)) {
          result = result.replaceAll(
            `{${configKey}}`,
            tokenizerOptions.config[configKey]
          );
        }
      }
    }
  }
  if (result.includes("{projectName}")) {
    result = result.replaceAll("{projectName}", projectName);
  }
  if (result.includes("{projectRoot}")) {
    result = result.replaceAll("{projectRoot}", projectRoot);
  }
  if (result.includes("{sourceRoot}")) {
    result = result.replaceAll("{sourceRoot}", sourceRoot);
  }
  if (result.includes("{workspaceRoot}")) {
    result = result.replaceAll(
      "{workspaceRoot}",
      tokenizerOptions.workspaceRoot ?? findWorkspaceRoot()
    );
  }
  return result;
};

// src/executors/container-publish/executor.ts
import https from "node:https";
async function* publishExecutor(options, context) {
  const isDryRun = process.env.NX_DRY_RUN === "true" || options.dryRun || false;
  if (!context.projectName) {
    throw new Error("The executor requires a projectName.");
  }
  console.info(
    `\u{1F680}  Running Storm Container Registry Publish executor on the ${context.projectName} crate`
  );
  const workspaceRoot = findWorkspaceRoot();
  const config = await getConfig(workspaceRoot);
  const projectConfig = context.projectsConfigurations?.projects[context.projectName];
  if (!projectConfig) {
    throw new Error(
      `The executor requires a valid projectsConfiguration - No configuration found for project ${context.projectName}`
    );
  }
  const projectRoot = projectConfig?.root ?? workspaceRoot;
  const sourceRoot = projectConfig?.sourceRoot ?? workspaceRoot;
  const projectName = projectConfig?.name ?? context.projectName;
  config.workspaceRoot = workspaceRoot;
  const tokenized = await applyWorkspaceTokens(
    options,
    {
      config,
      workspaceRoot,
      projectRoot,
      sourceRoot,
      projectName,
      ...projectConfig
    },
    applyWorkspaceExecutorTokens
  );
  tokenized.engine ??= "docker";
  tokenized.registry ??= config.registry.container;
  try {
    if (isDryRun) {
      console.log(
        `Would publish to ${tokenized.registry}, but [dry-run] was set`
      );
    } else {
      console.log(`Published to ${tokenized.registry}`);
      const packageManager = getPackageInfo(projectConfig);
      if (packageManager) {
        tokenized["build-args"] ??= [
          "ENVIRONMENT=production",
          "DEBUG_IMAGE=false"
        ];
        tokenized["labels"] ??= [];
        let version = "";
        if (process.env.TAG) {
          version = process.env.TAG;
        } else {
          if (packageManager.type === "Cargo.toml") {
            version = packageManager.content.package.version;
          } else if (packageManager.type === "package.json") {
            version = packageManager.content.version;
          }
        }
        tokenized["build-args"].push(`RELEASE=${version}`);
        tokenized["labels"].push(`org.opencontainers.image.version=${version}`);
        const tags = await getRegistryVersion(projectName, config);
        if (tags.length === 0) {
          tokenized["labels"].push(
            `org.opencontainers.image.created=${(/* @__PURE__ */ new Date()).toISOString()}`
          );
        } else if (tags.includes(version)) {
          console.warn(
            `Skipped package "${projectName}" because v${version} already exists in ${tokenized.registry}`
          );
          return {
            success: true
          };
        }
      } else {
        console.warn(
          `No package manager found for project "${projectName}" - Skipping container publishing`
        );
        return {
          success: true
        };
      }
      const { project, target, configuration } = parseTargetString(
        "container",
        context
      );
      for await (const output of await runExecutor({ project, target, configuration }, tokenized, context)) {
        if (!output.success) {
          throw new Error("Could not compile application files");
        }
        yield;
      }
    }
    return {
      success: true
    };
  } catch (error) {
    console.error(`Failed to publish to ${tokenized.registry}`);
    console.error(error);
    console.log("");
    return {
      success: false
    };
  }
}
var getRegistryVersion = (name, config) => {
  if (!name) {
    throw new Error(
      "The `getRegistryVersion` function requires a container name."
    );
  }
  try {
    const tagsApiUrl = `${config.registry.container}/v2/namespaces/${encodeURIComponent(config.namespace ? config.namespace : "storm-software")}/repositories/${encodeURIComponent(
      name.replace(`${config.namespace}-`, "")
    )}/tags`;
    console.log(`Checking for existing version at ${tagsApiUrl}`);
    return new Promise(
      (resolve, reject) => https.get(tagsApiUrl, (res) => {
        if (res.statusCode === 404) {
          console.log(`No existing version found at ${tagsApiUrl}`);
          return resolve([]);
        }
        res.on("data", (data) => {
          if (data) {
            console.log(
              `Existing versions found at ${tagsApiUrl} - ${data}`
            );
            const json = JSON.parse(data.toString());
            return resolve(
              json.results.filter(
                (result) => result.status === "active" && result.name && result.name !== "latest"
              ).map((result) => result.name)
            );
          }
          return reject(
            new Error(
              "No data returned from container registry, expected a 404 if no tags exist"
            )
          );
        });
      }).on("error", (e) => {
        throw e;
      })
    );
  } catch (error) {
    console.error(`Failed to get version from ${config.registry.container}`);
    console.error(error);
    console.log("");
    throw new Error(
      `Could not get version from container registry - ${config.registry.container}`,
      {
        cause: error
      }
    );
  }
};

export {
  publishExecutor,
  getRegistryVersion
};