kubernetes-fluent-client 3.0.3 → 3.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kubernetes-fluent-client",
-  "version": "3.0.3",
+  "version": "3.0.4",
   "description": "A @kubernetes/client-node fluent API wrapper that leverages K8s Server Side Apply.",
   "bin": "./dist/cli.js",
   "main": "dist/index.js",
@@ -10,6 +10,7 @@
     "build": "tsc",
     "semantic-release": "semantic-release",
     "test": "jest src --coverage",
+    "test:e2e": "jest e2e",
     "format:check": "eslint src && prettier . --check",
     "format:fix": "eslint --fix src && prettier . --write"
   },
@@ -52,13 +53,13 @@
     "@types/readable-stream": "4.0.15",
     "@types/urijs": "^1.19.25",
     "@types/yargs": "17.0.33",
-    "@typescript-eslint/eslint-plugin": "8.5.0",
-    "@typescript-eslint/parser": "8.5.0",
-    "eslint-plugin-jsdoc": "50.2.3",
+    "@typescript-eslint/eslint-plugin": "8.7.0",
+    "@typescript-eslint/parser": "8.7.0",
+    "eslint-plugin-jsdoc": "50.3.0",
     "jest": "29.7.0",
     "nock": "13.5.5",
     "prettier": "3.3.3",
-    "semantic-release": "24.1.1",
+    "semantic-release": "24.1.2",
     "ts-jest": "29.2.5",
     "typescript": "5.6.2"
   },

package/src/cli.ts

@@ -7,6 +7,8 @@ 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
 
 void yargs(hideBin(process.argv))
   .version("version", "Display version number", `kubernetes-fluent-client v${version}`)
@@ -37,14 +39,36 @@ void yargs(hideBin(process.argv))
           description:
             "the language to generate types in, see https://github.com/glideapps/quicktype#target-languages for a list of supported languages",
         })
+        .option("noPost", {
+          alias: "x",
+          type: "boolean",
+          default: false,
+          description: "disable post-processing after generating the types",
+        })
         .demandOption(["source", "directory"]);
     },
     async argv => {
       const opts = argv as unknown as GenerateOptions;
       opts.logFn = console.log;
 
+      // Pass the `post` flag to opts
+      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");
+      }
+
       try {
-        await generate(opts);
+        // Capture the results returned by generate
+        const allResults = await generate(opts);
+
+        // If noPost is false, run post-processing
+        if (!opts.noPost) {
+          await postProcessing(allResults, opts, fileSystem); // Pass the file system to postProcessing
+        }
       } catch (e) {
         console.log(`\n❌ ${e.message}`);
       }

package/src/fileSystem.test.ts

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Kubernetes Fluent Client Authors
+
+import * as fs from "fs";
+import { NodeFileSystem } from "./fileSystem";
+import { beforeEach, describe, expect, jest, test } from "@jest/globals";
+
+// Mock the fs module
+jest.mock("fs");
+
+describe("NodeFileSystem", () => {
+  let nodeFileSystem: NodeFileSystem;
+
+  beforeEach(() => {
+    nodeFileSystem = new NodeFileSystem();
+    jest.clearAllMocks(); // Clear all mocks before each test
+  });
+
+  describe("readFile", () => {
+    test("should call fs.readFileSync with correct arguments", () => {
+      const mockFilePath = "test-file.txt";
+      const mockFileContent = "This is a test file";
+
+      // Mock the fs.readFileSync method to return the mock file content
+      (fs.readFileSync as jest.Mock).mockReturnValue(mockFileContent);
+
+      const result = nodeFileSystem.readFile(mockFilePath);
+
+      // Assert that fs.readFileSync was called with the correct file path and encoding
+      expect(fs.readFileSync).toHaveBeenCalledWith(mockFilePath, "utf8");
+
+      // Assert that the returned content matches the mock file content
+      expect(result).toBe(mockFileContent);
+    });
+  });
+
+  describe("writeFile", () => {
+    test("should call fs.writeFileSync with correct arguments", () => {
+      const mockFilePath = "test-file.txt";
+      const mockFileContent = "This is a test file";
+
+      // Call the writeFile method
+      nodeFileSystem.writeFile(mockFilePath, mockFileContent);
+
+      // Assert that fs.writeFileSync was called with the correct arguments
+      expect(fs.writeFileSync).toHaveBeenCalledWith(mockFilePath, mockFileContent, "utf8");
+    });
+  });
+
+  describe("readdirSync", () => {
+    test("should call fs.readdirSync with correct arguments and return file list", () => {
+      const mockDirectoryPath = "test-directory";
+      const mockFileList = ["file1.txt", "file2.txt"];
+
+      // Mock the fs.readdirSync method to return the mock file list
+      (fs.readdirSync as jest.Mock).mockReturnValue(mockFileList);
+
+      const result = nodeFileSystem.readdirSync(mockDirectoryPath);
+
+      // Assert that fs.readdirSync was called with the correct directory path
+      expect(fs.readdirSync).toHaveBeenCalledWith(mockDirectoryPath);
+
+      // Assert that the returned file list matches the mock file list
+      expect(result).toEqual(mockFileList);
+    });
+  });
+});

package/src/fileSystem.ts

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Kubernetes Fluent Client Authors
+
+import * as fs from "fs";
+
+export interface FileSystem {
+  readFile(filePath: string): string;
+  writeFile(filePath: string, content: string): void;
+  readdirSync(directory: string): string[];
+}
+
+/* eslint class-methods-use-this: "off" */
+export class NodeFileSystem implements FileSystem {
+  readFile(filePath: string): string {
+    return fs.readFileSync(filePath, "utf8");
+  }
+
+  writeFile(filePath: string, content: string): void {
+    fs.writeFileSync(filePath, content, "utf8");
+  }
+
+  readdirSync(directory: string): string[] {
+    return fs.readdirSync(directory);
+  }
+}