Merge pull request #32 from nicolas-chaulet/refactor/use-options-types

refactor(types): generate types for services when useOptions is true

Author: mrlubos

README.md

@@ -49,7 +49,7 @@ $ openapi --help
     -o, --output <value>      Output directory (required)
     -c, --client <value>      HTTP client to generate [fetch, xhr, node, axios, angular] (default: "fetch")
     --name <value>            Custom client class name
-    --useOptions              Use options instead of arguments
+    --useOptions <value>      Use options instead of arguments (default: false)
     --useUnionTypes           Use union types instead of enums
     --exportCore <value>      Write core files to disk (default: true)
     --exportServices <value>  Write services to disk [true, false, regexp] (default: true)

bin/index.js

@@ -14,7 +14,7 @@ const params = program
     .requiredOption('-o, --output <value>', 'Output directory (required)')
     .option('-c, --client <value>', 'HTTP client to generate [fetch, xhr, node, axios, angular]', 'fetch')
     .option('--name <value>', 'Custom client class name')
-    .option('--useOptions', 'Use options instead of arguments')
+    .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('--exportCore <value>', 'Write core files to disk', true)
@@ -57,7 +57,7 @@ if (OpenAPI) {
         request: params.request,
         useDateType: JSON.parse(params.useDateType) === true,
         useOperationId: JSON.parse(params.useOperationId) === true,
-        useOptions: params.useOptions,
+        useOptions: JSON.parse(params.useOptions) === true,
         useUnionTypes: params.useUnionTypes,
     })
         .then(() => {

rollup.config.mjs

@@ -38,7 +38,9 @@ const handlebarsPlugin = () => ({
                     escapeEnumName: true,
                     escapeNewline: true,
                     ifdef: true,
+                    ifOperationDataOptional: true,
                     intersection: true,
+                    nameOperationDataType: true,
                     notEquals: true,
                     union: true,
                     useDateType: true,

src/client/interfaces/Operation.d.ts

@@ -3,14 +3,21 @@ import type { OperationParameters } from './OperationParameters';
 import type { OperationResponse } from './OperationResponse';
 
 export interface Operation extends OperationParameters {
-    service: string;
-    name: string;
-    summary: string | null;
-    description: string | null;
     deprecated: boolean;
+    description: string | null;
+    errors: OperationError[];
     method: string;
+    /**
+     * Method name. Methods contain the request logic.
+     */
+    name: string;
     path: string;
-    errors: OperationError[];
-    results: OperationResponse[];
     responseHeader: string | null;
+    results: OperationResponse[];
+    /**
+     * Service name, might be without postfix. This will be used to name the
+     * exported class.
+     */
+    service: string;
+    summary: string | null;
 }

src/client/interfaces/OperationParameters.d.ts

@@ -3,10 +3,10 @@ import type { OperationParameter } from './OperationParameter';
 export interface OperationParameters {
     imports: string[];
     parameters: OperationParameter[];
-    parametersPath: OperationParameter[];
-    parametersQuery: OperationParameter[];
-    parametersForm: OperationParameter[];
+    parametersBody: OperationParameter | null;
     parametersCookie: OperationParameter[];
+    parametersForm: OperationParameter[];
     parametersHeader: OperationParameter[];
-    parametersBody: OperationParameter | null;
+    parametersPath: OperationParameter[];
+    parametersQuery: OperationParameter[];
 }

src/client/interfaces/Options.d.ts

@@ -1,3 +1,6 @@
+import { HttpClient } from '../../HttpClient';
+import { Indent } from '../interfaces/Indent';
+
 export interface Options {
     autoformat?: boolean;
     clientName?: string;

src/client/interfaces/Service.d.ts

@@ -1,7 +1,7 @@
 import type { Operation } from './Operation';
 
 export interface Service {
+    imports: string[];
     name: string;
     operations: Operation[];
-    imports: string[];
 }

src/openApi/v3/parser/getContent.ts

@@ -1,4 +1,3 @@
-import { isDefined } from '../../../utils/isDefined';
 import type { Dictionary } from '../../../utils/types';
 import type { OpenApi } from '../interfaces/OpenApi';
 import type { OpenApiMediaType } from '../interfaces/OpenApiMediaType';
@@ -27,15 +26,15 @@ export const getContent = (openApi: OpenApi, content: Dictionary<OpenApiMediaTyp
             const cleanMediaType = mediaType.split(';')[0].trim();
             return BASIC_MEDIA_TYPES.includes(cleanMediaType);
         })
-        .find(mediaType => isDefined(content[mediaType]?.schema));
+        .find(mediaType => Boolean(content[mediaType]?.schema));
     if (basicMediaTypeWithSchema) {
         return {
             mediaType: basicMediaTypeWithSchema,
             schema: content[basicMediaTypeWithSchema].schema as OpenApiSchema,
         };
     }
 
-    const firstMediaTypeWithSchema = Object.keys(content).find(mediaType => isDefined(content[mediaType]?.schema));
+    const firstMediaTypeWithSchema = Object.keys(content).find(mediaType => Boolean(content[mediaType]?.schema));
     if (firstMediaTypeWithSchema) {
         return {
             mediaType: firstMediaTypeWithSchema,

src/openApi/v3/parser/getOperation.ts

@@ -24,42 +24,42 @@ export const getOperation = (
     pathParams: OperationParameters,
     options: Options
 ): Operation => {
-    const serviceName = getServiceName(tag);
-    const operationName = getOperationName(url, method, options, op.operationId);
+    const service = getServiceName(tag);
+    const name = getOperationName(url, method, options, op.operationId);
 
     // Create a new operation object for this method.
     const operation: Operation = {
-        service: serviceName,
-        name: operationName,
-        summary: op.summary || null,
+        deprecated: Boolean(op.deprecated),
         description: op.description || null,
-        deprecated: op.deprecated === true,
+        errors: [],
+        imports: [],
         method: method.toUpperCase(),
-        path: url,
+        name,
         parameters: [...pathParams.parameters],
-        parametersPath: [...pathParams.parametersPath],
-        parametersQuery: [...pathParams.parametersQuery],
+        parametersBody: pathParams.parametersBody,
+        parametersCookie: [...pathParams.parametersCookie],
         parametersForm: [...pathParams.parametersForm],
         parametersHeader: [...pathParams.parametersHeader],
-        parametersCookie: [...pathParams.parametersCookie],
-        parametersBody: pathParams.parametersBody,
-        imports: [],
-        errors: [],
-        results: [],
+        parametersPath: [...pathParams.parametersPath],
+        parametersQuery: [...pathParams.parametersQuery],
+        path: url,
         responseHeader: null,
+        results: [],
+        service,
+        summary: op.summary || null,
     };
 
     // Parse the operation parameters (path, query, body, etc).
     if (op.parameters) {
         const parameters = getOperationParameters(openApi, op.parameters);
         operation.imports.push(...parameters.imports);
         operation.parameters.push(...parameters.parameters);
-        operation.parametersPath.push(...parameters.parametersPath);
-        operation.parametersQuery.push(...parameters.parametersQuery);
+        operation.parametersBody = parameters.parametersBody;
+        operation.parametersCookie.push(...parameters.parametersCookie);
         operation.parametersForm.push(...parameters.parametersForm);
         operation.parametersHeader.push(...parameters.parametersHeader);
-        operation.parametersCookie.push(...parameters.parametersCookie);
-        operation.parametersBody = parameters.parametersBody;
+        operation.parametersPath.push(...parameters.parametersPath);
+        operation.parametersQuery.push(...parameters.parametersQuery);
     }
 
     if (op.requestBody) {
@@ -78,8 +78,8 @@ export const getOperation = (
         operation.responseHeader = getOperationResponseHeader(operationResults);
 
         operationResults.forEach(operationResult => {
-            operation.results.push(operationResult);
             operation.imports.push(...operationResult.imports);
+            operation.results.push(operationResult);
         });
     }
 

src/openApi/v3/parser/getServices.ts

@@ -1,10 +1,17 @@
+import type { Operation } from '../../../client/interfaces/Operation';
 import type { Options } from '../../../client/interfaces/Options';
 import type { Service } from '../../../client/interfaces/Service';
 import { unique } from '../../../utils/unique';
 import type { OpenApi } from '../interfaces/OpenApi';
 import { getOperation } from './getOperation';
 import { getOperationParameters } from './getOperationParameters';
 
+const getNewService = (operation: Operation): Service => ({
+    imports: [],
+    name: operation.service,
+    operations: [],
+});
+
 /**
  * Get the OpenAPI services
  */
@@ -20,30 +27,21 @@ export const getServices = (openApi: OpenApi, options: Options): Service[] => {
             for (const method in path) {
                 if (path.hasOwnProperty(method)) {
                     switch (method) {
-                        case 'get':
-                        case 'put':
-                        case 'post':
                         case 'delete':
-                        case 'options':
+                        case 'get':
                         case 'head':
+                        case 'options':
                         case 'patch':
+                        case 'post':
+                        case 'put':
                             // Each method contains an OpenAPI operation, we parse the operation
                             const op = path[method]!;
                             const tags = op.tags?.length ? op.tags.filter(unique) : ['Default'];
                             tags.forEach(tag => {
                                 const operation = getOperation(openApi, url, method, tag, op, pathParams, options);
-
-                                // If we have already declared a service, then we should fetch that and
-                                // append the new method to it. Otherwise we should create a new service object.
-                                const service: Service = services.get(operation.service) || {
-                                    name: operation.service,
-                                    operations: [],
-                                    imports: [],
-                                };
-
-                                // Push the operation in the service
-                                service.operations.push(operation);
-                                service.imports.push(...operation.imports);
+                                const service = services.get(operation.service) || getNewService(operation);
+                                service.imports = [...service.imports, ...operation.imports];
+                                service.operations = [...service.operations, operation];
                                 services.set(operation.service, service);
                             });
                             break;