@acrool/rtk-query-codegen-openapi 0.0.2-test.5 → 0.0.2-test.7

package/README.md

@@ -23,4 +23,5 @@ This is a utility library meant to be used with [RTK Query](https://redux-toolki
 
 ```bash
 yarn build && npx acrool-rtk-query-codegen-openapi ./rtk-query-codegen.config.ts
+yarn build && npx acrool-rtk-query-codegen-openapi ./rtk-query-codegen-slice.config.ts
 ```

package/lib/index.d.mts

@@ -122,6 +122,7 @@ interface OutputFileOptions extends Partial<CommonOptions> {
      * If passed as true it will generate TS enums instead of union of strings
      */
     useEnumType?: boolean;
+    sharedTypesFile?: string;
 }
 type EndpointOverrides = {
     pattern: EndpointMatcher;
@@ -129,13 +130,17 @@ type EndpointOverrides = {
     type: 'mutation' | 'query';
     parameterFilter: ParameterMatcher;
 }>;
-type ConfigFile = Id<Require<CommonOptions & OutputFileOptions, 'outputFile'>> | Id<Omit<CommonOptions, 'outputFile'> & {
-    outputFiles: {
-        [outputFile: string]: Omit<OutputFileOptions, 'outputFile'>;
+type OutputFilesConfig = {
+    [outputFile: string]: {
+        groupMatch: RegExp;
+        filterEndpoint: (groupName: string) => RegExp;
     };
+};
+type ConfigFile = Id<Require<CommonOptions & OutputFileOptions, 'outputFile'>> | Id<Omit<CommonOptions, 'outputFile'> & {
+    outputFiles: OutputFilesConfig;
 }>;
 
 declare function generateEndpoints(options: GenerationOptions): Promise<string | void>;
 declare function parseConfig(fullConfig: ConfigFile): (CommonOptions & OutputFileOptions)[];
 
-export { type ConfigFile, generateEndpoints, parseConfig };
+export { type ConfigFile, type OutputFilesConfig, generateEndpoints, parseConfig };

package/lib/index.d.ts

@@ -122,6 +122,7 @@ interface OutputFileOptions extends Partial<CommonOptions> {
      * If passed as true it will generate TS enums instead of union of strings
      */
     useEnumType?: boolean;
+    sharedTypesFile?: string;
 }
 type EndpointOverrides = {
     pattern: EndpointMatcher;
@@ -129,13 +130,17 @@ type EndpointOverrides = {
     type: 'mutation' | 'query';
     parameterFilter: ParameterMatcher;
 }>;
-type ConfigFile = Id<Require<CommonOptions & OutputFileOptions, 'outputFile'>> | Id<Omit<CommonOptions, 'outputFile'> & {
-    outputFiles: {
-        [outputFile: string]: Omit<OutputFileOptions, 'outputFile'>;
+type OutputFilesConfig = {
+    [outputFile: string]: {
+        groupMatch: RegExp;
+        filterEndpoint: (groupName: string) => RegExp;
     };
+};
+type ConfigFile = Id<Require<CommonOptions & OutputFileOptions, 'outputFile'>> | Id<Omit<CommonOptions, 'outputFile'> & {
+    outputFiles: OutputFilesConfig;
 }>;
 
 declare function generateEndpoints(options: GenerationOptions): Promise<string | void>;
 declare function parseConfig(fullConfig: ConfigFile): (CommonOptions & OutputFileOptions)[];
 
-export { type ConfigFile, generateEndpoints, parseConfig };
+export { type ConfigFile, type OutputFilesConfig, generateEndpoints, parseConfig };

package/lib/index.js

@@ -326,14 +326,14 @@ function removeUndefined(t) {
 
 // src/generators/react-hooks.ts
 var createBinding = ({
-  operationDefinition: { verb, path: path4, operation },
+  operationDefinition: { verb, path: path4 },
   overrides,
   isLazy = false
 }) => factory.createBindingElement(
   void 0,
   void 0,
   factory.createIdentifier(
-    `use${isLazy ? "Lazy" : ""}${capitalize((0, import_generate.getOperationName)(verb, path4, operation.operationId))}${isQuery(verb, overrides) ? "Query" : "Mutation"}`
+    `use${isLazy ? "Lazy" : ""}${capitalize((0, import_generate.getOperationName)(verb, path4, void 0))}${isQuery(verb, overrides) ? "Query" : "Mutation"}`
   ),
   void 0
 );
@@ -387,8 +387,8 @@ function defaultIsDataResponse(code, includeDefault) {
   const parsedCode = Number(code);
   return !Number.isNaN(parsedCode) && parsedCode >= 200 && parsedCode < 300;
 }
-function getOperationName2({ verb, path: path4, operation }) {
-  return (0, import_generate3.getOperationName)(verb, path4, operation.operationId);
+function getOperationName2({ verb, path: path4 }) {
+  return (0, import_generate3.getOperationName)(verb, path4, void 0);
 }
 function getTags({ verb, pathItem }) {
   return verb ? pathItem[verb]?.tags || [] : [];
@@ -453,7 +453,8 @@ async function generateApi(spec, {
   includeDefault = false,
   useEnumType = false,
   mergeReadWriteOnly = false,
-  httpResolverOptions
+  httpResolverOptions,
+  sharedTypesFile
 }) {
   const v3Doc = v3DocCache[spec] ??= await getV3Doc(spec, httpResolverOptions);
   const apiGen = new import_generate3.default(v3Doc, {
@@ -461,6 +462,62 @@ async function generateApi(spec, {
     useEnumType,
     mergeReadWriteOnly
   });
+  const schemeTypeNames = /* @__PURE__ */ new Set();
+  function addSchemeTypeName(name) {
+    schemeTypeNames.add(name);
+    schemeTypeNames.add((0, import_lodash.default)(name));
+    schemeTypeNames.add(capitalize((0, import_lodash.default)(name)));
+  }
+  if (sharedTypesFile) {
+    const resultFile2 = import_typescript4.default.createSourceFile(
+      "sharedTypes.ts",
+      "",
+      import_typescript4.default.ScriptTarget.Latest,
+      /*setParentNodes*/
+      false,
+      import_typescript4.default.ScriptKind.TS
+    );
+    const printer2 = import_typescript4.default.createPrinter({ newLine: import_typescript4.default.NewLineKind.LineFeed });
+    const allTypeDefinitions = [];
+    const components = v3Doc.components;
+    if (components) {
+      const componentDefinitions = Object.entries(components).map(([componentType, componentDefs]) => {
+        const typeEntries = Object.entries(componentDefs).map(([name, def]) => {
+          addSchemeTypeName(name);
+          const typeName = capitalize((0, import_lodash.default)(name));
+          const typeNode = wrapWithSchemeIfComponent(apiGen.getTypeFromSchema(def));
+          return factory.createTypeAliasDeclaration(
+            [factory.createModifier(import_typescript4.default.SyntaxKind.ExportKeyword)],
+            factory.createIdentifier(typeName),
+            void 0,
+            typeNode
+          );
+        });
+        return factory.createModuleDeclaration(
+          [factory.createModifier(import_typescript4.default.SyntaxKind.ExportKeyword)],
+          factory.createIdentifier("Scheme"),
+          factory.createModuleBlock(typeEntries),
+          import_typescript4.default.NodeFlags.Namespace
+        );
+      });
+      allTypeDefinitions.push(...componentDefinitions);
+    }
+    if (useEnumType) {
+      allTypeDefinitions.push(...apiGen.enumAliases);
+    }
+    allTypeDefinitions.push(...apiGen.aliases);
+    const output = printer2.printNode(
+      import_typescript4.default.EmitHint.Unspecified,
+      factory.createSourceFile(
+        allTypeDefinitions,
+        factory.createToken(import_typescript4.default.SyntaxKind.EndOfFileToken),
+        import_typescript4.default.NodeFlags.None
+      ),
+      resultFile2
+    );
+    const fs2 = await import("node:fs/promises");
+    await fs2.writeFile(sharedTypesFile, output, "utf-8");
+  }
   if (apiGen.spec.components?.schemas) {
     apiGen.preprocessComponents(apiGen.spec.components.schemas);
   }
@@ -492,12 +549,18 @@ async function generateApi(spec, {
     }
   }
   apiFile = apiFile.replace(/\.[jt]sx?$/, "");
+  const sharedTypesImportPath = sharedTypesFile && outputFile ? (() => {
+    let rel = import_node_path2.default.relative(import_node_path2.default.dirname(outputFile), sharedTypesFile).replace(/\\/g, "/").replace(/\.[jt]sx?$/, "");
+    if (!rel.startsWith(".")) rel = "./" + rel;
+    return rel;
+  })() : "./shared-types";
   return printer.printNode(
     import_typescript4.default.EmitHint.Unspecified,
     factory.createSourceFile(
       [
         generateImportNode(apiFile, { [apiImport]: "api" }),
         generateImportNode("@acrool/react-fetcher", { IRestFulEndpointsQueryReturn: "IRestFulEndpointsQueryReturn" }),
+        ...sharedTypesFile ? [generateImportNode(sharedTypesImportPath, { Scheme: "Scheme" })] : [],
         ...tag ? [generateTagTypes({ addTagTypes: extractAllTagTypes({ operationDefinitions }) })] : [],
         generateCreateApiCall({
           tag,
@@ -505,7 +568,8 @@ async function generateApi(spec, {
             operationDefinitions.map(
               (operationDefinition) => generateEndpoint({
                 operationDefinition,
-                overrides: getOverrides(operationDefinition, endpointOverrides)
+                overrides: getOverrides(operationDefinition, endpointOverrides),
+                sharedTypesFile: !!sharedTypesFile
               })
             ),
             true
@@ -517,8 +581,7 @@ async function generateApi(spec, {
           factory.createIdentifier(generatedApiName)
         ),
         ...Object.values(interfaces),
-        ...apiGen.aliases,
-        ...apiGen.enumAliases,
+        ...sharedTypesFile ? [] : [...apiGen.aliases, ...apiGen.enumAliases],
         ...hooks ? [
           generateReactHooks({
             exportName: generatedApiName,
@@ -545,7 +608,8 @@ async function generateApi(spec, {
   }
   function generateEndpoint({
     operationDefinition,
-    overrides
+    overrides,
+    sharedTypesFile: sharedTypesFile2
   }) {
     const {
       verb,
@@ -554,7 +618,7 @@ async function generateApi(spec, {
       operation,
       operation: { responses, requestBody }
     } = operationDefinition;
-    const operationName = getOperationName2({ verb, path: path4, operation });
+    const operationName = getOperationName2({ verb, path: path4 });
     const tags = tag ? getTags({ verb, pathItem }) : [];
     const isQuery2 = isQuery(verb, overrides);
     const returnsJson = apiGen.getResponseType(responses) === "json";
@@ -564,18 +628,39 @@ async function generateApi(spec, {
         ([code, response]) => [
           code,
           apiGen.resolve(response),
-          apiGen.getTypeFromResponse(response, "readOnly") || factory.createKeywordTypeNode(import_typescript4.default.SyntaxKind.UndefinedKeyword)
+          wrapWithSchemeIfComponent(
+            apiGen.getTypeFromResponse(response, "readOnly") || factory.createKeywordTypeNode(import_typescript4.default.SyntaxKind.UndefinedKeyword)
+          )
         ]
       ).filter(
         ([status, response]) => isDataResponse(status, includeDefault, apiGen.resolve(response), responses || {})
-      ).filter(([_1, _2, type]) => type !== import_generate3.keywordType.void).map(
-        ([code, response, type]) => import_typescript4.default.addSyntheticLeadingComment(
-          { ...type },
+      ).filter(([_1, _2, type]) => type !== import_generate3.keywordType.void).map(([code, response, type]) => {
+        if (sharedTypesFile2 && import_typescript4.default.isTypeReferenceNode(type) && type.typeName) {
+          if (import_typescript4.default.isIdentifier(type.typeName)) {
+            const typeName = type.typeName.text;
+            if (typeName in apiGen.aliases || typeName in apiGen.enumAliases) {
+              return import_typescript4.default.addSyntheticLeadingComment(
+                factory.createTypeReferenceNode(
+                  factory.createQualifiedName(
+                    factory.createIdentifier("sharedTypes"),
+                    factory.createIdentifier((0, import_lodash.default)(typeName))
+                  ),
+                  type.typeArguments
+                ),
+                import_typescript4.default.SyntaxKind.MultiLineCommentTrivia,
+                `* status ${code} ${response.description} `,
+                false
+              );
+            }
+          }
+        }
+        return import_typescript4.default.addSyntheticLeadingComment(
+          type,
           import_typescript4.default.SyntaxKind.MultiLineCommentTrivia,
           `* status ${code} ${response.description} `,
           false
-        )
-      );
+        );
+      });
       if (returnTypes.length > 0) {
         ResponseType = factory.createUnionTypeNode(returnTypes);
       }
@@ -616,7 +701,7 @@ async function generateApi(spec, {
         origin: "param",
         name,
         originalName: param.name,
-        type: apiGen.getTypeFromSchema((0, import_generate3.isReference)(param) ? param : param.schema, void 0, "writeOnly"),
+        type: wrapWithSchemeIfComponent(apiGen.getTypeFromSchema((0, import_generate3.isReference)(param) ? param : param.schema, void 0, "writeOnly")),
         required: param.required,
         param
       };
@@ -624,7 +709,7 @@ async function generateApi(spec, {
     if (requestBody) {
       const body = apiGen.resolve(requestBody);
       const schema = apiGen.getSchemaFromContent(body.content);
-      const type = apiGen.getTypeFromSchema(schema);
+      const type = wrapWithSchemeIfComponent(apiGen.getTypeFromSchema(schema));
       const schemaName = (0, import_lodash.default)(
         type.name || (0, import_generate3.getReferenceName)(schema) || typeof schema === "object" && "title" in schema && schema.title || "body"
       );
@@ -633,7 +718,7 @@ async function generateApi(spec, {
         origin: "body",
         name,
         originalName: schemaName,
-        type: apiGen.getTypeFromSchema(schema, void 0, "writeOnly"),
+        type: wrapWithSchemeIfComponent(apiGen.getTypeFromSchema(schema, void 0, "writeOnly")),
         required: true,
         body
       };
@@ -774,6 +859,49 @@ async function generateApi(spec, {
   function generateMutationEndpointProps({}) {
     return {};
   }
+  function wrapWithSchemeIfComponent(typeNode) {
+    if (import_typescript4.default.isTypeReferenceNode(typeNode) && import_typescript4.default.isIdentifier(typeNode.typeName)) {
+      const typeName = typeNode.typeName.text;
+      if (schemeTypeNames.has(typeName)) {
+        return factory.createTypeReferenceNode(
+          factory.createQualifiedName(
+            factory.createIdentifier("Scheme"),
+            typeNode.typeName
+          ),
+          typeNode.typeArguments?.map(wrapWithSchemeIfComponent)
+        );
+      }
+      if (typeNode.typeArguments) {
+        return factory.createTypeReferenceNode(
+          typeNode.typeName,
+          typeNode.typeArguments.map(wrapWithSchemeIfComponent)
+        );
+      }
+    }
+    if (import_typescript4.default.isArrayTypeNode(typeNode)) {
+      return factory.createArrayTypeNode(wrapWithSchemeIfComponent(typeNode.elementType));
+    }
+    if (import_typescript4.default.isUnionTypeNode(typeNode)) {
+      return factory.createUnionTypeNode(typeNode.types.map(wrapWithSchemeIfComponent));
+    }
+    if (import_typescript4.default.isTypeLiteralNode(typeNode)) {
+      return factory.createTypeLiteralNode(
+        typeNode.members.map((member) => {
+          if (import_typescript4.default.isPropertySignature(member) && member.type) {
+            return factory.updatePropertySignature(
+              member,
+              member.modifiers,
+              member.name,
+              member.questionToken,
+              wrapWithSchemeIfComponent(member.type)
+            );
+          }
+          return member;
+        })
+      );
+    }
+    return typeNode;
+  }
 }
 function generatePathExpression(path4, pathParameters, rootObject, isFlatArg, encodePathParams) {
   const expressions = [];
@@ -801,7 +929,55 @@ function generatePathExpression(path4, pathParameters, rootObject, isFlatArg, en
 }
 
 // src/index.ts
+var import_lodash2 = __toESM(require("lodash.camelcase"));
 var require2 = (0, import_node_module.createRequire)(__filename);
+async function ensureDirectoryExists(filePath) {
+  const dirname = import_node_path3.default.dirname(filePath);
+  if (!import_node_fs.default.existsSync(dirname)) {
+    await import_node_fs.default.promises.mkdir(dirname, { recursive: true });
+  }
+}
+function fileExists(filePath) {
+  try {
+    return import_node_fs.default.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+function getApiNameFromDir(dirPath) {
+  const dirName = import_node_path3.default.basename(dirPath);
+  return `${dirName}Api`;
+}
+async function ensureBaseFilesExist(outputDir) {
+  const enhanceEndpointsPath = import_node_path3.default.join(outputDir, "enhanceEndpoints.ts");
+  const indexPath = import_node_path3.default.join(outputDir, "index.ts");
+  const apiName = getApiNameFromDir(outputDir);
+  if (!fileExists(enhanceEndpointsPath)) {
+    const enhanceEndpointsContent = `import api from './query.generated';
+
+const enhancedApi = api.enhanceEndpoints({
+    endpoints: {
+    },
+});
+
+export default enhancedApi;
+`;
+    await import_node_fs.default.promises.writeFile(enhanceEndpointsPath, enhanceEndpointsContent, "utf-8");
+  }
+  if (!fileExists(indexPath)) {
+    const indexContent = `export * from './query.generated';
+export {default as ${apiName}} from './enhanceEndpoints';
+`;
+    await import_node_fs.default.promises.writeFile(indexPath, indexContent, "utf-8");
+  }
+}
+function getGroupNameFromPath(path4, pattern) {
+  const match = path4.match(pattern);
+  if (match && match[1]) {
+    return (0, import_lodash2.default)(match[1]);
+  }
+  return "common";
+}
 async function generateEndpoints(options) {
   const schemaLocation = options.schemaFile;
   const schemaAbsPath = isValidUrl(options.schemaFile) ? options.schemaFile : import_node_path3.default.resolve(process.cwd(), schemaLocation);
@@ -810,8 +986,12 @@ async function generateEndpoints(options) {
   });
   const { outputFile, prettierConfigFile } = options;
   if (outputFile) {
+    const outputPath = import_node_path3.default.resolve(process.cwd(), outputFile);
+    await ensureDirectoryExists(outputPath);
+    const outputDir = import_node_path3.default.dirname(outputPath);
+    await ensureBaseFilesExist(outputDir);
     import_node_fs.default.writeFileSync(
-      import_node_path3.default.resolve(process.cwd(), outputFile),
+      outputPath,
       await prettify(outputFile, sourceCode, prettierConfigFile)
     );
   } else {
@@ -822,13 +1002,29 @@ function parseConfig(fullConfig) {
   const outFiles = [];
   if ("outputFiles" in fullConfig) {
     const { outputFiles, ...commonConfig } = fullConfig;
-    for (const [outputFile, specificConfig] of Object.entries(outputFiles)) {
+    const openApiDoc = JSON.parse(import_node_fs.default.readFileSync(fullConfig.schemaFile, "utf-8"));
+    const paths = Object.keys(openApiDoc.paths);
+    const [outputPath, config] = Object.entries(outputFiles)[0];
+    const patterns = config.groupMatch;
+    const filterEndpoint = config.filterEndpoint;
+    const pattern = patterns;
+    const groupedPaths = paths.reduce((acc, path4) => {
+      const groupName = getGroupNameFromPath(path4, pattern);
+      if (!acc[groupName]) {
+        acc[groupName] = [];
+      }
+      acc[groupName].push(path4);
+      return acc;
+    }, {});
+    Object.entries(groupedPaths).forEach(([groupName, paths2]) => {
+      const finalOutputPath = outputPath.replace("$1", groupName);
+      const filterEndpoints = filterEndpoint(groupName);
       outFiles.push({
         ...commonConfig,
-        ...specificConfig,
-        outputFile
+        outputFile: finalOutputPath,
+        filterEndpoints: [filterEndpoints]
       });
-    }
+    });
   } else {
     outFiles.push(fullConfig);
   }