@storm-software/k8s-tools 0.3.0 → 0.5.0

package/src/plugins/docker/index.js

@@ -0,0 +1,246 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/k8s-tools/src/plugins/docker/index.ts
+var docker_exports = {};
+__export(docker_exports, {
+  createDependencies: () => createDependencies,
+  createNodes: () => createNodes,
+  description: () => description,
+  name: () => name
+});
+module.exports = __toCommonJS(docker_exports);
+
+// packages/k8s-tools/src/plugins/docker/_dockerfile.ts
+var import_devkit2 = require("@nx/devkit");
+var import_project_tags2 = require("@storm-software/workspace-tools/utils/project-tags");
+var import_node_fs2 = require("node:fs");
+
+// packages/k8s-tools/src/utils/package-helpers.ts
+var import_devkit = require("@nx/devkit");
+var import_project_tags = require("@storm-software/workspace-tools/utils/project-tags");
+var import_toml = require("@storm-software/workspace-tools/utils/toml");
+var import_node_fs = require("node:fs");
+var getPackageManager = (project) => {
+  if ((0, import_project_tags.isEqualProjectTag)(
+    project,
+    import_project_tags.ProjectTagConstants.Language.TAG_ID,
+    import_project_tags.ProjectTagConstants.Language.RUST
+  ) && (0, import_node_fs.existsSync)((0, import_devkit.joinPathFragments)(project.root, "Cargo.toml"))) {
+    return {
+      type: "Cargo.toml",
+      content: (0, import_toml.parseCargoToml)((0, import_devkit.joinPathFragments)(project.root, "Cargo.toml"))
+    };
+  } else if ((0, import_project_tags.isEqualProjectTag)(
+    project,
+    import_project_tags.ProjectTagConstants.Language.TAG_ID,
+    import_project_tags.ProjectTagConstants.Language.TYPESCRIPT
+  ) && (0, import_node_fs.existsSync)((0, import_devkit.joinPathFragments)(project.root, "package.json"))) {
+    return {
+      type: "package.json",
+      content: (0, import_devkit.readJsonFile)(
+        (0, import_devkit.joinPathFragments)(project.root, "package.json")
+      )
+    };
+  }
+  return null;
+};
+
+// packages/k8s-tools/src/plugins/docker/_dockerfile.ts
+var name = "storm-software/docker/dockerfile";
+var description = "Plugin for parsing Dockerfile files";
+var createNodes = [
+  "*/**/{Dockerfile,Dockerfile.*}",
+  async (dockerFilePath, opts = {
+    defaultEngine: "docker"
+  }, _) => {
+    if (!dockerFilePath) {
+      return {};
+    }
+    const { loadStormConfig, findWorkspaceRoot } = await import("@storm-software/config-tools");
+    const root = dockerFilePath.substring(dockerFilePath.lastIndexOf("/") + 1);
+    const projectJsonPath = (0, import_devkit2.joinPathFragments)(root, "project.json");
+    if (!(0, import_node_fs2.existsSync)(projectJsonPath)) {
+      return {};
+    }
+    const projectJson = (0, import_devkit2.readJsonFile)(projectJsonPath);
+    if (projectJson?.name) {
+      return {};
+    }
+    const workspaceRoot = findWorkspaceRoot();
+    const config = await loadStormConfig(workspaceRoot);
+    Object.keys(projectJson).forEach((key) => {
+      if (!project[key]) {
+        project[key] = projectJson[key];
+      }
+    });
+    const project = {
+      root,
+      name: projectJson?.name
+    };
+    const engine = opts.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(config.organization) : "Storm Software"}`,
+      `org.opencontainers.image.vendor=${config.organization ? titleCase(config.organization) : "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 = getPackageManager(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/${config.organization ? config.organization : "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 (((0, import_project_tags2.isEqualProjectTag)(
+      project,
+      import_project_tags2.ProjectTagConstants.ProjectType.TAG_ID,
+      import_project_tags2.ProjectTagConstants.ProjectType.APPLICATION
+    ) || project.projectType === "application") && (0, import_project_tags2.hasProjectTag)(project, import_project_tags2.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
+          }
+        };
+      }
+    }
+    (0, import_project_tags2.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
+    };
+  }
+];
+var createDependencies = (_, context) => {
+  return [];
+};
+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(" ");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDependencies,
+  createNodes,
+  description,
+  name
+});

package/src/plugins/index.d.ts

@@ -0,0 +1 @@
+export * from "./docker";

package/src/utils/package-helpers.d.ts

@@ -0,0 +1,13 @@
+import { ProjectConfiguration } from "@nx/devkit";
+import { PackageJson } from "@storm-software/workspace-tools/executors/clean-package/types";
+import { CargoToml } from "@storm-software/workspace-tools/utils/toml";
+export type PackageManagerType = "package.json" | "Cargo.toml";
+export declare const PackageManagerTypes: {
+    PackageJson: PackageManagerType;
+    CargoToml: PackageManagerType;
+};
+export type PackageManager = {
+    content: PackageJson | CargoToml;
+    type: "package.json" | "Cargo.toml";
+};
+export declare const getPackageManager: (project: ProjectConfiguration) => null | PackageManager;