feat: custom model class

Author: devthejo

utils/crd-generate/src/cli.ts

@@ -32,13 +32,25 @@ export async function run(): Promise<void> {
       describe: "YAML version.",
       choices: ["1.0", "1.1", "1.2"]
     })
+    .option("customBaseClassName", {
+      type: "string",
+      describe: "Base class import name",
+      default: "Model"
+    })
+    .option("customBaseClassImportPath", {
+      type: "string",
+      describe: "Base class import path",
+      default: "@kubernetes-models/base"
+    })
     .parse();
 
   try {
     await generate({
       input: await readFiles(args.input),
       outputPath: args.output,
-      yamlVersion: args.yamlVersion as GenerateOptions["yamlVersion"]
+      yamlVersion: args.yamlVersion as GenerateOptions["yamlVersion"],
+      customBaseClassName: args.customBaseClassName,
+      customBaseClassImportPath: args.customBaseClassImportPath
     });
   } catch (err) {
     console.error(err);

utils/crd-generate/src/generate.ts

@@ -144,6 +144,8 @@ export interface GenerateOptions {
   input: string;
   outputPath: string;
   yamlVersion?: DocumentOptions["version"];
+  customBaseClassName?: string;
+  customBaseClassImportPath?: string;
 }
 
 export async function generate(options: GenerateOptions): Promise<void> {
@@ -191,7 +193,10 @@ export async function generate(options: GenerateOptions): Promise<void> {
     }
   }
 
-  const files = await generator(dedupeDefinitions(definitions));
+  const files = await generator(dedupeDefinitions(definitions), {
+    baseClassName: options.customBaseClassName,
+    baseClassImportPath: options.customBaseClassImportPath
+  });
 
   await writeOutputFiles(options.outputPath, files);
 }

utils/crd-generate/src/generators/definition.ts

@@ -6,8 +6,10 @@ import {
   getAPIVersion,
   GroupVersionKind,
   Import,
-  OutputFile
+  OutputFile,
+  GenerateOptions as BaseGenerateOptions
 } from "@kubernetes-models/generate";
+import { GenerateOptions } from "../generate";
 import { formatComment, trimSuffix } from "@kubernetes-models/string-util";
 import { getRelativePath, getSchemaPath } from "../utils";
 
@@ -19,7 +21,8 @@ function getFieldType(key: string[]): string | undefined {
 
 function generateDefinition(
   gvk: GroupVersionKind,
-  def: Definition
+  def: Definition,
+  options: GenerateOptions
 ): OutputFile {
   const apiVersion = getAPIVersion(gvk);
   const className = gvk.kind;
@@ -66,8 +69,9 @@ constructor(data?: ModelData<${interfaceName}>) {
   });
 
   imports.push({
-    name: "Model",
-    path: "@kubernetes-models/base"
+    alias: "Model",
+    name: options.customBaseClassName as string,
+    path: options.customBaseClassImportPath as string
   });
 
   imports.push({
@@ -114,14 +118,22 @@ setValidateFunc(${className}, validate as ValidateFunc<${interfaceName}>);
   };
 }
 
-const generateDefinitions: Generator = async (definitions) => {
+const generateDefinitions: Generator = async (definitions, options = {}) => {
   const output: OutputFile[] = [];
 
+  // Convert base options to local options format
+  const localOptions: GenerateOptions = {
+    input: "",
+    outputPath: "",
+    customBaseClassName: options.baseClassName,
+    customBaseClassImportPath: options.baseClassImportPath
+  };
+
   for (const def of definitions) {
     const gvks = def.gvk;
 
     if (gvks && gvks.length) {
-      output.push(generateDefinition(gvks[0], def));
+      output.push(generateDefinition(gvks[0], def, localOptions));
     }
   }
 

utils/generate/src/types.ts

@@ -35,8 +35,16 @@ export interface OutputFile {
   content: string;
 }
 
+export interface GenerateOptions {
+  baseClassName?: string;
+  baseClassImportPath?: string;
+}
+
 export interface Generator {
-  (definitions: readonly Definition[]): Promise<OutputFile[]>;
+  (
+    definitions: readonly Definition[],
+    options?: GenerateOptions
+  ): Promise<OutputFile[]>;
 }
 
 export interface SchemaTransformer {

utils/generate/src/utils.ts

@@ -1,4 +1,9 @@
-import { Generator, GroupVersionKind, OutputFile } from "./types";
+import {
+  Generator,
+  GenerateOptions,
+  GroupVersionKind,
+  OutputFile
+} from "./types";
 import { outputFile } from "fs-extra";
 import { join } from "path";
 
@@ -11,11 +16,11 @@ export class PathConflictError extends Error {
 PathConflictError.prototype.name = "PathConflictError";
 
 export function composeGenerators(generators: readonly Generator[]): Generator {
-  return async (definitions) => {
+  return async (definitions, options: GenerateOptions = {}) => {
     const fileMap = new Map<string, OutputFile>();
 
     for (const g of generators) {
-      const files = await g(definitions);
+      const files = await g(definitions, options);
 
       for (const f of files) {
         if (fileMap.has(f.path)) {