@acrool/rtk-query-codegen-openapi 0.0.2-test.0 → 0.0.2-test.2

package/src/generate.ts

@@ -30,17 +30,7 @@ import { factory } from './utils/factory';
 const generatedApiName = 'injectedRtkApi';
 const v3DocCache: Record<string, OpenAPIV3.Document> = {};
 
-// Add IUseFetcherArgs import
-const useFetcherImport = generateImportNode('@acrool/react-fetcher', {
-  IUseFetcherArgs: 'IUseFetcherArgs',
-});
-
-function defaultIsDataResponse(
-  code: string,
-  includeDefault: boolean,
-  response: OpenAPIV3.ResponseObject,
-  allResponses: OpenAPIV3.ResponsesObject
-) {
+function defaultIsDataResponse(code: string, includeDefault: boolean) {
   if (includeDefault && code === 'default') {
     return true;
   }
@@ -53,8 +43,7 @@ function getOperationName({ verb, path, operation }: Pick<OperationDefinition, '
 }
 
 function getTags({ verb, pathItem }: Pick<OperationDefinition, 'verb' | 'pathItem'>): string[] {
-  const tags = verb && pathItem[verb]?.tags ? pathItem[verb].tags : [];
-  return tags.map((tag) => tag.toString());
+  return verb ? pathItem[verb]?.tags || [] : [];
 }
 
 function patternMatches(pattern?: TextMatcher) {
@@ -235,127 +224,6 @@ export async function generateApi(
     return [...allTagTypes];
   }
 
-  function generateQueryArgType(operationDefinition: OperationDefinition): ts.TypeNode {
-    const {
-      operation: { parameters = [], requestBody },
-    } = operationDefinition;
-
-    const properties: ts.PropertySignature[] = [];
-
-    // Add body property if needed
-    if (requestBody && !isReference(requestBody)) {
-      const bodySchema = requestBody.content?.['application/json']?.schema;
-      if (bodySchema) {
-        properties.push(
-          factory.createPropertySignature(
-            undefined,
-            factory.createIdentifier('body'),
-            undefined,
-            factory.createTypeReferenceNode(factory.createIdentifier('any'), undefined)
-          )
-        );
-      }
-    }
-
-    // Add params property if needed
-    const queryParams = parameters.filter((p): p is OpenAPIV3.ParameterObject => !isReference(p) && p.in === 'query');
-    if (queryParams.length > 0) {
-      properties.push(
-        factory.createPropertySignature(
-          undefined,
-          factory.createIdentifier('params'),
-          undefined,
-          factory.createTypeLiteralNode(
-            queryParams.map((param) =>
-              factory.createPropertySignature(
-                undefined,
-                factory.createIdentifier(param.name),
-                factory.createToken(ts.SyntaxKind.QuestionToken),
-                factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
-              )
-            )
-          )
-        )
-      );
-    }
-
-    // Add headers property if needed
-    const headerParams = parameters.filter((p): p is OpenAPIV3.ParameterObject => !isReference(p) && p.in === 'header');
-    if (headerParams.length > 0) {
-      properties.push(
-        factory.createPropertySignature(
-          undefined,
-          factory.createIdentifier('headers'),
-          undefined,
-          factory.createTypeLiteralNode(
-            headerParams.map((param) =>
-              factory.createPropertySignature(
-                undefined,
-                factory.createIdentifier(param.name),
-                factory.createToken(ts.SyntaxKind.QuestionToken),
-                factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
-              )
-            )
-          )
-        )
-      );
-    }
-
-    return factory.createTypeLiteralNode([
-      factory.createPropertySignature(
-        undefined,
-        factory.createIdentifier('variables'),
-        undefined,
-        factory.createTypeLiteralNode(properties)
-      ),
-      factory.createPropertySignature(
-        undefined,
-        factory.createIdentifier('fetchOptions'),
-        factory.createToken(ts.SyntaxKind.QuestionToken),
-        factory.createTypeReferenceNode(factory.createIdentifier('any'), undefined)
-      ),
-    ]);
-  }
-
-  function generateQueryArgDefinitions(operationDefinition: OperationDefinition): QueryArgDefinitions {
-    const {
-      operation: { parameters = [], requestBody },
-    } = operationDefinition;
-
-    const queryArg: QueryArgDefinitions = {};
-
-    // Add body definition if needed
-    if (requestBody && !isReference(requestBody)) {
-      const bodySchema = requestBody.content?.['application/json']?.schema;
-      if (bodySchema) {
-        queryArg['body'] = {
-          name: 'body',
-          originalName: 'body',
-          type: factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
-          required: true,
-          origin: 'body',
-          body: requestBody,
-        };
-      }
-    }
-
-    // Add parameter definitions
-    parameters
-      .filter((p): p is OpenAPIV3.ParameterObject => !isReference(p))
-      .forEach((param) => {
-        queryArg[param.name] = {
-          name: param.name,
-          originalName: param.name,
-          type: factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-          required: param.required || false,
-          origin: 'param',
-          param,
-        };
-      });
-
-    return queryArg;
-  }
-
   function generateEndpoint({
     operationDefinition,
     overrides,
@@ -378,52 +246,171 @@ export async function generateApi(
     let ResponseType: ts.TypeNode = factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
     if (returnsJson) {
       const returnTypes = Object.entries(responses || {})
-        .map(([code, response]) =>
-          isDataResponse(code, includeDefault, response as OpenAPIV3.ResponseObject, responses as OpenAPIV3.ResponsesObject) && response
-            ? apiGen.getTypeFromResponse(response as OpenAPIV3.ResponseObject)
-            : undefined
+        .map(
+          ([code, response]) =>
+            [
+              code,
+              apiGen.resolve(response),
+              apiGen.getTypeFromResponse(response, 'readOnly') ||
+                factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),
+            ] as const
         )
-        .filter(removeUndefined);
-
-      if (returnTypes.length === 1) {
-        ResponseType = returnTypes[0];
-      } else if (returnTypes.length > 1) {
+        .filter(([status, response]) =>
+          isDataResponse(status, includeDefault, apiGen.resolve(response), responses || {})
+        )
+        .filter(([_1, _2, type]) => type !== keywordType.void)
+        .map(([code, response, type]) =>
+          ts.addSyntheticLeadingComment(
+            { ...type },
+            ts.SyntaxKind.MultiLineCommentTrivia,
+            `* status ${code} ${response.description} `,
+            false
+          )
+        );
+      if (returnTypes.length > 0) {
         ResponseType = factory.createUnionTypeNode(returnTypes);
       }
     }
 
-    const QueryArg = generateQueryArgType(operationDefinition);
-    const wrappedQueryArg = factory.createTypeReferenceNode(factory.createIdentifier('IUseFetcherArgs'), [QueryArg]);
+    const ResponseTypeName = factory.createTypeReferenceNode(
+      registerInterface(
+        factory.createTypeAliasDeclaration(
+          [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+          capitalize(operationName + operationNameSuffix + responseSuffix),
+          undefined,
+          ResponseType
+        )
+      ).name
+    );
 
-    const endpointBuilder = factory.createIdentifier('build');
+    const operationParameters = apiGen.resolveArray(operation.parameters);
+    const pathItemParameters = apiGen
+      .resolveArray(pathItem.parameters)
+      .filter((pp) => !operationParameters.some((op) => op.name === pp.name && op.in === pp.in));
 
-    const Response = factory.createTypeReferenceNode(
-      factory.createIdentifier(`${capitalize(operationName)}${responseSuffix}`),
-      undefined
+    const parameters = supportDeepObjects([...pathItemParameters, ...operationParameters]).filter(
+      argumentMatches(overrides?.parameterFilter)
     );
 
-    const queryArgDefinitions = generateQueryArgDefinitions(operationDefinition);
+    const allNames = parameters.map((p) => p.name);
+    const queryArg: QueryArgDefinitions = {};
+    function generateName(name: string, potentialPrefix: string) {
+      const isPureSnakeCase = /^[a-zA-Z][a-zA-Z0-9_]*$/.test(name);
+      // prefix with `query`, `path` or `body` if there are multiple paramters with the same name
+      const hasNamingConflict = allNames.filter((n) => n === name).length > 1;
+      if (hasNamingConflict) {
+        name = `${potentialPrefix}_${name}`;
+      }
+      // convert to camelCase if the name is pure snake_case and there are no naming conflicts
+      const camelCaseName = camelCase(name);
+      if (isPureSnakeCase && !allNames.includes(camelCaseName)) {
+        name = camelCaseName;
+      }
+      // if there are still any naming conflicts, prepend with underscore
+      while (name in queryArg) {
+        name = `_${name}`;
+      }
+      return name;
+    }
+
+    for (const param of parameters) {
+      const name = generateName(param.name, param.in);
+      queryArg[name] = {
+        origin: 'param',
+        name,
+        originalName: param.name,
+        type: apiGen.getTypeFromSchema(isReference(param) ? param : param.schema, undefined, 'writeOnly'),
+        required: param.required,
+        param,
+      };
+    }
+
+    if (requestBody) {
+      const body = apiGen.resolve(requestBody);
+      const schema = apiGen.getSchemaFromContent(body.content);
+      const type = apiGen.getTypeFromSchema(schema);
+      const schemaName = camelCase(
+        (type as any).name ||
+          getReferenceName(schema) ||
+          (typeof schema === 'object' && 'title' in schema && schema.title) ||
+          'body'
+      );
+      const name = generateName(schemaName in queryArg ? 'body' : schemaName, 'body');
+
+      queryArg[name] = {
+        origin: 'body',
+        name,
+        originalName: schemaName,
+        type: apiGen.getTypeFromSchema(schema, undefined, 'writeOnly'),
+        required: true,
+        body,
+      };
+    }
+
+    const propertyName = (name: string | ts.PropertyName): ts.PropertyName => {
+      if (typeof name === 'string') {
+        return isValidIdentifier(name) ? factory.createIdentifier(name) : factory.createStringLiteral(name);
+      }
+      return name;
+    };
+
+    const queryArgValues = Object.values(queryArg);
 
-    const extraEndpointsProps = isQuery
-      ? generateQueryEndpointProps({ operationDefinition })
-      : generateMutationEndpointProps({ operationDefinition });
+    const isFlatArg = flattenArg && queryArgValues.length === 1;
+    const QueryArg = factory.createTypeReferenceNode(
+      registerInterface(
+        factory.createTypeAliasDeclaration(
+          [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+          capitalize(operationName + operationNameSuffix + argSuffix),
+          undefined,
+          queryArgValues.length > 0
+            ? isFlatArg
+              ? withQueryComment(
+                  factory.createUnionTypeNode([
+                    queryArgValues[0].type,
+                    ...(!queryArgValues[0].required
+                      ? [factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword)]
+                      : []),
+                  ]),
+                  queryArgValues[0],
+                  false
+                )
+              : factory.createTypeLiteralNode(
+                  queryArgValues.map((def) =>
+                    withQueryComment(
+                      factory.createPropertySignature(
+                        undefined,
+                        propertyName(def.name),
+                        createQuestionToken(!def.required),
+                        def.type
+                      ),
+                      def,
+                      true
+                    )
+                  )
+                )
+            : factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword)
+        )
+      ).name
+    );
 
     return generateEndpointDefinition({
-      operationName,
+      operationName: operationNameSuffix ? capitalize(operationName + operationNameSuffix) : operationName,
       type: isQuery ? 'query' : 'mutation',
-      Response,
-      QueryArg: wrappedQueryArg,
+      Response: ResponseTypeName,
+      QueryArg,
       queryFn: generateQueryFn({
         operationDefinition,
-        queryArg: queryArgDefinitions,
-        isFlatArg: flattenArg,
+        queryArg,
         isQuery,
+        isFlatArg,
         encodePathParams,
         encodeQueryParams,
       }),
-      extraEndpointsProps,
+      extraEndpointsProps: isQuery
+        ? generateQueryEndpointProps({ operationDefinition })
+        : generateMutationEndpointProps({ operationDefinition }),
       tags,
-      endpointBuilder,
     });
   }
 
@@ -442,109 +429,80 @@ export async function generateApi(
     encodePathParams: boolean;
     encodeQueryParams: boolean;
   }) {
-    const {
-      operation: { parameters = [], requestBody },
-      path,
-      verb,
-    } = operationDefinition;
+    const { path, verb } = operationDefinition;
 
-    const bodyParameter = requestBody && !isReference(requestBody) ? requestBody.content?.['application/json']?.schema : undefined;
-    const bodyArg = bodyParameter ? queryArg['body'] : undefined;
+    const bodyParameter = Object.values(queryArg).find((def) => def.origin === 'body');
 
-    const pathParameters = parameters
-      .filter((p): p is OpenAPIV3.ParameterObject => !isReference(p) && p.in === 'path')
-      .map((param) => ({
-        name: param.name,
-        originalName: param.name,
-        type: factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-        required: param.required,
-        param,
-        origin: 'param' as const,
-      }));
+    const rootObject = factory.createIdentifier('queryArg');
 
-    const queryParameters = parameters
-      .filter((p): p is OpenAPIV3.ParameterObject => !isReference(p) && p.in === 'query')
-      .map((param) => ({
-        name: param.name,
-        originalName: param.name,
-        type: factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-        required: param.required,
-        param,
-        origin: 'param' as const,
-      }));
+    function pickParams(paramIn: string) {
+      return Object.values(queryArg).filter((def) => def.origin === 'param' && def.param.in === paramIn);
+    }
 
-    const headerParameters = parameters
-      .filter((p): p is OpenAPIV3.ParameterObject => !isReference(p) && p.in === 'header')
-      .map((param) => ({
-        name: param.name.includes('-') ? `'${param.name}'` : param.name,
-        originalName: param.name,
-        type: factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-        required: param.required,
-        param,
-        origin: 'param' as const,
-      }));
+    function createObjectLiteralProperty(parameters: QueryArgDefinition[], propertyName: string) {
+      if (parameters.length === 0) return undefined;
 
-    const rootObject = factory.createIdentifier('queryArg');
+      const properties = parameters.map((param) => {
+        const value = isFlatArg ? rootObject : accessProperty(rootObject, param.name);
 
-    const objectProperties: ts.ObjectLiteralElementLike[] = [
-      factory.createPropertyAssignment(
-        'url',
-        generatePathExpression(path, pathParameters, rootObject, isFlatArg, encodePathParams)
-      ),
-      factory.createPropertyAssignment('method', factory.createStringLiteral(verb.toUpperCase())),
-    ];
-
-    if (bodyArg) {
-      objectProperties.push(
-        factory.createPropertyAssignment(
-          'body',
-          factory.createPropertyAccessExpression(
-            factory.createPropertyAccessExpression(rootObject, factory.createIdentifier('variables')),
-            factory.createIdentifier('body')
-          )
-        )
-      );
-    }
+        const encodedValue =
+          encodeQueryParams && param.param?.in === 'query'
+            ? factory.createConditionalExpression(
+                value,
+                undefined,
+                factory.createCallExpression(factory.createIdentifier('encodeURIComponent'), undefined, [
+                  factory.createCallExpression(factory.createIdentifier('String'), undefined, [value]),
+                ]),
+                undefined,
+                factory.createIdentifier('undefined')
+              )
+            : value;
 
-    if (queryParameters.length) {
-      objectProperties.push(
-        factory.createPropertyAssignment(
-          'params',
-          factory.createPropertyAccessExpression(
-            factory.createPropertyAccessExpression(rootObject, factory.createIdentifier('variables')),
-            factory.createIdentifier('params')
-          )
-        )
-      );
-    }
+        return createPropertyAssignment(param.originalName, encodedValue);
+      });
 
-    if (headerParameters.length) {
-      objectProperties.push(
-        factory.createPropertyAssignment(
-          'headers',
-          factory.createPropertyAccessExpression(
-            factory.createPropertyAccessExpression(rootObject, factory.createIdentifier('variables')),
-            factory.createIdentifier('headers')
-          )
-        )
+      return factory.createPropertyAssignment(
+        factory.createIdentifier(propertyName),
+        factory.createObjectLiteralExpression(properties, true)
       );
     }
 
-    // Add fetchOptions
-    objectProperties.push(
-      factory.createPropertyAssignment(
-        'fetchOptions',
-        factory.createPropertyAccessExpression(rootObject, factory.createIdentifier('fetchOptions'))
-      )
-    );
-
     return factory.createArrowFunction(
       undefined,
       undefined,
-      [factory.createParameterDeclaration(undefined, undefined, rootObject)],
+      Object.keys(queryArg).length
+        ? [factory.createParameterDeclaration(undefined, undefined, rootObject, undefined, undefined, undefined)]
+        : [],
       undefined,
       factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
-      factory.createParenthesizedExpression(factory.createObjectLiteralExpression(objectProperties, true))
+      factory.createParenthesizedExpression(
+        factory.createObjectLiteralExpression(
+          [
+            factory.createPropertyAssignment(
+              factory.createIdentifier('url'),
+              generatePathExpression(path, pickParams('path'), rootObject, isFlatArg, encodePathParams)
+            ),
+            isQuery && verb.toUpperCase() === 'GET'
+              ? undefined
+              : factory.createPropertyAssignment(
+                  factory.createIdentifier('method'),
+                  factory.createStringLiteral(verb.toUpperCase())
+                ),
+            bodyParameter === undefined
+              ? undefined
+              : factory.createPropertyAssignment(
+                  factory.createIdentifier('body'),
+                  isFlatArg
+                    ? rootObject
+                    : factory.createPropertyAccessExpression(rootObject, factory.createIdentifier(bodyParameter.name))
+                ),
+            createObjectLiteralProperty(pickParams('cookie'), 'cookies'),
+            createObjectLiteralProperty(pickParams('header'), 'headers'),
+            createObjectLiteralProperty(pickParams('query'), 'params'),
+          ].filter(removeUndefined),
+          false
+        )
+      )
     );
   }
 
@@ -571,7 +529,7 @@ function generatePathExpression(
   rootObject: ts.Identifier,
   isFlatArg: boolean,
   encodePathParams: boolean
-): ts.Expression {
+) {
   const expressions: Array<[string, string]> = [];
 
   const head = path.replace(/\{(.*?)}(.*?)(?=\{|$)/g, (_, expression, literal) => {
@@ -585,12 +543,9 @@ function generatePathExpression(
 
   return expressions.length
     ? factory.createTemplateExpression(
-        factory.createTemplateHead(head, head),
+        factory.createTemplateHead(head),
         expressions.map(([prop, literal], index) => {
-          const value = factory.createPropertyAccessExpression(
-            factory.createPropertyAccessExpression(rootObject, factory.createIdentifier('variables')),
-            factory.createIdentifier(prop)
-          );
+          const value = isFlatArg ? rootObject : accessProperty(rootObject, prop);
           const encodedValue = encodePathParams
             ? factory.createCallExpression(factory.createIdentifier('encodeURIComponent'), undefined, [
                 factory.createCallExpression(factory.createIdentifier('String'), undefined, [value]),
@@ -599,12 +554,12 @@ function generatePathExpression(
           return factory.createTemplateSpan(
             encodedValue,
             index === expressions.length - 1
-              ? factory.createTemplateTail(literal, literal)
-              : factory.createTemplateMiddle(literal, literal)
+              ? factory.createTemplateTail(literal)
+              : factory.createTemplateMiddle(literal)
           );
         })
       )
-    : factory.createStringLiteral(head);
+    : factory.createNoSubstitutionTemplateLiteral(head);
 }
 
 type QueryArgDefinition = {