fix(api): add option to specify custom base path

Author: mrlubos

README.md

@@ -55,6 +55,7 @@ $ openapi --help
     --exportServices <value>  Write services to disk [true, false, regexp] (default: true)
     --exportModels <value>    Write models to disk [true, false, regexp] (default: true)
     --exportSchemas <value>   Write schemas to disk (default: false)
+    --base <value>            Manually set base in OpenAPI config instead of inferring from server value
     --indent <value>          Indentation options [4, 2, tab] (default: "4")
     --postfixServices         Service name postfix (default: "Service")
     --postfixModels           Model name postfix

bin/index.js

@@ -17,6 +17,7 @@ const params = program
     .option('--useOptions [value]', 'Use options instead of arguments', false)
     .option('--useUnionTypes', 'Use union types instead of enums')
     .option('--autoformat', 'Process generated files with autoformatter', false)
+    .option('--base [value]', 'Manually set base in OpenAPI config instead of inferring from server value')
     .option('--exportCore <value>', 'Write core files to disk', true)
     .option('--exportServices <value>', 'Write services to disk', true)
     .option('--exportModels <value>', 'Write models to disk', true)
@@ -43,24 +44,17 @@ const parseBooleanOrString = value => {
 
 if (OpenAPI) {
     OpenAPI.generate({
+        ...params,
         autoformat: JSON.parse(params.autoformat) === true,
         clientName: params.name,
         exportCore: JSON.parse(params.exportCore) === true,
         exportModels: parseBooleanOrString(params.exportModels),
         exportSchemas: JSON.parse(params.exportSchemas) === true,
         exportServices: parseBooleanOrString(params.exportServices),
         httpClient: params.client,
-        indent: params.indent,
-        input: params.input,
-        output: params.output,
-        postfixModels: params.postfixModels,
-        postfixServices: params.postfixServices,
-        request: params.request,
-        serviceResponse: params.serviceResponse,
         useDateType: JSON.parse(params.useDateType) === true,
         useOperationId: JSON.parse(params.useOperationId) === true,
         useOptions: JSON.parse(params.useOptions) === true,
-        useUnionTypes: params.useUnionTypes,
     })
         .then(() => {
             process.exit(0);

src/client/interfaces/Client.d.ts

@@ -2,8 +2,8 @@ import type { Model } from './Model';
 import type { Service } from './Service';
 
 export interface Client {
-    version: string;
-    server: string;
     models: Model[];
+    server: string;
     services: Service[];
+    version: string;
 }

src/client/interfaces/Options.d.ts

@@ -4,23 +4,84 @@ import { Indent } from '../../Indent';
 export type ServiceResponse = 'body' | 'generics' | 'response';
 
 export interface Options {
+    /**
+     * Process generated files with autoformatter
+     */
     autoformat?: boolean;
+    /**
+     * Manually set base in OpenAPI config instead of inferring from server value
+     */
+    base?: string;
+    /**
+     * Custom client class name
+     */
     clientName?: string;
+    /**
+     * Generate core client classes
+     */
     exportCore?: boolean;
+    /**
+     * Generate models
+     */
     exportModels?: boolean | string;
+    /**
+     * Generate schemas
+     */
     exportSchemas?: boolean;
+    /**
+     * Generate services
+     */
     exportServices?: boolean | string;
+    /**
+     * The selected httpClient (fetch, xhr, node or axios)
+     */
     httpClient?: HttpClient;
+    /**
+     * Indentation options (4, 2 or tab)
+     */
     indent?: Indent;
+    /**
+     * The relative location of the OpenAPI spec
+     */
     input: string | Record<string, any>;
+    /**
+     * The relative location of the output directory
+     */
     output: string;
+    /**
+     * Model name postfix
+     */
     postfixModels?: string;
+    /**
+     * Service name postfix
+     */
     postfixServices?: string;
+    /**
+     * Path to custom request file
+     */
     request?: string;
+    /**
+     * Define shape of returned value from service calls
+     */
     serviceResponse?: ServiceResponse;
+    /**
+     * Output Date instead of string for the format "date-time" in the models
+     */
     useDateType?: boolean;
+    /**
+     * Should the operationId be used when generating operation names?
+     */
     useOperationId?: boolean;
+    /**
+     * Use options or arguments functions
+     */
     useOptions?: boolean;
+    /**
+     * Use union types instead of enums
+     */
     useUnionTypes?: boolean;
+    /**
+     * Write the files to disk (true or false)
+     */
     write?: boolean;
 }

src/index.ts

@@ -1,11 +1,8 @@
 import type { Options } from './client/interfaces/Options';
 import { HttpClient } from './HttpClient';
 import { Indent } from './Indent';
-import { parse as parseV2 } from './openApi/v2';
-import { parse as parseV3 } from './openApi/v3';
 import { getOpenApiSpec } from './utils/getOpenApiSpec';
-import { getOpenApiVersion, OpenApiVersion } from './utils/getOpenApiVersion';
-import { isString } from './utils/isString';
+import { getOpenApiSpecParser } from './utils/getOpenApiSpecParser';
 import { postProcessClient } from './utils/postProcessClient';
 import { registerHandlebarTemplates } from './utils/registerHandlebarTemplates';
 import { writeClient } from './utils/writeClient';
@@ -17,25 +14,7 @@ export { Indent } from './Indent';
  * Generate the OpenAPI client. This method will read the OpenAPI specification and based on the
  * given language it will generate the client, including the typed models, validation schemas,
  * service layer, etc.
- * @param autoformat Process generated files with autoformatter
- * @param clientName Custom client class name
- * @param exportCore Generate core client classes
- * @param exportModels Generate models
- * @param exportSchemas Generate schemas
- * @param exportServices Generate services
- * @param httpClient The selected httpClient (fetch, xhr, node or axios)
- * @param indent Indentation options (4, 2 or tab)
- * @param input The relative location of the OpenAPI spec
- * @param output The relative location of the output directory
- * @param postfixModels Model name postfix
- * @param postfixServices Service name postfix
- * @param request Path to custom request file
- * @param serviceResponse Define shape of returned value from service calls
- * @param useDateType Output Date instead of string for the format "date-time" in the models
- * @param useOperationId should the operationId be used when generating operation names
- * @param useOptions Use options or arguments functions
- * @param useUnionTypes Use union types instead of enums
- * @param write Write the files to disk (true or false)
+ * @param options Options passed to the generate method
  */
 export const generate = async (options: Options): Promise<void> => {
     const {
@@ -53,33 +32,15 @@ export const generate = async (options: Options): Promise<void> => {
         useUnionTypes = false,
         write = true,
     } = options;
-    const openApi = isString(options.input) ? await getOpenApiSpec(options.input) : options.input;
-    const openApiVersion = getOpenApiVersion(openApi);
+    const openApi = typeof options.input === 'string' ? await getOpenApiSpec(options.input) : options.input;
+    const parser = getOpenApiSpecParser(openApi);
     const templates = registerHandlebarTemplates({
         httpClient,
         serviceResponse,
         useUnionTypes,
         useOptions,
     });
 
-    let parser: typeof parseV2 | typeof parseV3;
-
-    switch (openApiVersion) {
-        case OpenApiVersion.V2: {
-            parser = parseV2;
-            break;
-        }
-
-        case OpenApiVersion.V3: {
-            parser = parseV3;
-            break;
-        }
-    }
-
-    if (!parser) {
-        return;
-    }
-
     const client = parser(openApi, options);
     const clientFinal = postProcessClient(client);
     if (write) {

src/openApi/v3/index.ts

@@ -18,5 +18,10 @@ export const parse = (openApi: OpenApi, options: Options): Client => {
     const models = getModels(openApi);
     const services = getServices(openApi, options);
 
-    return { version, server, models, services };
+    return {
+        models,
+        server,
+        services,
+        version,
+    };
 };

src/utils/__tests__/getOpenApiSpecParser.spec.ts

@@ -0,0 +1,33 @@
+import { getOpenApiSpecParser } from '../getOpenApiSpecParser';
+
+jest.mock('../../openApi/v2', () => ({
+    parse: 'parseV2',
+}));
+jest.mock('../../openApi/v3', () => ({
+    parse: 'parseV3',
+}));
+
+describe('getOpenApiSpecParser', () => {
+    it('returns v2 parser', () => {
+        expect(getOpenApiSpecParser({ openapi: '2' })).toEqual('parseV2');
+        expect(getOpenApiSpecParser({ openapi: '2.0' })).toEqual('parseV2');
+
+        expect(getOpenApiSpecParser({ swagger: '2' })).toEqual('parseV2');
+        expect(getOpenApiSpecParser({ swagger: '2.0' })).toEqual('parseV2');
+    });
+
+    it('returns v3 parser', () => {
+        expect(getOpenApiSpecParser({ openapi: '3' })).toEqual('parseV3');
+        expect(getOpenApiSpecParser({ openapi: '3.0' })).toEqual('parseV3');
+        expect(getOpenApiSpecParser({ openapi: '3.1.0' })).toEqual('parseV3');
+
+        expect(getOpenApiSpecParser({ swagger: '3' })).toEqual('parseV3');
+        expect(getOpenApiSpecParser({ swagger: '3.0' })).toEqual('parseV3');
+        expect(getOpenApiSpecParser({ swagger: '3.1.0' })).toEqual('parseV3');
+    });
+
+    it('throws on unknown version', () => {
+        expect(() => getOpenApiSpecParser({})).toThrow('Unsupported Open API version: "undefined"');
+        expect(() => getOpenApiSpecParser({ swagger: '4.0' })).toThrow('Unsupported Open API version: "4.0"');
+    });
+});

src/utils/getOpenApiSpecParser.ts

@@ -0,0 +1,23 @@
+import { parse as parseV2 } from '../openApi/v2';
+import { parse as parseV3 } from '../openApi/v3';
+
+type SupportedMajorVersions = '2' | '3';
+
+/**
+ * @param openApi The loaded spec
+ */
+export const getOpenApiSpecParser = (openApi: Record<string, any>): typeof parseV2 | typeof parseV3 => {
+    const versionString = openApi.swagger || openApi.openapi;
+    if (typeof versionString === 'string') {
+        const versionMajor = versionString.charAt(0) as SupportedMajorVersions;
+        switch (versionMajor) {
+            case '2':
+                return parseV2;
+            case '3':
+                return parseV3;
+            default:
+                break;
+        }
+    }
+    throw new Error(`Unsupported Open API version: "${String(versionString)}"`);
+};