kubernetes-fluent-client 3.0.3 → 3.0.4

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/dist/cli.js

@@ -10,6 +10,8 @@ const helpers_1 = require("yargs/helpers");
 const yargs_1 = __importDefault(require("yargs/yargs"));
 const generate_1 = require("./generate");
 const package_json_1 = require("../package.json");
+const postProcessing_1 = require("./postProcessing");
+const fileSystem_1 = require("./fileSystem"); // Import your new file system
 void (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
     .version("version", "Display version number", `kubernetes-fluent-client v${package_json_1.version}`)
     .alias("version", "V")
@@ -33,13 +35,31 @@ void (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
         type: "string",
         default: "ts",
         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;
     opts.logFn = console.log;
+    // Pass the `post` flag to opts
+    opts.noPost = argv.noPost;
+    // Use NodeFileSystem as the file system for post-processing
+    const fileSystem = new fileSystem_1.NodeFileSystem(); // Create an instance of NodeFileSystem
+    if (!opts.noPost) {
+        console.log("\n✅ Post-processing has been enabled.\n");
+    }
     try {
-        await (0, generate_1.generate)(opts);
+        // Capture the results returned by generate
+        const allResults = await (0, generate_1.generate)(opts);
+        // If noPost is false, run post-processing
+        if (!opts.noPost) {
+            await (0, postProcessing_1.postProcessing)(allResults, opts, fileSystem); // Pass the file system to postProcessing
+        }
     }
     catch (e) {
         console.log(`\n❌ ${e.message}`);

package/dist/fileSystem.d.ts

@@ -0,0 +1,11 @@
+export interface FileSystem {
+    readFile(filePath: string): string;
+    writeFile(filePath: string, content: string): void;
+    readdirSync(directory: string): string[];
+}
+export declare class NodeFileSystem implements FileSystem {
+    readFile(filePath: string): string;
+    writeFile(filePath: string, content: string): void;
+    readdirSync(directory: string): string[];
+}
+//# sourceMappingURL=fileSystem.d.ts.map

package/dist/fileSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileSystem.d.ts","sourceRoot":"","sources":["../src/fileSystem.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;IACnC,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACnD,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC1C;AAGD,qBAAa,cAAe,YAAW,UAAU;IAC/C,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAIlC,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAIlD,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE;CAGzC"}

package/dist/fileSystem.js

@@ -0,0 +1,42 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Kubernetes Fluent Client Authors
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeFileSystem = void 0;
+const fs = __importStar(require("fs"));
+/* eslint class-methods-use-this: "off" */
+class NodeFileSystem {
+    readFile(filePath) {
+        return fs.readFileSync(filePath, "utf8");
+    }
+    writeFile(filePath, content) {
+        fs.writeFileSync(filePath, content, "utf8");
+    }
+    readdirSync(directory) {
+        return fs.readdirSync(directory);
+    }
+}
+exports.NodeFileSystem = NodeFileSystem;

package/dist/fileSystem.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fileSystem.test.d.ts.map

package/dist/fileSystem.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileSystem.test.d.ts","sourceRoot":"","sources":["../src/fileSystem.test.ts"],"names":[],"mappings":""}

package/dist/fileSystem.test.js

@@ -0,0 +1,75 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Kubernetes Fluent Client Authors
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const fileSystem_1 = require("./fileSystem");
+const globals_1 = require("@jest/globals");
+// Mock the fs module
+globals_1.jest.mock("fs");
+(0, globals_1.describe)("NodeFileSystem", () => {
+    let nodeFileSystem;
+    (0, globals_1.beforeEach)(() => {
+        nodeFileSystem = new fileSystem_1.NodeFileSystem();
+        globals_1.jest.clearAllMocks(); // Clear all mocks before each test
+    });
+    (0, globals_1.describe)("readFile", () => {
+        (0, globals_1.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.mockReturnValue(mockFileContent);
+            const result = nodeFileSystem.readFile(mockFilePath);
+            // Assert that fs.readFileSync was called with the correct file path and encoding
+            (0, globals_1.expect)(fs.readFileSync).toHaveBeenCalledWith(mockFilePath, "utf8");
+            // Assert that the returned content matches the mock file content
+            (0, globals_1.expect)(result).toBe(mockFileContent);
+        });
+    });
+    (0, globals_1.describe)("writeFile", () => {
+        (0, globals_1.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
+            (0, globals_1.expect)(fs.writeFileSync).toHaveBeenCalledWith(mockFilePath, mockFileContent, "utf8");
+        });
+    });
+    (0, globals_1.describe)("readdirSync", () => {
+        (0, globals_1.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.mockReturnValue(mockFileList);
+            const result = nodeFileSystem.readdirSync(mockDirectoryPath);
+            // Assert that fs.readdirSync was called with the correct directory path
+            (0, globals_1.expect)(fs.readdirSync).toHaveBeenCalledWith(mockDirectoryPath);
+            // Assert that the returned file list matches the mock file list
+            (0, globals_1.expect)(result).toEqual(mockFileList);
+        });
+    });
+});

package/dist/generate.d.ts

@@ -1,24 +1,84 @@
-import { TargetLanguage } from "quicktype-core";
+import { InputData, TargetLanguage } from "quicktype-core";
+import { CustomResourceDefinition } from "./upstream";
 import { LogFn } from "./types";
 export interface GenerateOptions {
-    /** The source URL, yaml file path or K8s CRD name */
     source: string;
-    /** The output directory path */
     directory?: string;
-    /** Disable kubernetes-fluent-client wrapping */
     plain?: boolean;
-    /** The language to generate types in */
     language?: string | TargetLanguage;
-    /** Override the NPM package to import when generating formatted Typescript */
     npmPackage?: string;
-    /** Log function callback */
     logFn: LogFn;
+    noPost?: boolean;
 }
 /**
- * Generate TypeScript types from a K8s CRD
+ * Converts a CustomResourceDefinition to TypeScript types
  *
- * @param opts The options to use when generating
- * @returns A promise that resolves when the TypeScript types have been generated
+ * @param crd - The CustomResourceDefinition object to convert.
+ * @param opts - The options for generating the TypeScript types.
+ * @returns A promise that resolves to a record of generated TypeScript types.
  */
-export declare function generate(opts: GenerateOptions): Promise<Record<string, string[]>>;
+export declare function convertCRDtoTS(crd: CustomResourceDefinition, opts: GenerateOptions): Promise<{
+    results: Record<string, string[]>;
+    name: string;
+    crd: CustomResourceDefinition;
+    version: string;
+}[]>;
+/**
+ * Prepares the input data for quicktype from the provided schema.
+ *
+ * @param name - The name of the schema.
+ * @param schema - The JSON schema as a string.
+ * @returns A promise that resolves to the input data for quicktype.
+ */
+export declare function prepareInputData(name: string, schema: string): Promise<InputData>;
+/**
+ * Generates TypeScript types using quicktype.
+ *
+ * @param inputData - The input data for quicktype.
+ * @param opts - The options for generating the TypeScript types.
+ * @returns A promise that resolves to an array of generated TypeScript type lines.
+ */
+export declare function generateTypes(inputData: InputData, opts: GenerateOptions): Promise<string[]>;
+/**
+ * Writes the processed lines to the output file.
+ *
+ * @param fileName - The name of the file to write.
+ * @param directory - The directory where the file will be written.
+ * @param content - The content to write to the file.
+ * @param language - The programming language of the file.
+ */
+export declare function writeGeneratedFile(fileName: string, directory: string, content: string[], language: string | TargetLanguage): void;
+/**
+ * Reads or fetches a CustomResourceDefinition from a file, URL, or the cluster.
+ *
+ * @param opts - The options for generating the TypeScript types.
+ * @returns A promise that resolves to an array of CustomResourceDefinition objects.
+ */
+export declare function readOrFetchCrd(opts: GenerateOptions): Promise<CustomResourceDefinition[]>;
+/**
+ * Resolves the source file path, treating relative paths as local files.
+ *
+ * @param source - The source path to resolve.
+ * @returns The resolved file path.
+ */
+export declare function resolveFilePath(source: string): string;
+/**
+ * Tries to parse the source as a URL.
+ *
+ * @param source - The source string to parse as a URL.
+ * @returns The parsed URL object or null if parsing fails.
+ */
+export declare function tryParseUrl(source: string): URL | null;
+/**
+ * Main generate function to convert CRDs to TypeScript types.
+ *
+ * @param opts - The options for generating the TypeScript types.
+ * @returns A promise that resolves to a record of generated TypeScript types.
+ */
+export declare function generate(opts: GenerateOptions): Promise<{
+    results: Record<string, string[]>;
+    name: string;
+    crd: CustomResourceDefinition;
+    version: string;
+}[]>;
 //# sourceMappingURL=generate.d.ts.map

package/dist/generate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../src/generate.ts"],"names":[],"mappings":"AAMA,OAAO,EAIL,cAAc,EAEf,MAAM,gBAAgB,CAAC;AAKxB,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,MAAM,WAAW,eAAe;IAC9B,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAC;IACf,gCAAgC;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gDAAgD;IAChD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,GAAG,cAAc,CAAC;IACnC,8EAA8E;IAC9E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4BAA4B;IAC5B,KAAK,EAAE,KAAK,CAAC;CACd;AA0KD;;;;;GAKG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,eAAe,qCA4BnD"}
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../src/generate.ts"],"names":[],"mappings":"AAMA,OAAO,EAEL,SAAS,EAET,cAAc,EAEf,MAAM,gBAAgB,CAAC;AAIxB,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,GAAG,cAAc,CAAC;IACnC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,GAAG,EAAE,wBAAwB,EAC7B,IAAI,EAAE,eAAe,GACpB,OAAO,CACR;IACE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,wBAAwB,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC;CACjB,EAAE,CACJ,CAuCA;AAED;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,CAYvF;AAED;;;;;;GAMG;AACH,wBAAsB,aAAa,CACjC,SAAS,EAAE,SAAS,EACpB,IAAI,EAAE,eAAe,GACpB,OAAO,CAAC,MAAM,EAAE,CAAC,CAYnB;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EAAE,EACjB,QAAQ,EAAE,MAAM,GAAG,cAAc,GAChC,IAAI,CAON;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,wBAAwB,EAAE,CAAC,CA0B/F;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,GAAG,IAAI,CAMtD;AAED;;;;;GAKG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAC5D;IACE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,wBAAwB,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC;CACjB,EAAE,CACJ,CA8BA"}

package/dist/generate.js

@@ -25,6 +25,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertCRDtoTS = convertCRDtoTS;
+exports.prepareInputData = prepareInputData;
+exports.generateTypes = generateTypes;
+exports.writeGeneratedFile = writeGeneratedFile;
+exports.readOrFetchCrd = readOrFetchCrd;
+exports.resolveFilePath = resolveFilePath;
+exports.tryParseUrl = tryParseUrl;
 exports.generate = generate;
 const client_node_1 = require("@kubernetes/client-node");
 const fs = __importStar(require("fs"));
@@ -36,144 +43,150 @@ const upstream_1 = require("./upstream");
 /**
  * Converts a CustomResourceDefinition to TypeScript types
  *
- * @param crd The CustomResourceDefinition to convert
- * @param opts The options to use when converting
- * @returns A promise that resolves when the CustomResourceDefinition has been converted
+ * @param crd - The CustomResourceDefinition object to convert.
+ * @param opts - The options for generating the TypeScript types.
+ * @returns A promise that resolves to a record of generated TypeScript types.
  */
 async function convertCRDtoTS(crd, opts) {
-    // Get the name of the kind
     const name = crd.spec.names.kind;
     const results = {};
+    const output = [];
+    // Check for missing versions or empty schema
+    if (!crd.spec.versions || crd.spec.versions.length === 0) {
+        opts.logFn(`Skipping ${crd.metadata?.name}, it does not appear to be a CRD`);
+        return [];
+    }
+    // Iterate through each version of the CRD
     for (const match of crd.spec.versions) {
-        const version = match.name;
-        // Get the schema from the matched version
-        const schema = JSON.stringify(match?.schema?.openAPIV3Schema);
-        // Create a new JSONSchemaInput
-        const schemaInput = new quicktype_core_1.JSONSchemaInput(new quicktype_core_1.FetchingJSONSchemaStore());
-        opts.logFn(`- Generating ${crd.spec.group}/${version} types for ${name}`);
-        // Add the schema to the input
-        await schemaInput.addSource({ name, schema });
-        // Create a new InputData object
-        const inputData = new quicktype_core_1.InputData();
-        inputData.addInput(schemaInput);
-        // If the language is not specified, default to TypeScript
-        if (!opts.language) {
-            opts.language = "ts";
-        }
-        // Generate the types
-        const out = await (0, quicktype_core_1.quicktype)({
-            inputData,
-            lang: opts.language,
-            rendererOptions: { "just-types": "true" },
-        });
-        let processedLines = out.lines;
-        // If using typescript, remove the line containing `[property: string]: any;`
-        if (opts.language === "ts" || opts.language === "typescript") {
-            processedLines = out.lines.filter(line => !line.includes("[property: string]: any;"));
-        }
-        // If the language is TypeScript and plain is not specified, wire up the fluent client
-        if (opts.language === "ts" && !opts.plain) {
-            if (!opts.npmPackage) {
-                opts.npmPackage = "kubernetes-fluent-client";
-            }
-            processedLines.unshift(
-            // Add warning that the file is auto-generated
-            `// This file is auto-generated by ${opts.npmPackage}, do not edit manually\n`, 
-            // Add the imports before any other lines
-            `import { GenericKind, RegisterKind } from "${opts.npmPackage}";\n`);
-            // Replace the interface with a named class that extends GenericKind
-            const entryIdx = processedLines.findIndex(line => line.includes(`export interface ${name} {`));
-            // Replace the interface with a named class that extends GenericKind
-            processedLines[entryIdx] = `export class ${name} extends GenericKind {`;
-            // Add the RegisterKind call
-            processedLines.push(`RegisterKind(${name}, {`);
-            processedLines.push(`  group: "${crd.spec.group}",`);
-            processedLines.push(`  version: "${version}",`);
-            processedLines.push(`  kind: "${name}",`);
-            processedLines.push(`  plural: "${crd.spec.names.plural}",`);
-            processedLines.push(`});`);
-        }
-        const finalContents = processedLines.join("\n");
-        const fileName = `${name.toLowerCase()}-${version.toLowerCase()}`;
-        // If an output file is specified, write the output to the file
-        if (opts.directory) {
-            // Create the directory if it doesn't exist
-            fs.mkdirSync(opts.directory, { recursive: true });
-            // Write the file
-            const filePath = path.join(opts.directory, `${fileName}.${opts.language}`);
-            fs.writeFileSync(filePath, finalContents);
+        if (!match.schema?.openAPIV3Schema) {
+            opts.logFn(`Skipping ${crd.metadata?.name ?? "unknown"}, it does not appear to have a valid schema`);
+            continue;
         }
-        // Add the results to the array
-        results[fileName] = processedLines;
+        const schema = JSON.stringify(match.schema.openAPIV3Schema);
+        opts.logFn(`- Generating ${crd.spec.group}/${match.name} types for ${name}`);
+        const inputData = await prepareInputData(name, schema);
+        const generatedTypes = await generateTypes(inputData, opts);
+        const fileName = `${name.toLowerCase()}-${match.name.toLowerCase()}`;
+        writeGeneratedFile(fileName, opts.directory || "", generatedTypes, opts.language || "ts");
+        results[fileName] = generatedTypes;
+        output.push({ results, name, crd, version: match.name });
     }
-    return results;
+    return output;
+}
+/**
+ * Prepares the input data for quicktype from the provided schema.
+ *
+ * @param name - The name of the schema.
+ * @param schema - The JSON schema as a string.
+ * @returns A promise that resolves to the input data for quicktype.
+ */
+async function prepareInputData(name, schema) {
+    // Create a new JSONSchemaInput
+    const schemaInput = new quicktype_core_1.JSONSchemaInput(new quicktype_core_1.FetchingJSONSchemaStore());
+    // Add the schema to the input
+    await schemaInput.addSource({ name, schema });
+    // Create a new InputData object
+    const inputData = new quicktype_core_1.InputData();
+    inputData.addInput(schemaInput);
+    return inputData;
 }
 /**
- * Reads a CustomResourceDefinition from a file, the cluster or the internet
+ * Generates TypeScript types using quicktype.
  *
- * @param opts The options to use when reading
- * @returns A promise that resolves when the CustomResourceDefinition has been read
+ * @param inputData - The input data for quicktype.
+ * @param opts - The options for generating the TypeScript types.
+ * @returns A promise that resolves to an array of generated TypeScript type lines.
+ */
+async function generateTypes(inputData, opts) {
+    // If the language is not specified, default to TypeScript
+    const language = opts.language || "ts";
+    // Generate the types
+    const out = await (0, quicktype_core_1.quicktype)({
+        inputData,
+        lang: language,
+        rendererOptions: { "just-types": "true" },
+    });
+    return out.lines;
+}
+/**
+ * Writes the processed lines to the output file.
+ *
+ * @param fileName - The name of the file to write.
+ * @param directory - The directory where the file will be written.
+ * @param content - The content to write to the file.
+ * @param language - The programming language of the file.
+ */
+function writeGeneratedFile(fileName, directory, content, language) {
+    language = language || "ts";
+    if (!directory)
+        return;
+    const filePath = path.join(directory, `${fileName}.${language}`);
+    fs.mkdirSync(directory, { recursive: true });
+    fs.writeFileSync(filePath, content.join("\n"));
+}
+/**
+ * Reads or fetches a CustomResourceDefinition from a file, URL, or the cluster.
+ *
+ * @param opts - The options for generating the TypeScript types.
+ * @returns A promise that resolves to an array of CustomResourceDefinition objects.
  */
 async function readOrFetchCrd(opts) {
-    const { source, logFn } = opts;
-    let filePath;
-    if (source[0] === "/") {
-        // If source is an absolute path
-        filePath = source;
-    }
-    else {
-        // If source is a relative path
-        filePath = path.join(process.cwd(), source);
-    }
-    // First try to read the source as a file
     try {
+        const filePath = resolveFilePath(opts.source);
         if (fs.existsSync(filePath)) {
-            logFn(`Attempting to load ${source} as a local file`);
-            const payload = fs.readFileSync(filePath, "utf8");
-            return (0, client_node_1.loadAllYaml)(payload);
+            opts.logFn(`Attempting to load ${opts.source} as a local file`);
+            const content = fs.readFileSync(filePath, "utf8");
+            return (0, client_node_1.loadAllYaml)(content);
         }
-    }
-    catch {
-        // Ignore errors
-    }
-    // Next try to parse the source as a URL
-    try {
-        const url = new URL(source);
-        // If the source is a URL, fetch it
-        if (url.protocol === "http:" || url.protocol === "https:") {
-            logFn(`Attempting to load ${source} as a URL`);
-            const { ok, data } = await (0, fetch_1.fetch)(source);
-            // If the request failed, throw an error
-            if (!ok) {
-                throw new Error(`Failed to fetch ${source}: ${data}`);
+        const url = tryParseUrl(opts.source);
+        if (url) {
+            opts.logFn(`Attempting to load ${opts.source} as a URL`);
+            const { ok, data } = await (0, fetch_1.fetch)(url.href);
+            if (ok) {
+                return (0, client_node_1.loadAllYaml)(data);
             }
-            return (0, client_node_1.loadAllYaml)(data);
         }
+        // Fallback to Kubernetes cluster
+        opts.logFn(`Attempting to read ${opts.source} from the Kubernetes cluster`);
+        return [await (0, fluent_1.K8s)(upstream_1.CustomResourceDefinition).Get(opts.source)];
     }
-    catch (e) {
-        // If invalid, ignore the error
-        if (e.code !== "ERR_INVALID_URL") {
-            throw new Error(`Error parsing URL ${source}`);
-        }
+    catch (error) {
+        opts.logFn(`Error loading CRD: ${error.message}`);
+        throw new Error(`Failed to read ${opts.source} as a file, URL, or Kubernetes CRD`);
     }
-    // Finally, if the source is not a file or URL, try to read it as a CustomResourceDefinition from the cluster
+}
+/**
+ * Resolves the source file path, treating relative paths as local files.
+ *
+ * @param source - The source path to resolve.
+ * @returns The resolved file path.
+ */
+function resolveFilePath(source) {
+    return source.startsWith("/") ? source : path.join(process.cwd(), source);
+}
+/**
+ * Tries to parse the source as a URL.
+ *
+ * @param source - The source string to parse as a URL.
+ * @returns The parsed URL object or null if parsing fails.
+ */
+function tryParseUrl(source) {
     try {
-        logFn(`Attempting to read ${source} from the current Kubernetes context`);
-        return [await (0, fluent_1.K8s)(upstream_1.CustomResourceDefinition).Get(source)];
+        return new URL(source);
     }
-    catch (e) {
-        throw new Error(`Failed to read ${source} as a file, url or K8s CRD: ${e.data?.message || "Cluster not available"}`);
+    catch {
+        return null;
     }
 }
 /**
- * Generate TypeScript types from a K8s CRD
+ * Main generate function to convert CRDs to TypeScript types.
  *
- * @param opts The options to use when generating
- * @returns A promise that resolves when the TypeScript types have been generated
+ * @param opts - The options for generating the TypeScript types.
+ * @returns A promise that resolves to a record of generated TypeScript types.
  */
 async function generate(opts) {
     const crds = (await readOrFetchCrd(opts)).filter(crd => !!crd);
-    const results = {};
+    const allResults = [];
     opts.logFn("");
     for (const crd of crds) {
         if (crd.kind !== "CustomResourceDefinition" || !crd.spec?.versions?.length) {
@@ -181,15 +194,15 @@ async function generate(opts) {
             // Ignore empty and non-CRD objects
             continue;
         }
-        // Add the results to the record
-        const out = await convertCRDtoTS(crd, opts);
-        for (const key of Object.keys(out)) {
-            results[key] = out[key];
-        }
+        allResults.push(...(await convertCRDtoTS(crd, opts)));
     }
     if (opts.directory) {
         // Notify the user that the files have been generated
-        opts.logFn(`\n✅ Generated ${Object.keys(results).length} files in the ${opts.directory} directory`);
+        opts.logFn(`\n✅ Generated ${allResults.length} files in the ${opts.directory} directory`);
+    }
+    else {
+        // Log a message about the number of generated files even when no directory is provided
+        opts.logFn(`\n✅ Generated ${allResults.length} files`);
     }
-    return results;
+    return allResults;
 }