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

package/src/generate.ts

@@ -38,8 +38,8 @@ function defaultIsDataResponse(code: string, includeDefault: boolean) {
   return !Number.isNaN(parsedCode) && parsedCode >= 200 && parsedCode < 300;
 }
 
-function getOperationName({ verb, path }: Pick<OperationDefinition, 'verb' | 'path' >) {
-  return _getOperationName(verb, path, undefined);
+function getOperationName({ verb, path, operation }: Pick<OperationDefinition, 'verb' | 'path' | 'operation'>) {
+  return _getOperationName(verb, path, operation.operationId);
 }
 
 function getTags({ verb, pathItem }: Pick<OperationDefinition, 'verb' | 'pathItem'>): string[] {
@@ -128,72 +128,49 @@ export async function generateApi(
     mergeReadWriteOnly,
   });
 
-  const schemeTypeNames = new Set<string>();
-
-  function addSchemeTypeName(name: string) {
-    schemeTypeNames.add(name);
-    schemeTypeNames.add(camelCase(name));
-    schemeTypeNames.add(capitalize(camelCase(name)));
-  }
-
+  // 如果提供了 sharedTypesFile，則將 components 輸出到該文件
   if (sharedTypesFile) {
-    const resultFile = ts.createSourceFile(
-      'sharedTypes.ts',
-      '',
-      ts.ScriptTarget.Latest,
-      /*setParentNodes*/ false,
-      ts.ScriptKind.TS
-    );
-    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
-
-    const allTypeDefinitions: ts.Statement[] = [];
-
     const components = v3Doc.components;
     if (components) {
-      const componentDefinitions = Object.entries(components).map(([componentType, componentDefs]) => {
-        const typeEntries = Object.entries(componentDefs as Record<string, unknown>).map(([name, def]) => {
-          addSchemeTypeName(name);
-          
-          const typeName = capitalize(camelCase(name));
-          const typeNode = wrapWithSchemeIfComponent(apiGen.getTypeFromSchema(def as OpenAPIV3.SchemaObject));
+      const resultFile = ts.createSourceFile(
+        'sharedTypes.ts',
+        '',
+        ts.ScriptTarget.Latest,
+        /*setParentNodes*/ false,
+        ts.ScriptKind.TS
+      );
+      const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+
+      // 將 components 轉換為 TypeScript 類型定義
+      const typeDefinitions = Object.entries(components).flatMap(([_, componentDefs]) => {
+        return Object.entries(componentDefs as Record<string, unknown>).map(([name, def]) => {
+          const typeNode = apiGen.getTypeFromSchema(def as OpenAPIV3.SchemaObject);
           return factory.createTypeAliasDeclaration(
             [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-            factory.createIdentifier(typeName),
+            factory.createIdentifier(name),
             undefined,
             typeNode
           );
         });
-
-        return factory.createModuleDeclaration(
-          [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-          factory.createIdentifier('Scheme'),
-          factory.createModuleBlock(typeEntries),
-          ts.NodeFlags.Namespace
-        );
       });
-      allTypeDefinitions.push(...componentDefinitions);
-    }
 
-    if (useEnumType) {
-      allTypeDefinitions.push(...apiGen.enumAliases);
-    }
-
-    allTypeDefinitions.push(...apiGen.aliases);
-
-    const output = printer.printNode(
-      ts.EmitHint.Unspecified,
-      factory.createSourceFile(
-        allTypeDefinitions,
-        factory.createToken(ts.SyntaxKind.EndOfFileToken),
-        ts.NodeFlags.None
-      ),
-      resultFile
-    );
+      const output = printer.printNode(
+        ts.EmitHint.Unspecified,
+        factory.createSourceFile(
+          typeDefinitions,
+          factory.createToken(ts.SyntaxKind.EndOfFileToken),
+          ts.NodeFlags.None
+        ),
+        resultFile
+      );
 
-    const fs = await import('node:fs/promises');
-    await fs.writeFile(sharedTypesFile, output, 'utf-8');
+      // 寫入文件
+      const fs = await import('node:fs/promises');
+      await fs.writeFile(sharedTypesFile, output, 'utf-8');
+    }
   }
 
+  // temporary workaround for https://github.com/oazapfts/oazapfts/issues/491
   if (apiGen.spec.components?.schemas) {
     apiGen.preprocessComponents(apiGen.spec.components.schemas);
   }
@@ -226,18 +203,17 @@ export async function generateApi(
       apiFile = apiFile.replace(/\\/g, '/');
       if (!apiFile.startsWith('.')) apiFile = `./${apiFile}`;
     }
+    // 處理 sharedTypesFile 的路徑
+    if (sharedTypesFile && sharedTypesFile.startsWith('.')) {
+      sharedTypesFile = path.relative(path.dirname(outputFile), sharedTypesFile);
+      sharedTypesFile = sharedTypesFile.replace(/\\/g, '/');
+      if (!sharedTypesFile.startsWith('.')) sharedTypesFile = `./${sharedTypesFile}`;
+    }
   }
   apiFile = apiFile.replace(/\.[jt]sx?$/, '');
-
-  const sharedTypesImportPath = sharedTypesFile && outputFile
-    ? (() => {
-        let rel = path.relative(path.dirname(outputFile), sharedTypesFile)
-          .replace(/\\/g, '/')
-          .replace(/\.[jt]sx?$/, '');
-        if (!rel.startsWith('.')) rel = './' + rel;
-        return rel;
-      })()
-    : './shared-types';
+  if (sharedTypesFile) {
+    sharedTypesFile = sharedTypesFile.replace(/\.[jt]sx?$/, '');
+  }
 
   return printer.printNode(
     ts.EmitHint.Unspecified,
@@ -245,7 +221,18 @@ export async function generateApi(
       [
         generateImportNode(apiFile, { [apiImport]: 'api' }),
         generateImportNode('@acrool/react-fetcher', { IRestFulEndpointsQueryReturn: 'IRestFulEndpointsQueryReturn' }),
-        ...(sharedTypesFile ? [generateImportNode(sharedTypesImportPath, { Scheme: 'Scheme' })] : []),
+        ...(sharedTypesFile ? [
+          factory.createImportDeclaration(
+            undefined,
+            factory.createImportClause(
+              false,
+              undefined,
+              factory.createNamespaceImport(factory.createIdentifier('SharedTypes'))
+            ),
+            factory.createStringLiteral(sharedTypesFile),
+            undefined
+          )
+        ] : []),
         ...(tag ? [generateTagTypes({ addTagTypes: extractAllTagTypes({ operationDefinitions }) })] : []),
         generateCreateApiCall({
           tag,
@@ -254,7 +241,6 @@ export async function generateApi(
               generateEndpoint({
                 operationDefinition,
                 overrides: getOverrides(operationDefinition, endpointOverrides),
-                sharedTypesFile: !!sharedTypesFile,
               })
             ),
             true
@@ -299,11 +285,9 @@ export async function generateApi(
   function generateEndpoint({
     operationDefinition,
     overrides,
-    sharedTypesFile,
   }: {
     operationDefinition: OperationDefinition;
     overrides?: EndpointOverrides;
-    sharedTypesFile: boolean;
   }) {
     const {
       verb,
@@ -312,56 +296,73 @@ export async function generateApi(
       operation,
       operation: { responses, requestBody },
     } = operationDefinition;
-    const operationName = getOperationName({ verb, path });
+    const operationName = getOperationName({ verb, path, operation });
     const tags = tag ? getTags({ verb, pathItem }) : [];
     const isQuery = testIsQuery(verb, overrides);
 
     const returnsJson = apiGen.getResponseType(responses) === 'json';
     let ResponseType: ts.TypeNode = factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+
+    function replaceReferences(schema: any): ts.TypeNode {
+      if (!schema) return factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+      
+      const refName = getReferenceName(schema);
+      if (refName && sharedTypesFile) {
+        return factory.createTypeReferenceNode(
+          factory.createQualifiedName(
+            factory.createIdentifier('SharedTypes'),
+            factory.createIdentifier(refName)
+          ),
+          undefined
+        );
+      }
+
+      if (schema.type === 'object' && schema.properties) {
+        const members = Object.entries(schema.properties).map(([key, value]: [string, any]) => {
+          return factory.createPropertySignature(
+            undefined,
+            factory.createIdentifier(key),
+            schema.required?.includes(key) ? undefined : factory.createToken(ts.SyntaxKind.QuestionToken),
+            replaceReferences(value)
+          );
+        });
+        return factory.createTypeLiteralNode(members);
+      }
+
+      if (schema.type === 'array' && schema.items) {
+        return factory.createArrayTypeNode(replaceReferences(schema.items));
+      }
+
+      return apiGen.getTypeFromSchema(schema);
+    }
+
     if (returnsJson) {
       const returnTypes = Object.entries(responses || {})
         .map(
-          ([code, response]) =>
-            [
-              code,
-              apiGen.resolve(response),
-              wrapWithSchemeIfComponent(
-                apiGen.getTypeFromResponse(response, 'readOnly') ||
-                  factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword)
-              ),
-            ] as const
+          ([code, response]) => {
+            const resolvedResponse = apiGen.resolve(response);
+            if (!resolvedResponse.content?.['application/json']?.schema) {
+              return [code, resolvedResponse, factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword)] as const;
+            }
+            
+            const schema = resolvedResponse.content['application/json'].schema;
+            const type = replaceReferences(schema);
+            
+            return [code, resolvedResponse, type] as const;
+          }
         )
         .filter(([status, response]) =>
           isDataResponse(status, includeDefault, apiGen.resolve(response), responses || {})
         )
         .filter(([_1, _2, type]) => type !== keywordType.void)
-        .map(([code, response, type]) => {
-          if (sharedTypesFile && ts.isTypeReferenceNode(type) && type.typeName) {
-            if (ts.isIdentifier(type.typeName)) {
-              const typeName = type.typeName.text;
-              if (typeName in apiGen.aliases || typeName in apiGen.enumAliases) {
-                return ts.addSyntheticLeadingComment(
-                  factory.createTypeReferenceNode(
-                    factory.createQualifiedName(
-                      factory.createIdentifier('sharedTypes'),
-                      factory.createIdentifier(camelCase(typeName))
-                    ),
-                    type.typeArguments
-                  ),
-                  ts.SyntaxKind.MultiLineCommentTrivia,
-                  `* status ${code} ${response.description} `,
-                  false
-                );
-              }
-            }
-          }
-          return ts.addSyntheticLeadingComment(
-            type,
+        .map(([code, response, type]) =>
+          ts.addSyntheticLeadingComment(
+            { ...type },
             ts.SyntaxKind.MultiLineCommentTrivia,
             `* status ${code} ${response.description} `,
             false
-          );
-        });
+          )
+        );
       if (returnTypes.length > 0) {
         ResponseType = factory.createUnionTypeNode(returnTypes);
       }
@@ -391,36 +392,28 @@ export async function generateApi(
     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: wrapWithSchemeIfComponent(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 = wrapWithSchemeIfComponent(apiGen.getTypeFromSchema(schema));
+      const type = replaceReferences(schema);
+
       const schemaName = camelCase(
         (type as any).name ||
           getReferenceName(schema) ||
@@ -433,12 +426,27 @@ export async function generateApi(
         origin: 'body',
         name,
         originalName: schemaName,
-        type: wrapWithSchemeIfComponent(apiGen.getTypeFromSchema(schema, undefined, 'writeOnly')),
+        type,
         required: true,
         body,
       };
     }
 
+    for (const param of parameters) {
+      const name = generateName(param.name, param.in);
+      const paramSchema = isReference(param) ? param : param.schema;
+      const type = replaceReferences(paramSchema);
+
+      queryArg[name] = {
+        origin: 'param',
+        name,
+        originalName: param.name,
+        type,
+        required: param.required,
+        param,
+      };
+    }
+
     const propertyName = (name: string | ts.PropertyName): ts.PropertyName => {
       if (typeof name === 'string') {
         return isValidIdentifier(name) ? factory.createIdentifier(name) : factory.createStringLiteral(name);
@@ -609,56 +617,14 @@ export async function generateApi(
     );
   }
 
+  // eslint-disable-next-line no-empty-pattern
   function generateQueryEndpointProps({}: { operationDefinition: OperationDefinition }): ObjectPropertyDefinitions {
-    return {};
+    return {}; /* TODO needs implementation - skip for now */
   }
 
+  // eslint-disable-next-line no-empty-pattern
   function generateMutationEndpointProps({}: { operationDefinition: OperationDefinition }): ObjectPropertyDefinitions {
-    return {};
-  }
-
-  function wrapWithSchemeIfComponent(typeNode: ts.TypeNode): ts.TypeNode {
-    if (ts.isTypeReferenceNode(typeNode) && ts.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 (ts.isArrayTypeNode(typeNode)) {
-      return factory.createArrayTypeNode(wrapWithSchemeIfComponent(typeNode.elementType));
-    }
-    if (ts.isUnionTypeNode(typeNode)) {
-      return factory.createUnionTypeNode(typeNode.types.map(wrapWithSchemeIfComponent));
-    }
-    if (ts.isTypeLiteralNode(typeNode)) {
-      return factory.createTypeLiteralNode(
-        typeNode.members.map(member => {
-          if (ts.isPropertySignature(member) && member.type) {
-            return factory.updatePropertySignature(
-              member,
-              member.modifiers,
-              member.name,
-              member.questionToken,
-              wrapWithSchemeIfComponent(member.type)
-            );
-          }
-          return member;
-        })
-      );
-    }
-    return typeNode;
+    return {}; /* TODO needs implementation - skip for now */
   }
 }
 

package/src/generators/react-hooks.ts

@@ -20,7 +20,7 @@ type CreateBindingParams = {
 };
 
 const createBinding = ({
-  operationDefinition: { verb, path },
+  operationDefinition: { verb, path, operation },
   overrides,
   isLazy = false,
 }: CreateBindingParams) =>
@@ -28,7 +28,7 @@ const createBinding = ({
     undefined,
     undefined,
     factory.createIdentifier(
-      `use${isLazy ? 'Lazy' : ''}${capitalize(getOperationName(verb, path, undefined))}${
+      `use${isLazy ? 'Lazy' : ''}${capitalize(getOperationName(verb, path, operation.operationId))}${
         isQuery(verb, overrides) ? 'Query' : 'Mutation'
       }`
     ),

package/src/index.ts

@@ -4,84 +4,10 @@ import path from 'node:path';
 import { generateApi } from './generate';
 import type { CommonOptions, ConfigFile, GenerationOptions, OutputFileOptions } from './types';
 import { isValidUrl, prettify } from './utils';
-import camelCase from 'lodash.camelcase';
-export type { OutputFilesConfig, ConfigFile } from './types';
+export type { ConfigFile } from './types';
 
 const require = createRequire(__filename);
 
-
-
-// 確保目錄存在的函數
-async function ensureDirectoryExists(filePath: string) {
-  const dirname = path.dirname(filePath);
-  if (!fs.existsSync(dirname)) {
-    await fs.promises.mkdir(dirname, { recursive: true });
-  }
-}
-
-
-// 檢查檔案是否存在的函數
-function fileExists(filePath: string): boolean {
-  try {
-    return fs.statSync(filePath).isFile();
-  } catch {
-    return false;
-  }
-}
-
-// 獲取資料夾名稱並轉換為 API 名稱
-function getApiNameFromDir(dirPath: string): string {
-  const dirName = path.basename(dirPath);
-  return `${dirName}Api`;
-}
-
-// 確保基礎文件存在的函數
-async function ensureBaseFilesExist(outputDir: string) {
-  const enhanceEndpointsPath = path.join(outputDir, 'enhanceEndpoints.ts');
-  const indexPath = path.join(outputDir, 'index.ts');
-  const apiName = getApiNameFromDir(outputDir);
-
-  // 如果 enhanceEndpoints.ts 不存在，創建它
-  if (!fileExists(enhanceEndpointsPath)) {
-    const enhanceEndpointsContent = `import api from './query.generated';
-
-const enhancedApi = api.enhanceEndpoints({
-    endpoints: {
-    },
-});
-
-export default enhancedApi;
-`;
-    await fs.promises.writeFile(enhanceEndpointsPath, enhanceEndpointsContent, 'utf-8');
-  }
-
-  // 如果 index.ts 不存在，創建它
-  if (!fileExists(indexPath)) {
-    const indexContent = `export * from './query.generated';
-export {default as ${apiName}} from './enhanceEndpoints';
-`;
-    await fs.promises.writeFile(indexPath, indexContent, 'utf-8');
-  }
-}
-
-
-// 從路徑中提取分類名稱
-function getGroupNameFromPath(path: string, pattern: RegExp): string {
-  // console.log('pattern', pattern);
-
-  const match = path.match(pattern);
-  // console.log('match', path, match);
-
-  if (match && match[1]) {
-    return camelCase(match[1]);
-  }
-  return 'common';
-}
-
-
-
-
-
 export async function generateEndpoints(options: GenerationOptions): Promise<string | void> {
   const schemaLocation = options.schemaFile;
 
@@ -94,15 +20,8 @@ export async function generateEndpoints(options: GenerationOptions): Promise<str
   });
   const { outputFile, prettierConfigFile } = options;
   if (outputFile) {
-    const outputPath = path.resolve(process.cwd(), outputFile);
-    await ensureDirectoryExists(outputPath);
-
-    // 確保基礎文件存在
-    const outputDir = path.dirname(outputPath);
-    await ensureBaseFilesExist(outputDir);
-
     fs.writeFileSync(
-      outputPath,
+      path.resolve(process.cwd(), outputFile),
       await prettify(outputFile, sourceCode, prettierConfigFile)
     );
   } else {
@@ -110,80 +29,18 @@ export async function generateEndpoints(options: GenerationOptions): Promise<str
   }
 }
 
-
 export function parseConfig(fullConfig: ConfigFile) {
   const outFiles: (CommonOptions & OutputFileOptions)[] = [];
 
   if ('outputFiles' in fullConfig) {
     const { outputFiles, ...commonConfig } = fullConfig;
-
-    // 讀取 OpenAPI 文檔
-    const openApiDoc = JSON.parse(fs.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, path) => {
-      const groupName = getGroupNameFromPath(path, pattern);
-      if (!acc[groupName]) {
-        acc[groupName] = [];
-      }
-      acc[groupName].push(path);
-      return acc;
-    }, {} as Record<string, string[]>);
-
-    // 為每個分類生成配置
-    Object.entries(groupedPaths).forEach(([groupName, paths]) => {
-      const finalOutputPath = outputPath.replace('$1', groupName);
-
-      if (filterEndpoint) {
-        // 如果有 filterEndpoint，使用基於路徑的篩選函數
-        const pathBasedFilter = (operationName: string, operationDefinition: any) => {
-          const path = operationDefinition.path;
-          
-          // 檢查路徑是否匹配當前分組
-          const pathGroupName = getGroupNameFromPath(path, pattern);
-          if (pathGroupName !== groupName) {
-            return false;
-          }
-
-          // 使用 filterEndpoint 進行額外篩選
-          const endpointFilter = filterEndpoint(groupName);
-          if (endpointFilter instanceof RegExp) {
-            return endpointFilter.test(operationName);
-          }
-
-          return true;
-        };
-
-        outFiles.push({
-          ...commonConfig,
-          outputFile: finalOutputPath,
-          filterEndpoints: pathBasedFilter,
-        });
-      } else {
-        // 如果沒有 filterEndpoint，只使用路徑分組
-        const pathBasedFilter = (operationName: string, operationDefinition: any) => {
-          const path = operationDefinition.path;
-          
-          // 檢查路徑是否匹配當前分組
-          const pathGroupName = getGroupNameFromPath(path, pattern);
-          return pathGroupName === groupName;
-        };
-
-        outFiles.push({
-          ...commonConfig,
-          outputFile: finalOutputPath,
-          filterEndpoints: pathBasedFilter,
-        });
-      }
-    });
-
+    for (const [outputFile, specificConfig] of Object.entries(outputFiles)) {
+      outFiles.push({
+        ...commonConfig,
+        ...specificConfig,
+        outputFile,
+      });
+    }
   } else {
     outFiles.push(fullConfig);
   }

package/src/types.ts

@@ -142,18 +142,10 @@ export type EndpointOverrides = {
   parameterFilter: ParameterMatcher;
 }>;
 
-export type OutputFilesConfig = {
-  [outputFile: string]: {
-      groupMatch: RegExp,
-      filterEndpoint?: (groupName: string) => RegExp
-    }
-};
-
 export type ConfigFile =
   | Id<Require<CommonOptions & OutputFileOptions, 'outputFile'>>
   | Id<
       Omit<CommonOptions, 'outputFile'> & {
-        // outputFiles: { [outputFile: string]: Omit<OutputFileOptions, 'outputFile'> };
-        outputFiles: OutputFilesConfig
+        outputFiles: { [outputFile: string]: Omit<OutputFileOptions, 'outputFile'> };
       }
     >;