kubernetes-fluent-client 3.5.6 → 3.6.1

package/src/cli.ts

@@ -5,10 +5,11 @@
 
 import { hideBin } from "yargs/helpers";
 import yargs from "yargs/yargs";
-import { GenerateOptions, generate } from "./generate";
-import { version } from "../package.json";
-import { postProcessing } from "./postProcessing";
-import { NodeFileSystem } from "./fileSystem"; // Import your new file system
+import { GenerateOptions, generate } from "./generate.js";
+import { postProcessing } from "./postProcessing.js";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const { version } = require("../package.json");
 
 void yargs(hideBin(process.argv))
   .version("version", "Display version number", `kubernetes-fluent-client v${version}`)
@@ -55,7 +56,6 @@ void yargs(hideBin(process.argv))
       opts.noPost = argv.noPost as boolean;
 
       // Use NodeFileSystem as the file system for post-processing
-      const fileSystem = new NodeFileSystem(); // Create an instance of NodeFileSystem
 
       if (!opts.noPost) {
         console.log("\n✅ Post-processing has been enabled.\n");
@@ -67,7 +67,7 @@ void yargs(hideBin(process.argv))
 
         // If noPost is false, run post-processing
         if (!opts.noPost) {
-          await postProcessing(allResults, opts, fileSystem); // Pass the file system to postProcessing
+          await postProcessing(allResults, opts); // Pass the file system to postProcessing
         }
       } catch (e) {
         console.log(`\n❌ ${e.message}`);

package/src/fluent/index.ts

@@ -6,14 +6,15 @@ import { Operation } from "fast-json-patch";
 import { StatusCodes } from "http-status-codes";
 import type { PartialDeep } from "type-fest";
 
-import { fetch } from "../fetch";
-import { modelToGroupVersionKind } from "../kinds";
-import { GenericClass } from "../types";
-import { ApplyCfg, FetchMethods, Filters, K8sInit, Paths, WatchAction } from "./types";
-import { k8sCfg, k8sExec } from "./utils";
-import { WatchCfg, Watcher } from "./watch";
-import { hasLogs } from "../helpers";
-import { Pod, type Service, type ReplicaSet } from "../upstream";
+import { fetch } from "../fetch.js";
+import { modelToGroupVersionKind } from "../kinds.js";
+import { GenericClass } from "../types.js";
+import { K8sInit, Paths } from "./types.js";
+import { Filters, WatchAction, FetchMethods, ApplyCfg } from "./shared-types.js";
+import { k8sCfg, k8sExec } from "./utils.js";
+import { WatchCfg, Watcher } from "./watch.js";
+import { hasLogs } from "../helpers.js";
+import { Pod, type Service, type ReplicaSet } from "../upstream.js";
 /**
  * Kubernetes fluent API inspired by Kubectl. Pass in a model, then call filters and actions on it.
  *
@@ -114,7 +115,7 @@ export function K8s<T extends GenericClass, K extends KubernetesObject = Instanc
     }
 
     try {
-      const object = await k8sExec<T, K>(model, filters, "GET");
+      const object = await k8sExec<T, K>(model, filters, FetchMethods.GET);
 
       if (kind !== "Pod") {
         if (kind === "Service") {
@@ -144,7 +145,7 @@ export function K8s<T extends GenericClass, K extends KubernetesObject = Instanc
 
     const podModel = { ...model, name: "V1Pod" };
     const logPromises = podList.map(po =>
-      k8sExec<T, string>(podModel, { ...filters, name: po.metadata!.name! }, "LOG"),
+      k8sExec<T, string>(podModel, { ...filters, name: po.metadata!.name! }, FetchMethods.LOG),
     );
 
     const responses = await Promise.all(logPromises);
@@ -179,7 +180,7 @@ export function K8s<T extends GenericClass, K extends KubernetesObject = Instanc
       filters.name = name;
     }
 
-    return k8sExec<T, K | KubernetesListObject<K>>(model, filters, "GET");
+    return k8sExec<T, K | KubernetesListObject<K>>(model, filters, FetchMethods.GET);
   }
 
   /**
@@ -195,7 +196,7 @@ export function K8s<T extends GenericClass, K extends KubernetesObject = Instanc
 
     try {
       // Try to delete the resource
-      await k8sExec<T, void>(model, filters, "DELETE");
+      await k8sExec<T, void>(model, filters, FetchMethods.DELETE);
     } catch (e) {
       // If the resource doesn't exist, ignore the error
       if (e.status === StatusCodes.NOT_FOUND) {
@@ -215,7 +216,7 @@ export function K8s<T extends GenericClass, K extends KubernetesObject = Instanc
     applyCfg: ApplyCfg = { force: false },
   ): Promise<K> {
     syncFilters(resource as K);
-    return k8sExec(model, filters, "APPLY", resource, applyCfg);
+    return k8sExec(model, filters, FetchMethods.APPLY, resource, applyCfg);
   }
 
   /**
@@ -224,7 +225,7 @@ export function K8s<T extends GenericClass, K extends KubernetesObject = Instanc
    */
   async function Create(resource: K): Promise<K> {
     syncFilters(resource);
-    return k8sExec(model, filters, "POST", resource);
+    return k8sExec(model, filters, FetchMethods.POST, resource);
   }
 
   /**
@@ -248,7 +249,7 @@ export function K8s<T extends GenericClass, K extends KubernetesObject = Instanc
         },
       };
       // Try to evict the resource
-      await k8sExec<T, void>(model, filters, "POST", evictionPayload);
+      await k8sExec<T, void>(model, filters, FetchMethods.POST, evictionPayload);
     } catch (e) {
       // If the resource doesn't exist, ignore the error
       if (e.status === StatusCodes.NOT_FOUND) {
@@ -268,7 +269,7 @@ export function K8s<T extends GenericClass, K extends KubernetesObject = Instanc
       throw new Error("No operations specified");
     }
 
-    return k8sExec(model, filters, "PATCH", payload);
+    return k8sExec(model, filters, FetchMethods.PATCH, payload);
   }
 
   /**
@@ -277,7 +278,7 @@ export function K8s<T extends GenericClass, K extends KubernetesObject = Instanc
    */
   async function PatchStatus(resource: PartialDeep<K>): Promise<K> {
     syncFilters(resource as K);
-    return k8sExec(model, filters, "PATCH_STATUS", resource);
+    return k8sExec(model, filters, FetchMethods.PATCH_STATUS, resource);
   }
 
   /**
@@ -292,7 +293,7 @@ export function K8s<T extends GenericClass, K extends KubernetesObject = Instanc
    * @inheritdoc
    * @see {@link K8sInit.Raw}
    */
-  async function Raw(url: string, method: FetchMethods = "GET") {
+  async function Raw(url: string, method: FetchMethods = FetchMethods.GET) {
     const thing = await k8sCfg(method);
     const { opts, serverUrl } = thing;
     const resp = await fetch<K>(`${serverUrl}${url}`, opts);

package/src/fluent/shared-types.ts

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Kubernetes Fluent Client Authors
+import { GenericClass, GroupVersionKind } from "../types.js";
+import { RequestInit } from "undici";
+import { KubernetesObject } from "@kubernetes/client-node";
+/**
+ * Fetch options and server URL
+ */
+export type K8sConfigPromise = Promise<{ opts: RequestInit; serverUrl: string | URL }>;
+
+/**
+ * The Phase matched when using the K8s Watch API.
+ */
+export enum WatchPhase {
+  Added = "ADDED",
+  Modified = "MODIFIED",
+  Deleted = "DELETED",
+  Bookmark = "BOOKMARK",
+  Error = "ERROR",
+}
+
+export type WatchAction<T extends GenericClass, K extends KubernetesObject = InstanceType<T>> = (
+  update: K,
+  phase: WatchPhase,
+) => Promise<void> | void;
+
+export interface Filters {
+  kindOverride?: GroupVersionKind;
+  fields?: Record<string, string>;
+  labels?: Record<string, string>;
+  name?: string;
+  namespace?: string;
+}
+
+/**
+ * Configuration for the apply function.
+ */
+export type ApplyCfg = {
+  /**
+   * Force the apply to be a create.
+   */
+  force?: boolean;
+};
+
+export enum FetchMethods {
+  APPLY = "APPLY",
+  DELETE = "DELETE",
+  GET = "GET",
+  LOG = "LOG",
+  PATCH = "PATCH",
+  PATCH_STATUS = "PATCH_STATUS",
+  POST = "POST",
+  PUT = "PUT",
+  WATCH = "WATCH",
+}

package/src/fluent/types.ts

@@ -4,22 +4,16 @@
 import { KubernetesListObject, KubernetesObject } from "@kubernetes/client-node";
 import { Operation } from "fast-json-patch";
 import type { PartialDeep } from "type-fest";
-import { RequestInit } from "undici";
-import { GenericClass, GroupVersionKind } from "../types";
-import { WatchCfg, Watcher } from "./watch";
+import { GenericClass } from "../types.js";
+import { WatchCfg, Watcher } from "./watch.js";
 import https from "https";
 import { SecureClientSessionOptions } from "http2";
-
+import { WatchAction, FetchMethods, ApplyCfg } from "./shared-types.js";
 /*
- * Watch Class Type
+ * Watch Class Type - Used in Pepr Watch Processor
  */
 export type WatcherType<T extends GenericClass> = Watcher<T>;
 
-/**
- * Fetch options and server URL
- */
-export type K8sConfigPromise = Promise<{ opts: RequestInit; serverUrl: string | URL }>;
-
 /**
  * Agent options for the the http2Watch
  */
@@ -35,36 +29,6 @@ export interface Options {
   agent?: https.Agent & { options?: AgentOptions };
 }
 
-/**
- * The Phase matched when using the K8s Watch API.
- */
-export enum WatchPhase {
-  Added = "ADDED",
-  Modified = "MODIFIED",
-  Deleted = "DELETED",
-  Bookmark = "BOOKMARK",
-  Error = "ERROR",
-}
-
-export type FetchMethods =
-  | "APPLY"
-  | "DELETE"
-  | "GET"
-  | "LOG"
-  | "PATCH"
-  | "PATCH_STATUS"
-  | "POST"
-  | "PUT"
-  | "WATCH";
-
-export interface Filters {
-  kindOverride?: GroupVersionKind;
-  fields?: Record<string, string>;
-  labels?: Record<string, string>;
-  name?: string;
-  namespace?: string;
-}
-
 /**
  * Get the resource or resources matching the filters.
  * If no filters are specified, all resources will be returned.
@@ -225,16 +189,6 @@ export type K8sWithFilters<T extends GenericClass, K extends KubernetesObject> =
   WithLabel: (key: string, value?: string) => K8sWithFilters<T, K>;
 };
 
-/**
- * Configuration for the apply function.
- */
-export type ApplyCfg = {
-  /**
-   * Force the apply to be a create.
-   */
-  force?: boolean;
-};
-
 export type K8sInit<T extends GenericClass, K extends KubernetesObject> = K8sWithFilters<T, K> &
   K8sUnfilteredActions<K> & {
     /**
@@ -246,11 +200,6 @@ export type K8sInit<T extends GenericClass, K extends KubernetesObject> = K8sWit
     InNamespace: (namespace: string) => K8sWithFilters<T, K>;
   };
 
-export type WatchAction<T extends GenericClass, K extends KubernetesObject = InstanceType<T>> = (
-  update: K,
-  phase: WatchPhase,
-) => Promise<void> | void;
-
 // Special types to handle the recursive keyof typescript lookup
 type Join<K, P> = K extends string | number
   ? P extends string | number

package/src/fluent/utils.ts

@@ -6,10 +6,10 @@ import { RequestInit } from "node-fetch";
 import { URL } from "url";
 import { Agent, Dispatcher } from "undici";
 import { Agent as httpsAgent } from "https";
-import { fetch } from "../fetch";
-import { modelToGroupVersionKind } from "../kinds";
-import { GenericClass } from "../types";
-import { ApplyCfg, FetchMethods, Filters, K8sConfigPromise } from "./types";
+import { fetch } from "../fetch.js";
+import { modelToGroupVersionKind } from "../kinds.js";
+import { GenericClass } from "../types.js";
+import { ApplyCfg, Filters, K8sConfigPromise, FetchMethods } from "./shared-types.js";
 import fs from "fs";
 import { V1Eviction as Eviction } from "@kubernetes/client-node";
 const SSA_CONTENT_TYPE = "application/apply-patch+yaml";
@@ -222,7 +222,7 @@ export async function k8sExec<T extends GenericClass, K>(
   applyCfg: ApplyCfg = { force: false },
 ) {
   const reconstruct = async (method: FetchMethods): K8sConfigPromise => {
-    const configMethod = method === "LOG" ? "GET" : method;
+    const configMethod = method === FetchMethods.LOG ? FetchMethods.GET : method;
     const { opts, serverUrl } = await k8sCfg(configMethod);
 
     // Build the base path once, using excludeName only for standard POST requests

package/src/fluent/watch.ts

@@ -1,15 +1,19 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2023-Present The Kubernetes Fluent Client Authors
 
-import { createHash } from "crypto";
 import { EventEmitter } from "events";
 import { fetch } from "undici";
-import { fetch as wrappedFetch } from "../fetch";
-import { GenericClass, KubernetesListObject } from "../types";
-import { Filters, WatchAction, WatchPhase, K8sConfigPromise } from "./types";
-import { k8sCfg, pathBuilder, getHeaders } from "./utils";
+import { fetch as wrappedFetch } from "../fetch.js";
+import { GenericClass, KubernetesListObject } from "../types.js";
+import { k8sCfg, pathBuilder, getHeaders } from "./utils.js";
 import { Readable } from "stream";
-
+import {
+  K8sConfigPromise,
+  WatchPhase,
+  WatchAction,
+  Filters,
+  FetchMethods,
+} from "./shared-types.js";
 export enum WatchEvent {
   /** Watch is connected successfully */
   CONNECT = "connect",
@@ -171,23 +175,6 @@ export class Watcher<T extends GenericClass> {
     this.#abortController.abort();
   }
 
-  /**
-   * Get a unique ID for the watch based on the model and filters.
-   * This is useful for caching the watch data or resource versions.
-   *
-   * @returns the watch CacheID
-   */
-  public getCacheID() {
-    // Build the URL, we don't care about the server URL or resourceVersion
-    const url = pathBuilder("https://ignore", this.#model, this.#filters, false);
-
-    // Hash and truncate the ID to 10 characters, cache the result
-    return createHash("sha224")
-      .update(url.pathname + url.search)
-      .digest("hex")
-      .substring(0, 10);
-  }
-
   /**
    * Subscribe to watch events. This is an EventEmitter that emits the following events:
    *
@@ -214,7 +201,7 @@ export class Watcher<T extends GenericClass> {
     continueToken?: string,
   ): K8sConfigPromise => {
     // Build the path and query params for the resource, excluding the name
-    const { opts, serverUrl } = await k8sCfg("GET");
+    const { opts, serverUrl } = await k8sCfg(FetchMethods.GET);
     const k8sUrl = serverUrl instanceof URL ? serverUrl.toString() : serverUrl;
     const url = pathBuilder(k8sUrl, this.#model, this.#filters, true);
 

package/src/generate.ts

@@ -12,10 +12,10 @@ import {
   quicktype,
 } from "quicktype-core";
 
-import { fetch } from "./fetch";
-import { K8s } from "./fluent";
-import { CustomResourceDefinition } from "./upstream";
-import { LogFn } from "./types";
+import { fetch } from "./fetch.js";
+import { K8s } from "./fluent/index.js";
+import { CustomResourceDefinition } from "./upstream.js";
+import { LogFn } from "./types.js";
 
 export interface GenerateOptions {
   source: string; // URL, file path, or K8s CRD name

package/src/index.ts

@@ -1,35 +1,35 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2023-Present The Kubernetes Fluent Client Authors
 
-import "./patch";
+import "./patch.js";
 
 // Export kinds as a single object
-import * as kind from "./upstream";
+import * as kind from "./upstream.js";
 
 /** kind is a collection of K8s types to be used within a K8s call: `K8s(kind.Secret).Apply({})`. */
 export { kind };
 
 // Export the node-fetch wrapper
-export { fetch } from "./fetch";
+export { fetch } from "./fetch.js";
 
 // Export the HTTP status codes
 export { StatusCodes as fetchStatus } from "http-status-codes";
 
 // Export the Watch Config and Event types
-export { WatchCfg, WatchEvent } from "./fluent/watch";
+export { WatchCfg, WatchEvent } from "./fluent/watch.js";
 
 // Export the fluent API entrypoint
-export { K8s } from "./fluent";
+export { K8s } from "./fluent/index.js";
 
 // Export helpers for working with K8s types
-export { RegisterKind, modelToGroupVersionKind } from "./kinds";
+export { RegisterKind, modelToGroupVersionKind } from "./kinds.js";
 
 // Export the GenericKind interface for CRD registration
-export { GenericKind } from "./types";
+export { GenericKind } from "./types.js";
 
-export * from "./types";
+export * from "./types.js";
 
 // Export the upstream raw models
-export * as models from "@kubernetes/client-node/dist/gen/models/all";
+export * as models from "@kubernetes/client-node/dist/gen/models/all.js";
 
-export { fromEnv, waitForCluster } from "./helpers";
+export { fromEnv, waitForCluster } from "./helpers.js";

package/src/kinds.ts

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2023-Present The Kubernetes Fluent Client Authors
 
-import { GenericClass, GroupVersionKind } from "./types";
+import { GenericClass, GroupVersionKind } from "./types.js";
 
 const gvkMap: Record<string, GroupVersionKind> = {
   /**

package/src/normalization.ts

@@ -0,0 +1,181 @@
+import { GenerateOptions } from "./generate.js";
+
+/**
+ * Normalizes indentation for TypeScript lines to a consistent format.
+ *
+ * @param lines The generated TypeScript lines.
+ * @returns The lines with normalized indentation.
+ */
+export function normalizeIndentation(lines: string[]): string[] {
+  return lines.map(line => line.replace(/^ {4}/, "  "));
+}
+
+/**
+ * Normalizes the indentation of a single line to use two spaces instead of four.
+ *
+ * @param line The line of code to normalize.
+ * @returns The line with normalized indentation.
+ */
+export function normalizeLineIndentation(line: string): string {
+  return line.replace(/^ {4}/, "  ");
+}
+
+/**
+ * Normalizes spacing between property names and types in TypeScript lines.
+ *
+ * @param lines The generated TypeScript lines.
+ * @returns The lines with normalized property spacing.
+ */
+export function normalizePropertySpacing(lines: string[]): string[] {
+  // https://regex101.com/r/XEv3pL/1
+  return lines.map(line => line.replace(/\s*\?\s*:\s*/, "?: "));
+}
+
+/**
+ * Processes a single line inside a class extending `GenericKind`.
+ *
+ * @param line The current line of code.
+ * @param genericKindProperties The list of properties from `GenericKind`.
+ * @param foundInterfaces The set of found interfaces in the file.
+ * @returns The modified line.
+ */
+export function modifyAndNormalizeClassProperties(
+  line: string,
+  genericKindProperties: string[],
+  foundInterfaces: Set<string>,
+): string {
+  line = modifyPropertiesAndAddEslintDirective(line, genericKindProperties, foundInterfaces);
+  line = normalizeLineIndentation(line);
+  return line;
+}
+
+/**
+ * Normalizes lines after processing, including indentation, spacing, and removing unnecessary lines.
+ *
+ * @param lines The lines of the file content.
+ * @param opts The options for processing.
+ * @returns The normalized lines.
+ */
+export function normalizeIndentationAndSpacing(lines: string[], opts: GenerateOptions): string[] {
+  let normalizedLines = normalizeIndentation(lines);
+  normalizedLines = normalizePropertySpacing(normalizedLines);
+  return removePropertyStringAny(normalizedLines, opts);
+}
+
+/**
+ * Removes lines containing `[property: string]: any;` from TypeScript files.
+ *
+ * @param lines The generated TypeScript lines.
+ * @param opts The options for processing.
+ * @returns The lines with `[property: string]: any;` removed.
+ */
+export function removePropertyStringAny(lines: string[], opts: GenerateOptions): string[] {
+  if (opts.language === "ts" || opts.language === "typescript") {
+    return lines.filter(line => !line.includes("[property: string]: any;"));
+  }
+  return lines;
+}
+
+/**
+ * Applies ESLint and property modifiers to a line of code.
+ *
+ * @param line - The current line of code.
+ * @param genericKindProperties - The list of properties from `GenericKind`.
+ * @param foundInterfaces - The set of found interfaces in the file.
+ * @returns The modified line.
+ */
+export function modifyPropertiesAndAddEslintDirective(
+  line: string,
+  genericKindProperties: string[],
+  foundInterfaces: Set<string>,
+): string {
+  line = addDeclareAndOptionalModifiersToProperties(line, genericKindProperties, foundInterfaces);
+  line = processEslintDisable(line, genericKindProperties);
+  return line;
+}
+
+/**
+ * Adds an ESLint disable comment for `[key: string]: any` if it's not part of `GenericKind`.
+ *
+ * @param line The current line of code.
+ * @param genericKindProperties The list of properties from `GenericKind`.
+ * @returns The modified line with the ESLint disable comment.
+ */
+export function processEslintDisable(line: string, genericKindProperties: string[]): string {
+  if (line.includes("[key: string]: any") && !genericKindProperties.includes("[key: string]")) {
+    return `  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n${line}`;
+  }
+  return line;
+}
+
+/**
+ * Applies property modifiers to a line of code.
+ *
+ * @param line The current line of code.
+ * @param genericKindProperties The list of properties from `GenericKind`.
+ * @param foundInterfaces The set of found interfaces in the file.
+ * @returns The modified line.
+ */
+export function addDeclareAndOptionalModifiersToProperties(
+  line: string,
+  genericKindProperties: string[],
+  foundInterfaces: Set<string>,
+): string {
+  line = addDeclareToGenericKindProperties(line, genericKindProperties);
+  line = makePropertiesOptional(line, foundInterfaces);
+  line = normalizeLineIndentation(line);
+  return line;
+}
+
+/**
+ * Adds the `declare` keyword to `GenericKind` properties.
+ *
+ * @param line The current line of code.
+ * @param genericKindProperties The list of properties from `GenericKind`.
+ * @returns The modified line with the `declare` keyword, if applicable.
+ */
+export function addDeclareToGenericKindProperties(
+  line: string,
+  genericKindProperties: string[],
+): string {
+  for (const prop of genericKindProperties) {
+    const propertyPattern = getPropertyPattern(prop);
+    if (propertyPattern.test(line)) {
+      return line.replace(prop, `declare ${prop}`);
+    }
+  }
+  return line;
+}
+
+/**
+ * Makes a property optional if its type matches one of the found interfaces and it is not already optional.
+ *
+ * @param line The current line of code.
+ * @param foundInterfaces The set of found interfaces in the file.
+ * @returns The modified line with the optional `?` symbol.
+ */
+export function makePropertiesOptional(line: string, foundInterfaces: Set<string>): string {
+  // https://regex101.com/r/kX8TCj/1
+  const propertyTypePattern = /:\s*(?<propertyType>\w+)\s*;/;
+  const match = line.match(propertyTypePattern);
+
+  if (match?.groups?.propertyType) {
+    const { propertyType } = match.groups;
+    if (foundInterfaces.has(propertyType) && !line.includes("?")) {
+      return line.replace(":", "?:");
+    }
+  }
+  return line;
+}
+
+/**
+ * Generates a regular expression to match a property pattern in TypeScript.
+ *
+ * @param prop The property name to match.
+ * @returns A regular expression to match the property pattern.
+ */
+export function getPropertyPattern(prop: string): RegExp {
+  // For prop="kind", the pattern will match "kind ? :" or "kind :"
+  // https://regex101.com/r/mF8kXn/1
+  return new RegExp(`\\b${prop}\\b\\s*\\?\\s*:|\\b${prop}\\b\\s*:`);
+}