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

package/lib/index.mjs

@@ -9,11 +9,17 @@ import { createRequire } from "node:module";
 import path3 from "node:path";
 
 // src/generate.ts
+import camelCase from "lodash.camelcase";
 import path2 from "node:path";
 import ApiGenerator, {
   getOperationName as _getOperationName,
+  getReferenceName,
   isReference,
-  isValidIdentifier
+  supportDeepObjects,
+  createPropertyAssignment,
+  createQuestionToken,
+  isValidIdentifier,
+  keywordType
 } from "oazapfts/generate";
 import ts4 from "typescript";
 
@@ -151,10 +157,7 @@ function generateEndpointDefinition({
     objectProperties.push(
       factory.createPropertyAssignment(
         factory.createIdentifier(type === "query" ? "providesTags" : "invalidatesTags"),
-        factory.createArrayLiteralExpression(
-          tags.map((tag) => factory.createStringLiteral(tag)),
-          false
-        )
+        factory.createArrayLiteralExpression(tags.map((tag) => factory.createStringLiteral(tag), false))
       )
     );
   }
@@ -356,10 +359,7 @@ var generateReactHooks = ({
 // src/generate.ts
 var generatedApiName = "injectedRtkApi";
 var v3DocCache = {};
-var useFetcherImport = generateImportNode("@acrool/react-fetcher", {
-  IUseFetcherArgs: "IUseFetcherArgs"
-});
-function defaultIsDataResponse(code, includeDefault, response, allResponses) {
+function defaultIsDataResponse(code, includeDefault) {
   if (includeDefault && code === "default") {
     return true;
   }
@@ -370,8 +370,7 @@ function getOperationName2({ verb, path: path4, operation }) {
   return _getOperationName(verb, path4, operation.operationId);
 }
 function getTags({ verb, pathItem }) {
-  const tags = verb && pathItem[verb]?.tags ? pathItem[verb].tags : [];
-  return tags.map((tag) => tag.toString());
+  return verb ? pathItem[verb]?.tags || [] : [];
 }
 function patternMatches(pattern) {
   const filters = Array.isArray(pattern) ? pattern : [pattern];
@@ -390,6 +389,26 @@ function operationMatches(pattern) {
     return checkMatch(operationName, operationDefinition);
   };
 }
+function argumentMatches(pattern) {
+  const checkMatch = typeof pattern === "function" ? pattern : patternMatches(pattern);
+  return function matcher(argumentDefinition) {
+    if (!pattern || argumentDefinition.in === "path") return true;
+    const argumentName = argumentDefinition.name;
+    return checkMatch(argumentName, argumentDefinition);
+  };
+}
+function withQueryComment(node, def, hasTrailingNewLine) {
+  const comment = def.origin === "param" ? def.param.description : def.body.description;
+  if (comment) {
+    return ts4.addSyntheticLeadingComment(
+      node,
+      ts4.SyntaxKind.MultiLineCommentTrivia,
+      `* ${comment} `,
+      hasTrailingNewLine
+    );
+  }
+  return node;
+}
 function getOverrides(operation, endpointOverrides) {
   return endpointOverrides?.find((override) => operationMatches(override.pattern)(operation));
 }
@@ -508,109 +527,6 @@ async function generateApi(spec, {
     }
     return [...allTagTypes];
   }
-  function generateQueryArgType(operationDefinition) {
-    const {
-      operation: { parameters = [], requestBody }
-    } = operationDefinition;
-    const properties = [];
-    if (requestBody && !isReference(requestBody)) {
-      const bodySchema = requestBody.content?.["application/json"]?.schema;
-      if (bodySchema) {
-        properties.push(
-          factory.createPropertySignature(
-            void 0,
-            factory.createIdentifier("body"),
-            void 0,
-            apiGen.getTypeFromSchema(bodySchema)
-          )
-        );
-      }
-    }
-    const queryParams = parameters.filter((p) => !isReference(p) && p.in === "query");
-    if (queryParams.length > 0) {
-      properties.push(
-        factory.createPropertySignature(
-          void 0,
-          factory.createIdentifier("params"),
-          void 0,
-          factory.createTypeLiteralNode(
-            queryParams.map(
-              (param) => factory.createPropertySignature(
-                void 0,
-                factory.createIdentifier(param.name),
-                param.required ? void 0 : factory.createToken(ts4.SyntaxKind.QuestionToken),
-                apiGen.getTypeFromSchema(param.schema)
-              )
-            )
-          )
-        )
-      );
-    }
-    const headerParams = parameters.filter((p) => !isReference(p) && p.in === "header");
-    if (headerParams.length > 0) {
-      properties.push(
-        factory.createPropertySignature(
-          void 0,
-          factory.createIdentifier("headers"),
-          void 0,
-          factory.createTypeLiteralNode(
-            headerParams.map(
-              (param) => factory.createPropertySignature(
-                void 0,
-                factory.createIdentifier(param.name.includes("-") ? `'${param.name}'` : param.name),
-                param.required ? void 0 : factory.createToken(ts4.SyntaxKind.QuestionToken),
-                apiGen.getTypeFromSchema(param.schema)
-              )
-            )
-          )
-        )
-      );
-    }
-    return factory.createTypeLiteralNode([
-      factory.createPropertySignature(
-        void 0,
-        factory.createIdentifier("variables"),
-        void 0,
-        factory.createTypeLiteralNode(properties)
-      ),
-      factory.createPropertySignature(
-        void 0,
-        factory.createIdentifier("fetchOptions"),
-        factory.createToken(ts4.SyntaxKind.QuestionToken),
-        factory.createTypeReferenceNode(factory.createIdentifier("any"), void 0)
-      )
-    ]);
-  }
-  function generateQueryArgDefinitions(operationDefinition) {
-    const {
-      operation: { parameters = [], requestBody }
-    } = operationDefinition;
-    const queryArg = {};
-    if (requestBody && !isReference(requestBody)) {
-      const bodySchema = requestBody.content?.["application/json"]?.schema;
-      if (bodySchema) {
-        queryArg["body"] = {
-          name: "body",
-          originalName: "body",
-          type: factory.createKeywordTypeNode(ts4.SyntaxKind.AnyKeyword),
-          required: true,
-          origin: "body",
-          body: requestBody
-        };
-      }
-    }
-    parameters.filter((p) => !isReference(p)).forEach((param) => {
-      queryArg[param.name] = {
-        name: param.name,
-        originalName: param.name,
-        type: factory.createKeywordTypeNode(ts4.SyntaxKind.StringKeyword),
-        required: param.required || false,
-        origin: "param",
-        param
-      };
-    });
-    return queryArg;
-  }
   function generateEndpoint({
     operationDefinition,
     overrides
@@ -629,42 +545,138 @@ async function generateApi(spec, {
     let ResponseType = factory.createKeywordTypeNode(ts4.SyntaxKind.UnknownKeyword);
     if (returnsJson) {
       const returnTypes = Object.entries(responses || {}).map(
-        ([code, response]) => isDataResponse(code, includeDefault, response, responses) && response ? apiGen.getTypeFromResponse(response) : void 0
-      ).filter(removeUndefined);
-      if (returnTypes.length === 1) {
-        ResponseType = returnTypes[0];
-      } else if (returnTypes.length > 1) {
+        ([code, response]) => [
+          code,
+          apiGen.resolve(response),
+          apiGen.getTypeFromResponse(response, "readOnly") || factory.createKeywordTypeNode(ts4.SyntaxKind.UndefinedKeyword)
+        ]
+      ).filter(
+        ([status, response]) => isDataResponse(status, includeDefault, apiGen.resolve(response), responses || {})
+      ).filter(([_1, _2, type]) => type !== keywordType.void).map(
+        ([code, response, type]) => ts4.addSyntheticLeadingComment(
+          { ...type },
+          ts4.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(ts4.SyntaxKind.ExportKeyword)],
+          capitalize(operationName + operationNameSuffix + responseSuffix),
+          void 0,
+          ResponseType
+        )
+      ).name
     );
-    const endpointBuilder = factory.createIdentifier("build");
-    const Response = factory.createTypeReferenceNode(
-      factory.createIdentifier(`${capitalize(operationName)}${responseSuffix}`),
-      void 0
+    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 parameters = supportDeepObjects([...pathItemParameters, ...operationParameters]).filter(
+      argumentMatches(overrides?.parameterFilter)
+    );
+    const allNames = parameters.map((p) => p.name);
+    const queryArg = {};
+    function generateName(name, potentialPrefix) {
+      const isPureSnakeCase = /^[a-zA-Z][a-zA-Z0-9_]*$/.test(name);
+      const hasNamingConflict = allNames.filter((n) => n === name).length > 1;
+      if (hasNamingConflict) {
+        name = `${potentialPrefix}_${name}`;
+      }
+      const camelCaseName = camelCase(name);
+      if (isPureSnakeCase && !allNames.includes(camelCaseName)) {
+        name = camelCaseName;
+      }
+      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, void 0, "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.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, void 0, "writeOnly"),
+        required: true,
+        body
+      };
+    }
+    const propertyName = (name) => {
+      if (typeof name === "string") {
+        return isValidIdentifier(name) ? factory.createIdentifier(name) : factory.createStringLiteral(name);
+      }
+      return name;
+    };
+    const queryArgValues = Object.values(queryArg);
+    const isFlatArg = flattenArg && queryArgValues.length === 1;
+    const QueryArg = factory.createTypeReferenceNode(
+      registerInterface(
+        factory.createTypeAliasDeclaration(
+          [factory.createModifier(ts4.SyntaxKind.ExportKeyword)],
+          capitalize(operationName + operationNameSuffix + argSuffix),
+          void 0,
+          queryArgValues.length > 0 ? isFlatArg ? withQueryComment(
+            factory.createUnionTypeNode([
+              queryArgValues[0].type,
+              ...!queryArgValues[0].required ? [factory.createKeywordTypeNode(ts4.SyntaxKind.UndefinedKeyword)] : []
+            ]),
+            queryArgValues[0],
+            false
+          ) : factory.createTypeLiteralNode(
+            queryArgValues.map(
+              (def) => withQueryComment(
+                factory.createPropertySignature(
+                  void 0,
+                  propertyName(def.name),
+                  createQuestionToken(!def.required),
+                  def.type
+                ),
+                def,
+                true
+              )
+            )
+          ) : factory.createKeywordTypeNode(ts4.SyntaxKind.VoidKeyword)
+        )
+      ).name
     );
-    const queryArgDefinitions = generateQueryArgDefinitions(operationDefinition);
-    const extraEndpointsProps = isQuery2 ? generateQueryEndpointProps({ operationDefinition }) : generateMutationEndpointProps({ operationDefinition });
     return generateEndpointDefinition({
-      operationName,
+      operationName: operationNameSuffix ? capitalize(operationName + operationNameSuffix) : operationName,
       type: isQuery2 ? "query" : "mutation",
-      Response,
-      QueryArg: wrappedQueryArg,
+      Response: ResponseTypeName,
+      QueryArg,
       queryFn: generateQueryFn({
         operationDefinition,
-        queryArg: queryArgDefinitions,
-        isFlatArg: flattenArg,
+        queryArg,
         isQuery: isQuery2,
+        isFlatArg,
         encodePathParams,
         encodeQueryParams
       }),
-      extraEndpointsProps,
-      tags,
-      endpointBuilder
+      extraEndpointsProps: isQuery2 ? generateQueryEndpointProps({ operationDefinition }) : generateMutationEndpointProps({ operationDefinition }),
+      tags
     });
   }
   function generateQueryFn({
@@ -675,91 +687,60 @@ async function generateApi(spec, {
     encodePathParams: encodePathParams2,
     encodeQueryParams: encodeQueryParams2
   }) {
-    const {
-      operation: { parameters = [], requestBody },
-      path: path4,
-      verb
-    } = operationDefinition;
-    const bodyParameter = requestBody && !isReference(requestBody) ? requestBody.content?.["application/json"]?.schema : void 0;
-    const bodyArg = bodyParameter ? queryArg["body"] : void 0;
-    const pathParameters = parameters.filter((p) => !isReference(p) && p.in === "path").map((param) => ({
-      name: param.name,
-      originalName: param.name,
-      type: factory.createKeywordTypeNode(ts4.SyntaxKind.StringKeyword),
-      required: param.required,
-      param,
-      origin: "param"
-    }));
-    const queryParameters = parameters.filter((p) => !isReference(p) && p.in === "query").map((param) => ({
-      name: param.name,
-      originalName: param.name,
-      type: factory.createKeywordTypeNode(ts4.SyntaxKind.StringKeyword),
-      required: param.required,
-      param,
-      origin: "param"
-    }));
-    const headerParameters = parameters.filter((p) => !isReference(p) && p.in === "header").map((param) => ({
-      name: param.name.includes("-") ? `'${param.name}'` : param.name,
-      originalName: param.name,
-      type: factory.createKeywordTypeNode(ts4.SyntaxKind.StringKeyword),
-      required: param.required,
-      param,
-      origin: "param"
-    }));
+    const { path: path4, verb } = operationDefinition;
+    const bodyParameter = Object.values(queryArg).find((def) => def.origin === "body");
     const rootObject = factory.createIdentifier("queryArg");
-    const objectProperties = [
-      factory.createPropertyAssignment(
-        "url",
-        generatePathExpression(path4, pathParameters, rootObject, isFlatArg, encodePathParams2)
-      ),
-      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")
-          )
-        )
-      );
+    function pickParams(paramIn) {
+      return Object.values(queryArg).filter((def) => def.origin === "param" && def.param.in === paramIn);
     }
-    if (queryParameters.length) {
-      objectProperties.push(
-        factory.createPropertyAssignment(
-          "params",
-          factory.createPropertyAccessExpression(
-            factory.createPropertyAccessExpression(rootObject, factory.createIdentifier("variables")),
-            factory.createIdentifier("params")
-          )
-        )
-      );
-    }
-    if (headerParameters.length) {
-      objectProperties.push(
-        factory.createPropertyAssignment(
-          "headers",
-          factory.createPropertyAccessExpression(
-            factory.createPropertyAccessExpression(rootObject, factory.createIdentifier("variables")),
-            factory.createIdentifier("headers")
-          )
-        )
+    function createObjectLiteralProperty(parameters, propertyName) {
+      if (parameters.length === 0) return void 0;
+      const properties = parameters.map((param) => {
+        const value = isFlatArg ? rootObject : accessProperty(rootObject, param.name);
+        const encodedValue = encodeQueryParams2 && param.param?.in === "query" ? factory.createConditionalExpression(
+          value,
+          void 0,
+          factory.createCallExpression(factory.createIdentifier("encodeURIComponent"), void 0, [
+            factory.createCallExpression(factory.createIdentifier("String"), void 0, [value])
+          ]),
+          void 0,
+          factory.createIdentifier("undefined")
+        ) : value;
+        return createPropertyAssignment(param.originalName, encodedValue);
+      });
+      return factory.createPropertyAssignment(
+        factory.createIdentifier(propertyName),
+        factory.createObjectLiteralExpression(properties, true)
       );
     }
-    objectProperties.push(
-      factory.createPropertyAssignment(
-        "fetchOptions",
-        factory.createPropertyAccessExpression(rootObject, factory.createIdentifier("fetchOptions"))
-      )
-    );
     return factory.createArrowFunction(
       void 0,
       void 0,
-      [factory.createParameterDeclaration(void 0, void 0, rootObject)],
+      Object.keys(queryArg).length ? [factory.createParameterDeclaration(void 0, void 0, rootObject, void 0, void 0, void 0)] : [],
       void 0,
       factory.createToken(ts4.SyntaxKind.EqualsGreaterThanToken),
-      factory.createParenthesizedExpression(factory.createObjectLiteralExpression(objectProperties, true))
+      factory.createParenthesizedExpression(
+        factory.createObjectLiteralExpression(
+          [
+            factory.createPropertyAssignment(
+              factory.createIdentifier("url"),
+              generatePathExpression(path4, pickParams("path"), rootObject, isFlatArg, encodePathParams2)
+            ),
+            isQuery2 && verb.toUpperCase() === "GET" ? void 0 : factory.createPropertyAssignment(
+              factory.createIdentifier("method"),
+              factory.createStringLiteral(verb.toUpperCase())
+            ),
+            bodyParameter === void 0 ? void 0 : 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
+        )
+      )
     );
   }
   function generateQueryEndpointProps({}) {
@@ -769,6 +750,9 @@ async function generateApi(spec, {
     return {};
   }
 }
+function accessProperty(rootObject, propertyName) {
+  return isValidIdentifier(propertyName) ? factory.createPropertyAccessExpression(rootObject, factory.createIdentifier(propertyName)) : factory.createElementAccessExpression(rootObject, factory.createStringLiteral(propertyName));
+}
 function generatePathExpression(path4, pathParameters, rootObject, isFlatArg, encodePathParams) {
   const expressions = [];
   const head = path4.replace(/\{(.*?)}(.*?)(?=\{|$)/g, (_, expression, literal) => {
@@ -780,21 +764,18 @@ function generatePathExpression(path4, pathParameters, rootObject, isFlatArg, en
     return "";
   });
   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"), void 0, [
         factory.createCallExpression(factory.createIdentifier("String"), void 0, [value])
       ]) : value;
       return factory.createTemplateSpan(
         encodedValue,
-        index === expressions.length - 1 ? factory.createTemplateTail(literal, literal) : factory.createTemplateMiddle(literal, literal)
+        index === expressions.length - 1 ? factory.createTemplateTail(literal) : factory.createTemplateMiddle(literal)
       );
     })
-  ) : factory.createStringLiteral(head);
+  ) : factory.createNoSubstitutionTemplateLiteral(head);
 }
 
 // src/index.ts