@storm-software/k8s-tools 0.28.2 → 0.29.0

package/src/generators/helm-dependency/generator.ts

@@ -1,135 +0,0 @@
-import {
-  formatFiles,
-  ProjectConfiguration,
-  readProjectConfiguration,
-  Tree,
-  updateProjectConfiguration
-} from "@nx/devkit";
-import { StormWorkspaceConfig } from "@storm-software/config";
-import { writeDebug } from "@storm-software/config-tools";
-import { withRunGenerator } from "@storm-software/workspace-tools/base/base-generator";
-import yaml from "js-yaml";
-import type { HelmDependencyGeneratorSchema } from "./schema";
-
-export async function helmDependencyGeneratorFn(
-  tree: Tree,
-  options: HelmDependencyGeneratorSchema,
-  config?: StormWorkspaceConfig
-) {
-  writeDebug("📝  Preparing to add Helm Dependency", config);
-
-  const project = readProjectConfiguration(tree, options.project);
-
-  if (!project.targets?.["helm-package"]) {
-    throw new Error(
-      `Project ${options.project} does not have a helm target. Please run the chart generator first.`
-    );
-  }
-
-  updateProjectConfiguration(
-    tree,
-    options.project,
-    addDependencyToConfig(project, options.repositoryName, options.repository)
-  );
-
-  updateChartYaml(
-    tree,
-    project,
-    options.chartName!,
-    options.chartVersion!,
-    options.repository
-  );
-
-  if (options.format) {
-    await formatFiles(tree);
-  }
-
-  return {
-    success: true
-  };
-}
-
-export default withRunGenerator<HelmDependencyGeneratorSchema>(
-  "Helm Dependency",
-  helmDependencyGeneratorFn
-);
-
-function addDependencyToConfig(
-  project: ProjectConfiguration,
-  name: string,
-  url: string
-): ProjectConfiguration {
-  return {
-    ...project,
-    targets: {
-      ...project.targets,
-      helm: {
-        ...project.targets?.["helm-package"],
-        options: {
-          ...project.targets?.["helm-package"]?.options,
-          dependencies: {
-            ...project.targets?.["helm-package"]?.options.dependencies,
-            repositories: project.targets?.["helm-package"]?.options
-              .dependencies.repositories
-              ? [
-                  ...project.targets["helm-package"].options.dependencies
-                    .repositories,
-                  { name: name, url: url }
-                ]
-              : [{ name: name, url: url }]
-          }
-        }
-      }
-    }
-  };
-}
-
-function updateChartYaml(
-  tree: Tree,
-  project: ProjectConfiguration,
-  name: string,
-  version: string,
-  repository: string
-) {
-  const chartFolder = project.targets?.["helm-package"]?.options.chartFolder;
-  const chartPath = `${chartFolder}/Chart.yaml`;
-
-  if (!tree.exists(chartPath)) {
-    throw new Error("Chart.yaml not found");
-  }
-
-  try {
-    const result = tree.read(chartPath, "utf8")?.toString();
-    if (!result) {
-      throw new Error("Failed to read Chart.yaml");
-    }
-
-    const chartContents = yaml.load(result) as {
-      dependencies: { name: string; version: string; repository: string }[];
-    };
-
-    if (!chartContents.dependencies) {
-      chartContents.dependencies = [];
-    }
-
-    const existingDependency = chartContents.dependencies.find(
-      dep => dep.name === name
-    );
-
-    if (existingDependency) {
-      existingDependency.version = version;
-      existingDependency.repository = repository;
-    } else {
-      chartContents.dependencies.push({
-        name: name,
-        version: version,
-        repository: repository
-      });
-
-      tree.write(chartPath, yaml.dump(chartContents));
-    }
-  } catch (error) {
-    console.error(error);
-    throw new Error("Failed to parse Chart.yaml");
-  }
-}

package/src/plugins/docker/_dockerfile.ts

@@ -1,225 +0,0 @@
-import {
-  CreateNodesContext,
-  joinPathFragments,
-  ProjectGraphExternalNode,
-  readJsonFile,
-  type CreateDependencies,
-  type CreateNodes,
-  type ProjectConfiguration,
-} from "@nx/devkit";
-import { getConfig } from "@storm-software/config-tools/get-config";
-import { findWorkspaceRoot } from "@storm-software/config-tools/utilities/find-workspace-root";
-import { getPackageInfo } from "@storm-software/workspace-tools/utils/package-helpers";
-import {
-  hasProjectTag,
-  isEqualProjectTag,
-  ProjectTagConstants,
-  setDefaultProjectTags,
-} from "@storm-software/workspace-tools/utils/project-tags";
-import { CargoToml } from "@storm-software/workspace-tools/utils/toml";
-import { existsSync } from "node:fs";
-import type { ExternalContainerExecutorSchema } from "../../executors/container-publish/schema";
-
-export const name = "storm-software/docker";
-export const description = "Plugin for parsing Dockerfile files";
-
-export interface DockerFilePluginOptions {
-  defaultEngine?: ExternalContainerExecutorSchema["engine"];
-}
-
-export const createNodes: CreateNodes<DockerFilePluginOptions> = [
-  "*/**/{Dockerfile,Dockerfile.*}",
-  async (
-    dockerFilePath: string,
-    opts: DockerFilePluginOptions = {
-      defaultEngine: "docker",
-    },
-    _: CreateNodesContext,
-  ) => {
-    if (!dockerFilePath) {
-      return {};
-    }
-
-    const root = dockerFilePath.substring(dockerFilePath.lastIndexOf("/") + 1);
-    const projectJsonPath = joinPathFragments(root, "project.json");
-    if (!existsSync(projectJsonPath)) {
-      return {};
-    }
-
-    const projectJson = readJsonFile<ProjectConfiguration>(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: ProjectConfiguration = {
-      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 = getPackageInfo(project);
-    if (packageManager) {
-      if (packageManager.type === "Cargo.toml") {
-        tag = (packageManager.content as CargoToml).package.version;
-        labels.push(
-          `org.opencontainers.image.description=${(packageManager.content as CargoToml).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 (
-      (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: Record<string, ProjectConfiguration> = {};
-    const externalNodes: Record<string, ProjectGraphExternalNode> = {};
-
-    projects[project.root] = {
-      ...project,
-      release: {
-        ...project.release,
-        version: {
-          ...project.release?.version,
-          generator: "@storm-software/workspace-tools:release-version",
-        },
-      },
-    };
-
-    return {
-      projects,
-      externalNodes,
-    };
-  },
-];
-
-export const createDependencies: CreateDependencies = (_, context) => {
-  return [];
-};
-
-const titleCase = (input?: string): string | undefined => {
-  if (!input) {
-    return "";
-  }
-
-  return (
-    input
-      // eslint-disable-next-line no-useless-escape
-      .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(" ")
-  );
-};

package/src/plugins/docker/index.ts

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

package/src/plugins/index.ts

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

package/src/types.ts

@@ -1,37 +0,0 @@
-import { Options } from "prettier";
-/** Types for the core library */
-
-/** Interface for objects that can be initialized */
-export interface Initializable {
-  initialized: boolean;
-  initialize(): Promise<void>;
-}
-
-/** Options for packaging a chart */
-export interface PackageOptions {
-  chartFolder: string;
-  outputFolder: string;
-}
-
-/** Options for pushing a chart */
-export interface PushOptions {
-  chartPath: string;
-  remote: string;
-}
-
-/** Abstract class for Helm */
-export abstract class AbstractHelmClient implements Initializable {
-  initialized = false;
-
-  abstract package(options: PackageOptions): Promise<string | undefined>;
-
-  async initialize(): Promise<void> {
-    throw new Error("Method not implemented.");
-  }
-}
-
-/** Represents an Prettier ignore file. */
-export interface PrettierConfig {
-  sourceFilepath: string;
-  config: Options;
-}

package/src/utils/client.ts

@@ -1,141 +0,0 @@
-import { execSync } from "node:child_process";
-import type { PackageOptions, PushOptions } from "../types";
-import { AbstractHelmClient } from "../types";
-import { ensureInitialized } from "./ensure-init";
-
-/** Helm wrapper class */
-export class HelmClient extends AbstractHelmClient {
-  /**
-   * Creates an instance of HelmClient
-   */
-  public constructor() {
-    super();
-  }
-
-  /**
-   * Package a chart directory into a chart archive
-   *
-   * @param {PackageOptions} [options]
-   */
-  @ensureInitialized
-  public package(options: PackageOptions): Promise<string | undefined> {
-    let chartPath: string | undefined = undefined;
-
-    let output = {} as any;
-    try {
-      output = this.runCommand([
-        "helm",
-        "package",
-        options.chartFolder,
-        "-d",
-        options.outputFolder,
-      ]);
-    } catch (err) {
-      if (err?.stderr.length > 0 && err?.exitCode !== 0) {
-        throw new Error(`Failed to package chart: ${err.stderr}`);
-      }
-    }
-
-    if (output?.stderr.length > 0 && output?.exitCode !== 0) {
-      throw new Error(`Failed to package chart: ${output.stderr}`);
-    }
-
-    const match = output.stdout?.match(
-      /Successfully packaged chart and saved it to: (.+)/,
-    );
-    if (!match || match.length < 2) {
-      throw new Error("Failed to parse chart path from helm output");
-    }
-
-    chartPath = match[1]?.trim();
-
-    return new Promise((resolve) => resolve(chartPath));
-  }
-
-  @ensureInitialized
-  public push(options: PushOptions) {
-    try {
-      this.runCommand(["helm", "push", options.chartPath, options.remote]);
-    } catch (err) {
-      if (err?.stderr.length > 0 && err?.exitCode !== 0) {
-        throw new Error(`Failed to push chart: ${err.stderr}`);
-      }
-    }
-  }
-
-  @ensureInitialized
-  public dependencyUpdate(chartFolder: string) {
-    try {
-      this.runCommand(["helm", "dependency", "update", chartFolder]);
-    } catch (err) {
-      if (err?.stderr.length > 0 && err?.exitCode !== 0) {
-        throw new Error(`Failed to update chart dependencies: ${err.stderr}`);
-      }
-    }
-  }
-
-  @ensureInitialized
-  public dependencyBuild(chartFolder: string) {
-    try {
-      this.runCommand(["helm", "dependency", "build", chartFolder]);
-    } catch (err) {
-      if (err?.stderr.length > 0 && err?.exitCode !== 0) {
-        throw new Error(`Failed to build chart dependencies: ${err.stderr}`);
-      }
-    }
-  }
-
-  @ensureInitialized
-  public addRepository(name: string, url: string) {
-    try {
-      this.runCommand(["helm", "repo", "add", name, url]);
-    } catch (err) {
-      if (err?.stderr.length > 0 && err?.exitCode !== 0) {
-        throw new Error(`Failed to add repository: ${err.stderr}`);
-      }
-    }
-  }
-
-  /**
-   * Initialize Helm
-   *
-   * @returns A promise
-   */
-  public override async initialize(): Promise<void> {
-    if (this.initialized) {
-      return;
-    }
-
-    try {
-      this.runCommand(["helm", "version"]);
-    } catch (err) {
-      if (err?.stderr.length > 0 && err?.exitCode !== 0) {
-        throw new Error(`Helm is not installed: ${err.stderr}`);
-      }
-    }
-
-    return new Promise<void>((resolve) => {
-      this.initialized = true;
-
-      resolve();
-    });
-  }
-
-  private runCommand(commands: string[]): string {
-    return execSync(commands.filter(Boolean).join(" "), {
-      encoding: "utf8",
-      windowsHide: true,
-      maxBuffer: 1024 * 1000000,
-      stdio: "pipe",
-    });
-  }
-}
-
-/**
- * Create a new Helm client instance
- *
- * @returns {HelmClient}
- */
-export const createHelmClient = (): HelmClient => {
-  return new HelmClient();
-};

package/src/utils/ensure-init.ts

@@ -1,37 +0,0 @@
-import { Initializable } from "../types";
-
-/**
- * Decorator to ensure the class is initialized before executing a method
- *
- * @param {any} target
- * @param {string} propertyKey
- * @param {PropertyDescriptor} descriptor
- * @returns {PropertyDescriptor}
- */
-export const ensureInitialized = (
-  target: any,
-  propertyKey: string,
-  descriptor: PropertyDescriptor,
-): PropertyDescriptor => {
-  const originalMethod = descriptor.value;
-  descriptor.value = async function (...arguments_: any[]) {
-    const self = this as Initializable;
-
-    if (
-      self.initialized === undefined ||
-      typeof self.initialize !== "function"
-    ) {
-      throw new TypeError(
-        `The ensureInitialized decorator can only be applied in classes with an 'initialized' property and 'initialize' method.`,
-      );
-    }
-
-    if (!self.initialized) {
-      await self.initialize();
-    }
-
-    return originalMethod.apply(this, arguments_);
-  };
-
-  return descriptor;
-};

package/src/utils/index.ts

@@ -1,3 +0,0 @@
-export * from "./client";
-export * from "./ensure-init";
-export * from "./prettier";

package/src/utils/prettier.ts

@@ -1,62 +0,0 @@
-import { Tree } from "@nx/devkit";
-import { PrettierConfig } from "../types";
-
-/**
- * Resolves the existing Prettier configuration.
- *
- * @returns The Prettier configuration or undefined if not found.
- */
-export async function resolveUserExistingPrettierConfig(): Promise<
-  PrettierConfig | undefined
-> {
-  let prettier: typeof import("prettier");
-  try {
-    prettier = require("prettier");
-  } catch {
-    return undefined;
-  }
-
-  if (!prettier) {
-    return undefined;
-  }
-  try {
-    const filepath = await prettier.resolveConfigFile();
-    if (!filepath) {
-      return undefined;
-    }
-
-    const config = await prettier.resolveConfig(process.cwd(), {
-      useCache: false,
-      config: filepath,
-    });
-    if (!config) {
-      return undefined;
-    }
-
-    return {
-      sourceFilepath: filepath,
-      config: config,
-    };
-  } catch {
-    return undefined;
-  }
-}
-
-export function addToPrettierIgnore(tree: Tree, ignore: string[]) {
-  const ignorePath = `${tree.root}/.prettierignore`;
-
-  if (!tree.exists(ignorePath)) {
-    tree.write(ignorePath, ignore.join("\n"));
-    return;
-  }
-
-  try {
-    const content = tree.read(ignorePath, "utf8") || "";
-    const lines = content.split("\n");
-    // Remove duplicates
-    const newContent = [...new Set([...lines, ...ignore])].join("\n");
-    tree.write(ignorePath, newContent);
-  } catch (error: unknown) {
-    throw new Error(`Failed to update .prettierignore file: ${String(error)}`);
-  }
-}

package/tsconfig.json

@@ -1,31 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
-    "rootDir": "../..",
-    "target": "ESNext",
-    "module": "ESNext",
-    "lib": ["ESNext"],
-    "skipLibCheck": true,
-    "skipDefaultLibCheck": true,
-    "moduleResolution": "Bundler",
-    "moduleDetection": "force",
-    "types": ["node"]
-  },
-  "include": [
-    "executors.ts",
-    "generators.ts",
-    "index.ts",
-    "src/**/*.ts",
-    "src/**/*.d.ts",
-    "src/**/*.json",
-    "tsup.config.ts"
-  ],
-  "exclude": [
-    "jest.config.ts",
-    "src/generators/**/files/**/*",
-    "src/**/untyped.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.test.ts"
-  ]
-}

package/tsup.config.ts

@@ -1,26 +0,0 @@
-import { defineConfig } from "tsup";
-
-export default defineConfig([
-  {
-    name: "k8s-tools",
-    target: "node22",
-    entryPoints: [
-      "./*.ts",
-      "./src/types.ts",
-      "./src/utils/*.ts",
-      "./src/executors/*/executor.ts",
-      "./src/generators/*/generator.ts",
-      "./src/plugins/docker/index.ts",
-    ],
-    outDir: "dist",
-    format: ["cjs", "esm"],
-    platform: "node",
-    splitting: true,
-    clean: true,
-    dts: true,
-    sourcemap: false,
-    shims: true,
-    tsconfig: "./tsconfig.json",
-    external: ["@storm-software/workspace-tools"],
-  },
-]);