feat: allow function/async function config, add more source types, make patch functions async

Author: mdevils

src/cli/index.ts

@@ -27,8 +27,12 @@ async function loadConfig(filename: string): Promise<ApiTypescriptGeneratorConfi
             const {register} = await import('ts-node');
             register();
         }
-        const config = await import(fullFilename);
-        return 'default' in config ? config.default : config;
+        const configImport = await import(fullFilename);
+        let config = 'default' in configImport ? configImport.default : configImport;
+        if (typeof config === 'function') {
+            config = await config();
+        }
+        return config;
     } catch (e) {
         throw new Error(`Could not load configuration file: ${e instanceof Error ? e.message : e}`);
     }

src/schema-to-typescript/config.ts

@@ -26,6 +26,20 @@ export type CommonApiToTypescriptGeneratorSource =
            * URL to the file.
            */
           url: string;
+      }
+    | {
+          type: 'object';
+          /**
+           * OpenAPI schema as an object.
+           */
+          object: unknown;
+      }
+    | {
+          type: 'string';
+          /**
+           * OpenAPI schema as a string.
+           */
+          data: string;
       };
 
 /**
@@ -44,16 +58,23 @@ export interface ApiTypescriptGeneratorConfig {
  * @param schema The schema to patch.
  * @param schemaName The name of the schema.
  */
-export type OpenApiDocumentPatchSchema = (schema: OpenApiSchema, schemaName: string) => OpenApiSchema;
+export type OpenApiDocumentPatchSchema = (
+    schema: OpenApiSchema,
+    schemaName: string
+) => OpenApiSchema | Promise<OpenApiSchema>;
 
 /**
  * Callback to patch all schemas.
  *
  * @param schemas The schemas to patch.
  */
-export type OpenApiDocumentPatchAllSchemas = (schemas: {[schemaName: string]: OpenApiSchema}) => {
-    [schemaName: string]: OpenApiSchema;
-};
+export type OpenApiDocumentPatchAllSchemas = (schemas: {[schemaName: string]: OpenApiSchema}) =>
+    | {
+          [schemaName: string]: OpenApiSchema;
+      }
+    | Promise<{
+          [schemaName: string]: OpenApiSchema;
+      }>;
 
 /**
  * Callback to patch an operation.
@@ -66,26 +87,29 @@ export type OpenApiDocumentPatchOperation = (
     operation: OpenApiOperation,
     path: string,
     httpMethod: OpenApiHttpMethod
-) => OpenApiOperation;
+) => OpenApiOperation | Promise<OpenApiOperation>;
 /**
  * Callback to patch a path item.
  *
  * @param pathItem The path item to patch.
  * @param path The path of the path item.
  */
-export type OpenApiDocumentPatchPathItem = (pathItem: OpenApiPathItem, path: string) => OpenApiPathItem;
+export type OpenApiDocumentPatchPathItem = (
+    pathItem: OpenApiPathItem,
+    path: string
+) => OpenApiPathItem | Promise<OpenApiPathItem>;
 /**
  * Callback to patch tags.
  *
  * @param tags The tags to patch.
  */
-export type OpenApiDocumentPatchTags = (tags: OpenApiTag[]) => OpenApiTag[];
+export type OpenApiDocumentPatchTags = (tags: OpenApiTag[]) => OpenApiTag[] | Promise<OpenApiTag[]>;
 /**
  * Callback to patch the whole OpenAPI document. Applies after all other patches.
  *
  * @param document The OpenAPI document to patch.
  */
-export type OpenApiDocumentPatchDocument = (document: OpenApiDocument) => OpenApiDocument;
+export type OpenApiDocumentPatchDocument = (document: OpenApiDocument) => OpenApiDocument | Promise<OpenApiDocument>;
 
 /**
  * Configuration to patch an OpenAPI document.

src/schemas/fetch-source.ts

@@ -9,11 +9,17 @@ export async function fetchSource(source: CommonApiToTypescriptGeneratorSource):
             throw new Error(`Error downloading "${source.url}": ${response.statusText}`);
         }
         return yaml.load(await response.text());
-    } else {
+    } else if (source.type === 'file') {
         try {
             return yaml.load(await fs.promises.readFile(source.path, 'utf8'));
         } catch (e) {
             throw new Error(`Error reading file "${source.path}": ${e instanceof Error ? e.message : e}`);
         }
+    } else if (source.type === 'object') {
+        return source.object;
+    } else if (source.type === 'string') {
+        return yaml.load(source.data);
+    } else {
+        throw new Error(`Unknown source type: ${(source as {type: string}).type}`);
     }
 }

src/schemas/load-open-api-document.ts

@@ -9,7 +9,7 @@ export async function loadOpenApiDocument(
 ): Promise<OpenApiDocument> {
     let document = (await fetchSource(config.source)) as OpenApiDocument;
     if (config.patch) {
-        document = patchOpenApiDocument(document, config.patch);
+        document = await patchOpenApiDocument(document, config.patch);
     }
     document = resolveDocumentReferences(processOpenApiDocument(document));
     return document;

src/schemas/patch-open-api-document.ts

@@ -3,7 +3,11 @@ import {OpenApiDocument, OpenApiHttpMethod, OpenApiOperation, OpenApiPathItem} f
 import {CommonOpenApiClientGeneratorConfigDocumentPatch} from '../schema-to-typescript/config';
 import {JsonObject, JsonValue} from '../utils/json-value';
 
-function patch<T>(document: OpenApiDocument, path: string[], patch: (data: T) => T): OpenApiDocument {
+async function patch<T>(
+    document: OpenApiDocument,
+    path: string[],
+    patch: (data: T) => T | Promise<T>
+): Promise<OpenApiDocument> {
     let currentObject = document as unknown as JsonValue;
     for (const key of path.slice(0, -1)) {
         currentObject = (currentObject as JsonObject)[key];
@@ -16,57 +20,52 @@ function patch<T>(document: OpenApiDocument, path: string[], patch: (data: T) =>
         }
     }
     const lastPathItem = path[path.length - 1];
-    (currentObject as JsonObject)[lastPathItem] = patch((currentObject as JsonObject)[lastPathItem] as T) as JsonValue;
+    (currentObject as JsonObject)[lastPathItem] = (await patch(
+        (currentObject as JsonObject)[lastPathItem] as T
+    )) as JsonValue;
     return document;
 }
 
-export function patchOpenApiDocument(
+export async function patchOpenApiDocument(
     document: OpenApiDocument,
     config: CommonOpenApiClientGeneratorConfigDocumentPatch
-): OpenApiDocument {
+): Promise<OpenApiDocument> {
     let result = document;
     if (config.patchPaths) {
         if (typeof config.patchPaths === 'function') {
-            result = patch(result, ['paths'], config.patchPaths);
+            result = await patch(result, ['paths'], config.patchPaths);
         } else {
             for (const [path, pathItemPatch] of Object.entries(config.patchPaths)) {
                 if (typeof pathItemPatch === 'function') {
-                    result = patch(
-                        result,
-                        ['paths', path],
-                        (pathItem: OpenApiPathItem): OpenApiPathItem => pathItemPatch(pathItem, path)
+                    result = await patch(result, ['paths', path], (pathItem: OpenApiPathItem) =>
+                        pathItemPatch(pathItem, path)
                     );
                 } else {
                     for (const [method, methodPatch] of Object.entries(pathItemPatch)) {
-                        result = patch(
-                            result,
-                            ['paths', path, method],
-                            (operation: OpenApiOperation): OpenApiOperation =>
-                                methodPatch(operation, path, method as OpenApiHttpMethod)
+                        result = await patch(result, ['paths', path, method], (operation: OpenApiOperation) =>
+                            methodPatch(operation, path, method as OpenApiHttpMethod)
                         );
                     }
                 }
             }
         }
     }
     if (config.patchTags) {
-        result = patch(result, ['tags'], config.patchTags);
+        result = await patch(result, ['tags'], config.patchTags);
     }
     if (config.patchSchemas) {
         if (typeof config.patchSchemas === 'function') {
-            result = patch(result, ['components', 'schemas'], config.patchSchemas);
+            result = await patch(result, ['components', 'schemas'], config.patchSchemas);
         } else {
             for (const [schemaName, schemaPatch] of Object.entries(config.patchSchemas)) {
-                result = patch(
-                    result,
-                    ['components', 'schemas', schemaName],
-                    (schema: OpenApiSchema): OpenApiSchema => schemaPatch(schema, schemaName)
+                result = await patch(result, ['components', 'schemas', schemaName], (schema: OpenApiSchema) =>
+                    schemaPatch(schema, schemaName)
                 );
             }
         }
     }
     if (config.patchDocument) {
-        result = config.patchDocument(result);
+        result = await config.patchDocument(result);
     }
     return result;
 }

test/pet-store/api-typescript-generator-config.ts

@@ -1,32 +1,32 @@
 import path from 'path';
 import {ApiTypescriptGeneratorConfig} from './../../src';
 
-const configuration: ApiTypescriptGeneratorConfig = {
-    generates: [
-        {
-            type: 'openapiClient',
-            document: {
-                source: {
-                    type: 'url',
-                    url: 'https://raw.githubusercontent.com/readmeio/oas-examples/main/3.1/yaml/petstore.yaml'
+export default async function (): Promise<ApiTypescriptGeneratorConfig> {
+    return {
+        generates: [
+            {
+                type: 'openapiClient',
+                document: {
+                    source: {
+                        type: 'url',
+                        url: 'https://raw.githubusercontent.com/readmeio/oas-examples/main/3.1/yaml/petstore.yaml'
+                    }
+                },
+                outputDirPath: path.join(__dirname, 'petstore-api-client'),
+                client: {
+                    name: 'PetStoreApiClient'
+                },
+                operations: {
+                    validateResponse: true,
+                    makeResponseValidationSchemasExtensible: true
+                },
+                validation: {
+                    library: 'zod'
+                },
+                postprocess: {
+                    eslint: true
                 }
-            },
-            outputDirPath: path.join(__dirname, 'petstore-api-client'),
-            client: {
-                name: 'PetStoreApiClient'
-            },
-            operations: {
-                validateResponse: true,
-                makeResponseValidationSchemasExtensible: true
-            },
-            validation: {
-                library: 'zod'
-            },
-            postprocess: {
-                eslint: true
             }
-        }
-    ]
-};
-
-export default configuration;
+        ]
+    };
+}