kubernetes-fluent-client 3.0.3 → 4.0.0-rc-http2-watch

package/src/generate.ts

@@ -18,197 +18,219 @@ 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 */
+  source: string; // URL, file path, or K8s CRD name
+  directory?: string; // Output directory path
+  plain?: boolean; // Disable fluent client wrapping
   language?: string | TargetLanguage;
-  /** Override the NPM package to import when generating formatted Typescript */
-  npmPackage?: string;
-  /** Log function callback */
-  logFn: LogFn;
+  npmPackage?: string; // Override NPM package
+  logFn: LogFn; // Log function callback
+  noPost?: boolean; // Enable/disable post-processing
 }
 
 /**
  * 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(
+export async function convertCRDtoTS(
   crd: CustomResourceDefinition,
   opts: GenerateOptions,
-): Promise<Record<string, string[]>> {
-  // Get the name of the kind
+): Promise<
+  {
+    results: Record<string, string[]>;
+    name: string;
+    crd: CustomResourceDefinition;
+    version: string;
+  }[]
+> {
   const name = crd.spec.names.kind;
-
   const results: Record<string, string[]> = {};
+  const output: {
+    results: Record<string, string[]>;
+    name: string;
+    crd: CustomResourceDefinition;
+    version: string;
+  }[] = [];
+
+  // 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 JSONSchemaInput(new 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 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 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 (!match.schema?.openAPIV3Schema) {
+      opts.logFn(
+        `Skipping ${crd.metadata?.name ?? "unknown"}, it does not appear to have a valid schema`,
+      );
+      continue;
     }
 
-    // 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`,
-      );
+    const schema = JSON.stringify(match.schema.openAPIV3Schema);
+    opts.logFn(`- Generating ${crd.spec.group}/${match.name} types for ${name}`);
 
-      // Replace the interface with a named class that extends GenericKind
-      const entryIdx = processedLines.findIndex(line =>
-        line.includes(`export interface ${name} {`),
-      );
+    const inputData = await prepareInputData(name, schema);
+    const generatedTypes = await generateTypes(inputData, opts);
 
-      // Replace the interface with a named class that extends GenericKind
-      processedLines[entryIdx] = `export class ${name} extends GenericKind {`;
+    const fileName = `${name.toLowerCase()}-${match.name.toLowerCase()}`;
+    writeGeneratedFile(fileName, opts.directory || "", generatedTypes, opts.language || "ts");
 
-      // 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(`});`);
-    }
+    results[fileName] = generatedTypes;
+    output.push({ results, name, crd, version: match.name });
+  }
 
-    const finalContents = processedLines.join("\n");
-    const fileName = `${name.toLowerCase()}-${version.toLowerCase()}`;
+  return output;
+}
 
-    // 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 });
+/**
+ * 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 async function prepareInputData(name: string, schema: string): Promise<InputData> {
+  // Create a new JSONSchemaInput
+  const schemaInput = new JSONSchemaInput(new FetchingJSONSchemaStore());
 
-      // Write the file
-      const filePath = path.join(opts.directory, `${fileName}.${opts.language}`);
-      fs.writeFileSync(filePath, finalContents);
-    }
+  // Add the schema to the input
+  await schemaInput.addSource({ name, schema });
 
-    // Add the results to the array
-    results[fileName] = processedLines;
-  }
+  // Create a new InputData object
+  const inputData = new InputData();
+  inputData.addInput(schemaInput);
 
-  return results;
+  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 readOrFetchCrd(opts: GenerateOptions): Promise<CustomResourceDefinition[]> {
-  const { source, logFn } = opts;
-  let filePath: string;
+export async function generateTypes(
+  inputData: InputData,
+  opts: GenerateOptions,
+): Promise<string[]> {
+  // If the language is not specified, default to TypeScript
+  const language = opts.language || "ts";
+
+  // Generate the types
+  const out = await quicktype({
+    inputData,
+    lang: language,
+    rendererOptions: { "just-types": "true" },
+  });
+
+  return out.lines;
+}
 
-  if (source[0] === "/") {
-    // If source is an absolute path
-    filePath = source;
-  } else {
-    // If source is a relative path
-    filePath = path.join(process.cwd(), source);
-  }
+/**
+ * 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 function writeGeneratedFile(
+  fileName: string,
+  directory: string,
+  content: string[],
+  language: string | TargetLanguage,
+): void {
+  language = language || "ts";
+  if (!directory) return;
+
+  const filePath = path.join(directory, `${fileName}.${language}`);
+  fs.mkdirSync(directory, { recursive: true });
+  fs.writeFileSync(filePath, content.join("\n"));
+}
 
-  // First try to read the source as a file
+/**
+ * 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 async function readOrFetchCrd(opts: GenerateOptions): Promise<CustomResourceDefinition[]> {
   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 loadAllYaml(payload) as CustomResourceDefinition[];
+      opts.logFn(`Attempting to load ${opts.source} as a local file`);
+      const content = fs.readFileSync(filePath, "utf8");
+      return loadAllYaml(content) as CustomResourceDefinition[];
     }
-  } 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 fetch<string>(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 fetch<string>(url.href);
+      if (ok) {
+        return loadAllYaml(data) as CustomResourceDefinition[];
       }
-
-      return loadAllYaml(data) as CustomResourceDefinition[];
-    }
-  } catch (e) {
-    // If invalid, ignore the error
-    if (e.code !== "ERR_INVALID_URL") {
-      throw new Error(`Error parsing URL ${source}`);
     }
+
+    // Fallback to Kubernetes cluster
+    opts.logFn(`Attempting to read ${opts.source} from the Kubernetes cluster`);
+    return [await K8s(CustomResourceDefinition).Get(opts.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`);
   }
+}
+
+/**
+ * Resolves the source file path, treating relative paths as local files.
+ *
+ * @param source - The source path to resolve.
+ * @returns The resolved file path.
+ */
+export function resolveFilePath(source: string): string {
+  return source.startsWith("/") ? source : path.join(process.cwd(), source);
+}
 
-  // Finally, if the source is not a file or URL, try to read it as a CustomResourceDefinition from the cluster
+/**
+ * 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 function tryParseUrl(source: string): URL | null {
   try {
-    logFn(`Attempting to read ${source} from the current Kubernetes context`);
-    return [await K8s(CustomResourceDefinition).Get(source)];
-  } catch (e) {
-    throw new Error(
-      `Failed to read ${source} as a file, url or K8s CRD: ${
-        e.data?.message || "Cluster not available"
-      }`,
-    );
+    return new URL(source);
+  } 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.
  */
-export async function generate(opts: GenerateOptions) {
+export async function generate(opts: GenerateOptions): Promise<
+  {
+    results: Record<string, string[]>;
+    name: string;
+    crd: CustomResourceDefinition;
+    version: string;
+  }[]
+> {
   const crds = (await readOrFetchCrd(opts)).filter(crd => !!crd);
-  const results: Record<string, string[]> = {};
+  const allResults: {
+    results: Record<string, string[]>;
+    name: string;
+    crd: CustomResourceDefinition;
+    version: string;
+  }[] = [];
 
   opts.logFn("");
 
@@ -219,19 +241,16 @@ export async function generate(opts: GenerateOptions) {
       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;
 }