types

__tests__/openapi.generate.test.ts

@@ -1,10 +1,48 @@
 import { writeFileSync } from 'fs';
 
 import schema from '../__fixtures__/openapi/swagger.json';
+import { getDefaultSchemaTSOptions } from '../src';
 import { generateOpenApiClient } from '../src/openapi';
 
 it('swagger', () => {
-    const code = generateOpenApiClient(schema as any);
+    const options = getDefaultSchemaTSOptions({
+        // include: [
+        //     '*.v1.*'
+        // ],
+        includeMethodComments: true,
+        namingStrategy: {
+            useLastSegment: true
+        }
+    })
+    const code = generateOpenApiClient({
+        ...options,
+        version: 'v1',
+        mergedParams: false
+    }, schema as any);
     expect(code).toMatchSnapshot();
     writeFileSync(__dirname + '/../__fixtures__/output/swagger-client.ts', code);
 });
+
+it('merged', () => {
+    const options = getDefaultSchemaTSOptions({
+        // include: [
+        //     '*.v1.*'
+        // ],
+        includeMethodComments: true,
+        namingStrategy: {
+            useLastSegment: true
+        }
+    })
+    const code = generateOpenApiClient({
+        ...options,
+        version: 'v1',
+        mergedParams: true
+    }, schema as any);
+    expect(code).toMatchSnapshot();
+    writeFileSync(__dirname + '/../__fixtures__/output/swagger-client.merged.ts', code);
+});
+
+it('openapi', () => {
+    const data = Object.keys(schema.definitions)
+    writeFileSync(__dirname + '/../__fixtures__/output/swagger-definitions.json', JSON.stringify(data, null, 2));
+});

__tests__/openapi.overrides.test.ts

@@ -102,10 +102,26 @@ const overrides = {
     }
 };
 
-it('swagger', () => {
+it('useLastSegment false', () => {
     const code = generateTypeScript(myschema as any, {
-        overrides    
+        overrides,
+        includeTypeComments: true,
+        namingStrategy: {
+          useLastSegment: false
+        }
     });
     expect(code).toMatchSnapshot();
-    writeFileSync(__dirname + '/../__fixtures__/output/swagger.overrides.ts', code);
+    writeFileSync(__dirname + '/../__fixtures__/output/swagger.overrides.all.ts', code);
+});
+
+it('useLastSegment true', () => {
+    const code = generateTypeScript(myschema as any, {
+        overrides,
+        includeTypeComments: true,
+        namingStrategy: {
+          useLastSegment: true
+        }
+    });
+    expect(code).toMatchSnapshot();
+    writeFileSync(__dirname + '/../__fixtures__/output/swagger.overrides.last.ts', code);
 });

__tests__/openapi.test.ts

@@ -15,3 +15,25 @@ it('swagger', () => {
     expect(code).toMatchSnapshot();
     writeFileSync(__dirname + '/../__fixtures__/output/swagger.ts', code);
 });
+
+it('naming', () => {
+    const code = generateTypeScript(myschema as any, {
+        exclude: [
+            '*.v1beta1.*',
+            '*.v1beta2.*',
+            '*.v2beta2.*'
+        ],
+        includeTypeComments: true,
+        namingStrategy: {
+            renameMap: {
+                'io.k8s.api.events.v1.Event': 'EventsEvent',
+                'io.k8s.api.events.v1.EventList': 'EventsEventList',
+                'io.k8s.api.events.v1.EventSeries': 'EventsEventSeries',
+                'io.k8s.api.discovery.v1.EndpointPort': 'DiscoveryEndpoint',
+                'io.k8s.kube-aggregator.pkg.apis.apiregistration.v1.ServiceReference': 'ApiServiceReference'
+            }
+        }
+    });
+    expect(code).toMatchSnapshot();
+    writeFileSync(__dirname + '/../__fixtures__/output/swagger.includes.ts', code);
+});

package.json

@@ -48,6 +48,7 @@
     "@babel/core": "^7.24.4",
     "@babel/generator": "^7.24.4",
     "@babel/types": "^7.24.0",
-    "deepmerge": "^4.3.1"
+    "deepmerge": "^4.3.1",
+    "minimatch": "^9.0.4"
   }
 }

src/context.ts

@@ -1,16 +1,32 @@
 import deepmerge from 'deepmerge';
 
-import type { JSONSchema } from "./types";
+import type { DeepPartial, JSONSchema } from "./types";
 
 export interface SchemaDefinitionOverrides {
   [key: string]: JSONSchema
 }
+
+export interface SchemaNamingStrategy {
+  useLastSegment?: boolean;
+  prefixStrip?: string | RegExp;
+  renameMap?: { [originalName: string]: string };
+}
 export interface SchemaTSOptions {
   useSingleQuotes: boolean;
   camelCase?: boolean; // defaults to false
   camelCaseFn?: (str: string) => string; // optional function to convert keys to camelCase
   strictTypeSafety: boolean;  // true uses { [k: string]: unknown; }, false uses any
   overrides?: SchemaDefinitionOverrides;
+
+  includeTypeComments?: boolean;
+  includePropertyComments?: boolean;
+  includeMethodComments?: boolean;
+
+  namingStrategy?: SchemaNamingStrategy;
+
+  // Include/Exclude types
+  include?: string[];
+  exclude?: string[];
 }
 
 export interface SchemaTSContextI {
@@ -33,7 +49,7 @@ export class SchemaTSContext implements SchemaTSContextI {
     schema: JSONSchema,
     parents: JSONSchema[] = []
   ) {
-    this.options = deepmerge(defaultOptions, options ?? {});
+    this.options = getDefaultSchemaTSOptions(options);
     this.schema = schema;
     this.root = root;
     this.parents = parents;
@@ -48,9 +64,21 @@ export class SchemaTSContext implements SchemaTSContextI {
   }
 }
 
-export const defaultOptions: SchemaTSOptions = { 
+export const defaultSchemaTSOptions: SchemaTSOptions = { 
   useSingleQuotes: true, 
   camelCase: false,
   camelCaseFn: null,
-  strictTypeSafety: true
+  strictTypeSafety: true,
+  exclude: [],
+  include: [],
+  includePropertyComments: false,
+  includeMethodComments: false,
+  includeTypeComments: false,
+  namingStrategy: {
+    useLastSegment: true
+  }
+};
+
+export const getDefaultSchemaTSOptions = (options?: DeepPartial<SchemaTSOptions>): SchemaTSOptions => {
+  return deepmerge(defaultSchemaTSOptions, options ?? {}) as SchemaTSOptions;
 };