kubernetes-fluent-client 3.5.6 → 3.6.0

package/src/fluent/index.ts

@@ -9,7 +9,8 @@ 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 { K8sInit, Paths } from "./types";
+import { Filters, WatchAction, FetchMethods, ApplyCfg } from "./shared-types";
 import { k8sCfg, k8sExec } from "./utils";
 import { WatchCfg, Watcher } from "./watch";
 import { hasLogs } from "../helpers";
@@ -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";
+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 { GenericClass } from "../types";
 import { WatchCfg, Watcher } from "./watch";
 import https from "https";
 import { SecureClientSessionOptions } from "http2";
-
+import { WatchAction, FetchMethods, ApplyCfg } from "./shared-types";
 /*
- * 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

@@ -9,7 +9,7 @@ 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 { ApplyCfg, Filters, K8sConfigPromise, FetchMethods } from "./shared-types";
 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,13 @@
 // 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 { Readable } from "stream";
-
+import { K8sConfigPromise, WatchPhase, WatchAction, Filters, FetchMethods } from "./shared-types";
 export enum WatchEvent {
   /** Watch is connected successfully */
   CONNECT = "connect",
@@ -171,23 +169,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 +195,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/normalization.ts

@@ -0,0 +1,181 @@
+import { GenerateOptions } from "./generate";
+
+/**
+ * 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*:`);
+}