kubernetes-fluent-client 3.0.3 → 3.0.5

package/.prettierignore

@@ -0,0 +1,4 @@
+e2e/crds
+e2e/crds/**/*.ts
+e2e/generated
+generated/**/*.ts

package/README.md

@@ -105,6 +105,30 @@ Promise.all([
   });
 ```
 
+### Generating TypeScript Definitions from CRDs
+
+The Kubernetes Fluent Client can generate TypeScript definitions from Custom Resource Definitions (CRDs) using the `generate` command. This command will generate TypeScript interfaces for the CRDs in the cluster and save them to a file.
+
+To generate TypeScript definitions from CRDs, run the following command:
+
+```bash
+kubernetes-fluent-client crd /path/to/input.yaml /path/to/output/folder
+```
+
+If you have a CRD in a file named `crd.yaml` and you want to generate TypeScript definitions in a folder named `types`, you can run the following command:
+
+```bash
+kubernetes-fluent-client crd crd.yaml types
+```
+
+This will generate TypeScript interfaces for the CRD in the `crd.yaml` file and save them to the `types` folder.
+
+By default, the generated TypeScript interfaces will be post-processed to make them more user-friendly. If you want to disable this post-processing, you can use the `--noPost` flag:
+
+```bash
+kubernetes-fluent-client crd crd.yaml types --noPost
+```
+
 ### Community
 
 To chat with other users & see some examples of the fluent client in active use, go to [Kubernetes Slack](https://communityinviter.com/apps/kubernetes/community) and join `#pepr` channel.

package/e2e/cli.e2e.test.ts

@@ -0,0 +1,127 @@
+import { execFile } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import { describe, beforeEach, test, expect, afterEach } from "@jest/globals";
+
+// Utility function to execute the CLI command
+const runCliCommand = (
+  args: string[],
+  callback: (error: Error | null, stdout: string, stderr: string) => void,
+) => {
+  execFile("node", ["./dist/cli.js", ...args], callback); // Path to built CLI JS file
+};
+
+// Utility function to compare generated files to expected files
+const compareGeneratedToExpected = (generatedFile: string, expectedFile: string) => {
+  // Check if the expected file exists
+  expect(fs.existsSync(expectedFile)).toBe(true);
+
+  // Read and compare the content of the generated file to the expected file
+  const generatedContent = fs.readFileSync(generatedFile, "utf8").trim();
+  const expectedContent = fs.readFileSync(expectedFile, "utf8").trim();
+
+  expect(generatedContent).toBe(expectedContent);
+};
+
+describe("End-to-End CLI tests with multiple test files", () => {
+  const testFolder = path.join(__dirname, "crds/test.yaml"); // Directory containing .test.yaml files
+
+  // Get all .test.yaml files in the test folder
+  const testFiles = fs.readdirSync(testFolder).filter(file => file.endsWith(".test.yaml"));
+
+  testFiles.forEach(testFile => {
+    const name = path.basename(testFile, ".test.yaml"); // Extract name from the filename
+    const mockYamlPath = path.join(testFolder, testFile); // Full path to the test YAML file
+    const mockDir = path.join(__dirname, "crds/", name); // Output directory based on name
+    const expectedDir = path.join(__dirname, `crds/${name}.default.expected`); // Expected default directory
+    const expectedPostDir = path.join(__dirname, `crds/${name}.no.post.expected`); // Expected post-processing directory
+
+    const testInfoMessage = `
+      Running tests for ${name}
+                               Test file: ${mockYamlPath}
+                        Output directory: ${mockDir}
+                      Expected directory: ${expectedDir}
+      Expected post-processing directory: ${expectedPostDir}
+    `;
+
+    console.log(testInfoMessage);
+
+    beforeEach(() => {
+      // Ensure the output directory is clean
+      if (fs.existsSync(mockDir)) {
+        fs.rmSync(mockDir, { recursive: true });
+      }
+
+      // Recreate the output directory
+      fs.mkdirSync(mockDir);
+    });
+
+    afterEach(() => {
+      // Cleanup the output directory after each test
+      if (fs.existsSync(mockDir)) {
+        fs.rmSync(mockDir, { recursive: true });
+      }
+    });
+
+    test(`should generate TypeScript types and run post-processing for ${name}`, done => {
+      // Run the CLI command with the appropriate arguments
+      runCliCommand(["crd", mockYamlPath, mockDir], (error, stdout) => {
+        expect(error).toBeNull(); // Ensure no errors occurred
+
+        // Get the list of generated files
+        const generatedFiles = fs.readdirSync(mockDir);
+
+        // Compare each generated file to the corresponding expected file in expectedDir
+        generatedFiles.forEach(file => {
+          const generatedFilePath = path.join(mockDir, file);
+          const expectedFilePath = path.join(expectedDir, file);
+
+          compareGeneratedToExpected(generatedFilePath, expectedFilePath);
+        });
+
+        // Verify stdout output
+        expect(stdout).toContain("✅ Generated");
+
+        // Complete the test
+        done();
+      });
+    });
+
+    test(`should skip post-processing for ${name} when using --noPost`, done => {
+      // Run the CLI command without the --noPost flag
+      runCliCommand(["crd", mockYamlPath, mockDir, "--noPost"], (error, stdout) => {
+        expect(error).toBeNull(); // Ensure no errors occurred
+
+        // Ensure post-processing was not run (stdout should reflect this)
+        expect(stdout).not.toContain("🔧 Post-processing started");
+
+        // Complete the test
+        done();
+      });
+    });
+
+    test(`should skip post-processing for ${name} when using --noPost`, done => {
+      // Run the CLI command without post-processing
+      runCliCommand(["crd", mockYamlPath, mockDir, "--noPost"], (error, stdout) => {
+        expect(error).toBeNull(); // Ensure no errors occurred
+
+        // Get the list of generated files
+        const generatedFiles = fs.readdirSync(mockDir);
+
+        // Compare each generated file to the corresponding expected file in expectedPostDir
+        generatedFiles.forEach(file => {
+          const generatedFilePath = path.join(mockDir, file);
+          const expectedFilePath = path.join(expectedPostDir, file);
+
+          compareGeneratedToExpected(generatedFilePath, expectedFilePath);
+        });
+
+        // Ensure post-processing was not run (stdout should reflect this)
+        expect(stdout).not.toContain("🔧 Post-processing started");
+
+        // Complete the test
+        done();
+      });
+    });
+  });
+});

package/e2e/crds/policyreports.default.expected/policyreport-v1alpha1.ts

@@ -0,0 +1,332 @@
+// This file is auto-generated by kubernetes-fluent-client, do not edit manually
+import { GenericKind, RegisterKind } from "kubernetes-fluent-client";
+/**
+ * PolicyReport is the Schema for the policyreports API
+ */
+export class PolicyReport extends GenericKind {
+  /**
+   * APIVersion defines the versioned schema of this representation of an object. Servers
+   * should convert recognized schemas to the latest internal value, and may reject
+   * unrecognized values. More info:
+   * https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
+   */
+  declare apiVersion?: string;
+  /**
+   * Kind is a string value representing the REST resource this object represents. Servers may
+   * infer this from the endpoint the client submits requests to. Cannot be updated. In
+   * CamelCase. More info:
+   * https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
+   */
+  declare kind?: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  declare metadata?: { [key: string]: any };
+  /**
+   * PolicyReportResult provides result details
+   */
+  results?: Result[];
+  /**
+   * Scope is an optional reference to the report scope (e.g. a Deployment, Namespace, or Node)
+   */
+  scope?: Scope;
+  /**
+   * ScopeSelector is an optional selector for multiple scopes (e.g. Pods). Either one of, or
+   * none of, but not both of, Scope or ScopeSelector should be specified.
+   */
+  scopeSelector?: ScopeSelector;
+  /**
+   * PolicyReportSummary provides a summary of results
+   */
+  summary?: Summary;
+}
+
+/**
+ * PolicyReportResult provides the result for an individual policy
+ */
+export interface Result {
+  /**
+   * Category indicates policy category
+   */
+  category?: string;
+  /**
+   * Data provides additional information for the policy rule
+   */
+  data?: { [key: string]: string };
+  /**
+   * Message is a short user friendly description of the policy rule
+   */
+  message?: string;
+  /**
+   * Policy is the name of the policy
+   */
+  policy: string;
+  /**
+   * Resources is an optional reference to the resource checked by the policy and rule
+   */
+  resources?: Resource[];
+  /**
+   * ResourceSelector is an optional selector for policy results that apply to multiple
+   * resources. For example, a policy result may apply to all pods that match a label. Either
+   * a Resource or a ResourceSelector can be specified. If neither are provided, the result is
+   * assumed to be for the policy report scope.
+   */
+  resourceSelector?: ResourceSelector;
+  /**
+   * Rule is the name of the policy rule
+   */
+  rule?: string;
+  /**
+   * Scored indicates if this policy rule is scored
+   */
+  scored?: boolean;
+  /**
+   * Severity indicates policy severity
+   */
+  severity?: Severity;
+  /**
+   * Status indicates the result of the policy rule check
+   */
+  status?: Status;
+}
+
+/**
+ * ResourceSelector is an optional selector for policy results that apply to multiple
+ * resources. For example, a policy result may apply to all pods that match a label. Either
+ * a Resource or a ResourceSelector can be specified. If neither are provided, the result is
+ * assumed to be for the policy report scope.
+ */
+export interface ResourceSelector {
+  /**
+   * matchExpressions is a list of label selector requirements. The requirements are ANDed.
+   */
+  matchExpressions?: ResourceSelectorMatchExpression[];
+  /**
+   * matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is
+   * equivalent to an element of matchExpressions, whose key field is "key", the operator is
+   * "In", and the values array contains only "value". The requirements are ANDed.
+   */
+  matchLabels?: { [key: string]: string };
+}
+
+/**
+ * A label selector requirement is a selector that contains values, a key, and an operator
+ * that relates the key and values.
+ */
+export interface ResourceSelectorMatchExpression {
+  /**
+   * key is the label key that the selector applies to.
+   */
+  key: string;
+  /**
+   * operator represents a key's relationship to a set of values. Valid operators are In,
+   * NotIn, Exists and DoesNotExist.
+   */
+  operator: string;
+  /**
+   * values is an array of string values. If the operator is In or NotIn, the values array
+   * must be non-empty. If the operator is Exists or DoesNotExist, the values array must be
+   * empty. This array is replaced during a strategic merge patch.
+   */
+  values?: string[];
+}
+
+/**
+ * ObjectReference contains enough information to let you inspect or modify the referred
+ * object. --- New uses of this type are discouraged because of difficulty describing its
+ * usage when embedded in APIs. 1. Ignored fields.  It includes many fields which are not
+ * generally honored.  For instance, ResourceVersion and FieldPath are both very rarely
+ * valid in actual usage. 2. Invalid usage help.  It is impossible to add specific help for
+ * individual usage.  In most embedded usages, there are particular restrictions like, "must
+ * refer only to types A and B" or "UID not honored" or "name must be restricted". Those
+ * cannot be well described when embedded. 3. Inconsistent validation.  Because the usages
+ * are different, the validation rules are different by usage, which makes it hard for users
+ * to predict what will happen. 4. The fields are both imprecise and overly precise.  Kind
+ * is not a precise mapping to a URL. This can produce ambiguity during interpretation and
+ * require a REST mapping.  In most cases, the dependency is on the group,resource tuple and
+ * the version of the actual struct is irrelevant. 5. We cannot easily change it.  Because
+ * this type is embedded in many locations, updates to this type will affect numerous
+ * schemas.  Don't make new APIs embed an underspecified API type they do not control.
+ * Instead of using this type, create a locally provided and used type that is well-focused
+ * on your reference. For example, ServiceReferences for admission registration:
+ * https://github.com/kubernetes/api/blob/release-1.17/admissionregistration/v1/types.go#L533
+ * .
+ */
+export interface Resource {
+  /**
+   * API version of the referent.
+   */
+  apiVersion?: string;
+  /**
+   * If referring to a piece of an object instead of an entire object, this string should
+   * contain a valid JSON/Go field access statement, such as
+   * desiredState.manifest.containers[2]. For example, if the object reference is to a
+   * container within a pod, this would take on a value like: "spec.containers{name}" (where
+   * "name" refers to the name of the container that triggered the event) or if no container
+   * name is specified "spec.containers[2]" (container with index 2 in this pod). This syntax
+   * is chosen only to have some well-defined way of referencing a part of an object. TODO:
+   * this design is not final and this field is subject to change in the future.
+   */
+  fieldPath?: string;
+  /**
+   * Kind of the referent. More info:
+   * https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
+   */
+  kind?: string;
+  /**
+   * Name of the referent. More info:
+   * https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
+   */
+  name?: string;
+  /**
+   * Namespace of the referent. More info:
+   * https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/
+   */
+  namespace?: string;
+  /**
+   * Specific resourceVersion to which this reference is made, if any. More info:
+   * https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency
+   */
+  resourceVersion?: string;
+  /**
+   * UID of the referent. More info:
+   * https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids
+   */
+  uid?: string;
+}
+
+/**
+ * Severity indicates policy severity
+ */
+export enum Severity {
+  High = "high",
+  Low = "low",
+  Medium = "medium",
+}
+
+/**
+ * Status indicates the result of the policy rule check
+ */
+export enum Status {
+  Error = "error",
+  Fail = "fail",
+  Pass = "pass",
+  Skip = "skip",
+  Warn = "warn",
+}
+
+/**
+ * Scope is an optional reference to the report scope (e.g. a Deployment, Namespace, or Node)
+ */
+export interface Scope {
+  /**
+   * API version of the referent.
+   */
+  apiVersion?: string;
+  /**
+   * If referring to a piece of an object instead of an entire object, this string should
+   * contain a valid JSON/Go field access statement, such as
+   * desiredState.manifest.containers[2]. For example, if the object reference is to a
+   * container within a pod, this would take on a value like: "spec.containers{name}" (where
+   * "name" refers to the name of the container that triggered the event) or if no container
+   * name is specified "spec.containers[2]" (container with index 2 in this pod). This syntax
+   * is chosen only to have some well-defined way of referencing a part of an object. TODO:
+   * this design is not final and this field is subject to change in the future.
+   */
+  fieldPath?: string;
+  /**
+   * Kind of the referent. More info:
+   * https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
+   */
+  kind?: string;
+  /**
+   * Name of the referent. More info:
+   * https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
+   */
+  name?: string;
+  /**
+   * Namespace of the referent. More info:
+   * https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/
+   */
+  namespace?: string;
+  /**
+   * Specific resourceVersion to which this reference is made, if any. More info:
+   * https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency
+   */
+  resourceVersion?: string;
+  /**
+   * UID of the referent. More info:
+   * https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids
+   */
+  uid?: string;
+}
+
+/**
+ * ScopeSelector is an optional selector for multiple scopes (e.g. Pods). Either one of, or
+ * none of, but not both of, Scope or ScopeSelector should be specified.
+ */
+export interface ScopeSelector {
+  /**
+   * matchExpressions is a list of label selector requirements. The requirements are ANDed.
+   */
+  matchExpressions?: ScopeSelectorMatchExpression[];
+  /**
+   * matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is
+   * equivalent to an element of matchExpressions, whose key field is "key", the operator is
+   * "In", and the values array contains only "value". The requirements are ANDed.
+   */
+  matchLabels?: { [key: string]: string };
+}
+
+/**
+ * A label selector requirement is a selector that contains values, a key, and an operator
+ * that relates the key and values.
+ */
+export interface ScopeSelectorMatchExpression {
+  /**
+   * key is the label key that the selector applies to.
+   */
+  key: string;
+  /**
+   * operator represents a key's relationship to a set of values. Valid operators are In,
+   * NotIn, Exists and DoesNotExist.
+   */
+  operator: string;
+  /**
+   * values is an array of string values. If the operator is In or NotIn, the values array
+   * must be non-empty. If the operator is Exists or DoesNotExist, the values array must be
+   * empty. This array is replaced during a strategic merge patch.
+   */
+  values?: string[];
+}
+
+/**
+ * PolicyReportSummary provides a summary of results
+ */
+export interface Summary {
+  /**
+   * Error provides the count of policies that could not be evaluated
+   */
+  error?: number;
+  /**
+   * Fail provides the count of policies whose requirements were not met
+   */
+  fail?: number;
+  /**
+   * Pass provides the count of policies whose requirements were met
+   */
+  pass?: number;
+  /**
+   * Skip indicates the count of policies that were not selected for evaluation
+   */
+  skip?: number;
+  /**
+   * Warn provides the count of unscored policies whose requirements were not met
+   */
+  warn?: number;
+}
+
+RegisterKind(PolicyReport, {
+  group: "wgpolicyk8s.io",
+  version: "v1alpha1",
+  kind: "PolicyReport",
+  plural: "policyreports",
+});