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

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

import {
  ProjectTagConstants,
  getPackageInfo,
  hasProjectTag,
  isEqualProjectTag,
  setDefaultProjectTags
} from "./chunk-BLX33ZLH.mjs";
import {
  findWorkspaceRoot,
  getConfig
} from "./chunk-XLWMBELQ.mjs";

// src/plugins/docker/_dockerfile.ts
import {
  createNodesFromFiles,
  joinPathFragments,
  readJsonFile
} from "@nx/devkit";
import { existsSync } from "node:fs";
var name = "storm-software/docker";
var description = "Plugin for parsing Dockerfile files";
var createNodesV2 = [
  "*/**/{Dockerfile,Dockerfile.*}",
  async (configFiles, options, context) => {
    return await createNodesFromFiles(
      async (dockerFilePath, options2 = {
        defaultEngine: "docker"
      }, context2) => {
        try {
          if (!dockerFilePath) {
            return {};
          }
          const root = dockerFilePath.substring(
            dockerFilePath.lastIndexOf("/") + 1
          );
          const projectJsonPath = joinPathFragments(root, "project.json");
          if (!existsSync(projectJsonPath)) {
            return {};
          }
          const projectJson = readJsonFile(projectJsonPath);
          if (projectJson?.name) {
            return {};
          }
          const workspaceRoot = findWorkspaceRoot();
          const config = await getConfig(workspaceRoot);
          Object.keys(projectJson).forEach((key) => {
            if (!project[key]) {
              project[key] = projectJson[key];
            }
          });
          const project = {
            root,
            name: projectJson?.name
          };
          const engine = options2.defaultEngine ?? "docker";
          const labels = [
            `org.opencontainers.image.ref.name=${project.name}`,
            `org.opencontainers.image.title=${titleCase(project.name)}`,
            `org.opencontainers.image.authors=${config.organization ? titleCase(
              typeof config.organization === "string" ? config.organization : config.organization.name
            ) : "Storm Software"}`,
            `org.opencontainers.image.vendor=${config.organization ? titleCase(
              typeof config.organization === "string" ? config.organization : config.organization.name
            ) : "Storm Software"}`,
            `org.opencontainers.image.documentation=${config.docs}`,
            `org.opencontainers.image.url=${config.homepage}`,
            `org.opencontainers.image.source=${config.repository}`
          ];
          let tag = "latest";
          const packageManager = getPackageInfo(project);
          if (packageManager) {
            if (packageManager.type === "Cargo.toml") {
              tag = packageManager.content.package.version;
              labels.push(
                `org.opencontainers.image.description=${packageManager.content.package.description}`
              );
            } else if (packageManager.type === "package.json") {
              tag = packageManager.content.version;
              labels.push(
                `org.opencontainers.image.description=${packageManager.content.description}`
              );
            }
          }
          project.targets = {
            ...project.targets,
            container: {
              executor: "@nx-tools/nx-container:build",
              options: {
                file: dockerFilePath,
                engine,
                labels,
                push: true,
                platforms: ["linux/amd64"],
                metadata: {
                  images: [
                    `${config.namespace ? config.namespace : "storm-software"}/${project.name?.replace(`${config.namespace}-`, "")}`,
                    `ghcr.io/${(typeof config.organization === "string" ? config.organization : config.organization?.name) || "storm-software"}/${project.name}`
                  ],
                  tags: [
                    "type=schedule",
                    "type=ref,event=branch",
                    "type=ref,event=tag",
                    "type=ref,event=pr",
                    "type=semver,pattern={{version}}",
                    "type=semver,pattern={{major}}.{{minor}}",
                    "type=semver,pattern={{major}}",
                    "type=sha"
                  ]
                }
              },
              defaultConfiguration: "production",
              configurations: {
                development: {
                  quiet: false,
                  "build-args": [
                    "ENVIRONMENT=development",
                    "DEBUG_IMAGE=true",
                    `RELEASE=${tag}`
                  ]
                },
                production: {
                  quiet: true,
                  "build-args": [
                    "ENVIRONMENT=production",
                    "DEBUG_IMAGE=false",
                    `RELEASE=${tag}`
                  ]
                }
              }
            }
          };
          if ((isEqualProjectTag(
            project,
            ProjectTagConstants.ProjectType.TAG_ID,
            ProjectTagConstants.ProjectType.APPLICATION
          ) || project.projectType === "application") && hasProjectTag(project, ProjectTagConstants.Registry.TAG_ID)) {
            if (project.targets["nx-release-publish"]) {
              project.targets["nx-release-publish"] = {
                ...project.targets["nx-release-publish"],
                executor: "@storm-software/k8s-tools:container-publish",
                options: {
                  packageRoot: project.root
                }
              };
            } else {
              project.targets["nx-release-publish"] = {
                cache: true,
                inputs: [
                  "linting",
                  "testing",
                  "documentation",
                  "rust",
                  "^production"
                ],
                dependsOn: ["build", "^nx-release-publish"],
                executor: "@storm-software/k8s-tools:container-publish",
                options: {
                  packageRoot: project.root
                }
              };
            }
          }
          setDefaultProjectTags(project);
          const projects = {};
          const externalNodes = {};
          projects[project.root] = {
            ...project,
            release: {
              ...project.release,
              version: {
                ...project.release?.version,
                generator: "@storm-software/workspace-tools:release-version"
              }
            }
          };
          return {
            projects,
            externalNodes
          };
        } catch (e) {
          console.error(e);
          return {};
        }
      },
      configFiles,
      options,
      context
    );
  }
];
var titleCase = (input) => {
  if (!input) {
    return "";
  }
  return input.split(/(?=[A-Z])|[\.\-\s_]/).map((s) => s.trim()).filter((s) => !!s).map(
    (s) => s ? s.toLowerCase().charAt(0).toUpperCase() + s.toLowerCase().slice(1) : s
  ).join(" ");
};

export {
  name,
  description,
  createNodesV2
};