@bitstack/ng-query-codegen-openapi 0.0.30 → 0.0.31-alpha.1

package/lib/index.mjs

@@ -311,6 +311,13 @@ var FileWriterService = class {
   async writeFile(filePath, content) {
     try {
       const resolvedPath = path3.resolve(process.cwd(), filePath);
+      const fileName = path3.basename(resolvedPath);
+      if (fileName === "enhanceEndpoints.ts" && fs3.existsSync(resolvedPath)) {
+        return {
+          path: resolvedPath,
+          success: true
+        };
+      }
       await ensureDirectoryExists(resolvedPath);
       fs3.writeFileSync(resolvedPath, content);
       return {
@@ -338,7 +345,7 @@ var FileWriterService = class {
     return results;
   }
   /**
-   * 為群組寫入標準檔案結構
+   * 為群組寫入 RTK Query 檔案結構
    * @param groupOutputDir - 群組輸出目錄
    * @param files - 檔案內容
    */
@@ -347,11 +354,11 @@ var FileWriterService = class {
     if (files.types) {
       filesToWrite[path3.join(groupOutputDir, "types.ts")] = files.types;
     }
-    if (files.apiService) {
-      filesToWrite[path3.join(groupOutputDir, "api.service.ts")] = files.apiService;
-    }
     if (files.queryService) {
-      filesToWrite[path3.join(groupOutputDir, "query.service.ts")] = files.queryService;
+      filesToWrite[path3.join(groupOutputDir, "query.generated.ts")] = files.queryService;
+    }
+    if (files.enhanceEndpoints) {
+      filesToWrite[path3.join(groupOutputDir, "enhanceEndpoints.ts")] = files.enhanceEndpoints;
     }
     if (files.index) {
       filesToWrite[path3.join(groupOutputDir, "index.ts")] = files.index;
@@ -368,9 +375,6 @@ var FileWriterService = class {
     if (sharedFiles.commonTypes) {
       filesToWrite[path3.join(outputDir, "common-types.ts")] = sharedFiles.commonTypes;
     }
-    if (sharedFiles.cacheKeys) {
-      filesToWrite[path3.join(outputDir, "cache-keys.ts")] = sharedFiles.cacheKeys;
-    }
     if (sharedFiles.doNotModify) {
       filesToWrite[path3.join(outputDir, "DO_NOT_MODIFY.md")] = sharedFiles.doNotModify;
     }
@@ -399,7 +403,6 @@ var OpenApiParserService = class {
     this.v3Doc = v3Doc;
     this.apiGen = new ApiGenerator(v3Doc, {
       unionUndefined: options.unionUndefined,
-      useEnumType: options.useEnumType,
       mergeReadWriteOnly: options.mergeReadWriteOnly
     });
   }
@@ -409,6 +412,12 @@ var OpenApiParserService = class {
    */
   initialize() {
     if (this.apiGen.spec.components?.schemas) {
+      Object.keys(this.apiGen.spec.components.schemas).forEach((schemaName) => {
+        const schema = this.apiGen.spec.components.schemas[schemaName];
+        if (schema && typeof schema === "object" && "title" in schema) {
+          delete schema.title;
+        }
+      });
       this.apiGen.preprocessComponents(this.apiGen.spec.components.schemas);
       Object.keys(this.apiGen.spec.components.schemas).forEach((schemaName) => {
         try {
@@ -447,64 +456,6 @@ var OpenApiParserService = class {
   }
 };
 
-// src/generators/cache-keys-generator.ts
-init_esm_shims();
-
-// src/generators/utils-generator.ts
-init_esm_shims();
-function generateUtilsFile() {
-  return `/* eslint-disable */
-// [Warning] Generated automatically - do not edit manually 
-    
-/**
-* Clear undefined in object
-*/
-export function withoutUndefined(obj?: Record<string, any>) {
-  if(typeof obj === 'undefined') return;
-  return Object.fromEntries(
-      Object.entries(obj).filter(([_, v]) => v !== undefined && v !== null)
-  );
-}
-
-`;
-}
-function toCamelCase(str) {
-  return str.toLowerCase().replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-}
-
-// src/generators/cache-keys-generator.ts
-function generateCacheKeysFile(allEndpointInfos) {
-  const groupedKeys = allEndpointInfos.reduce((acc, info) => {
-    if (!acc[info.groupKey]) {
-      acc[info.groupKey] = [];
-    }
-    acc[info.groupKey].push({
-      operationName: info.operationName,
-      queryKeyName: info.queryKeyName
-    });
-    return acc;
-  }, {});
-  const enumEntries = Object.entries(groupedKeys).map(([groupKey, keys]) => {
-    const groupComment = `  // ${groupKey.charAt(0).toUpperCase() + groupKey.slice(1)} related cache keys`;
-    const keyEntries = keys.map(
-      (key) => `  ${key.queryKeyName} = '${toCamelCase(key.queryKeyName)}',`
-    ).join("\n");
-    return `${groupComment}
-${keyEntries}`;
-  }).join("\n\n");
-  return `// [Warning] Generated automatically - do not edit manually 
-  
-/**
- * Cache keys enum for all API queries
- */
-export enum ECacheKeys {
-${enumEntries}
-}
-
-export default ECacheKeys;
-`;
-}
-
 // src/generators/common-types-generator.ts
 init_esm_shims();
 function generateCommonTypesFile() {
@@ -525,11 +476,15 @@ export interface QueryConfig {
     keepUnusedDataFor?: number,
 }
 
+export interface IRequestConfig extends RequestOptions {
+  timeout?: number;
+}
+
 export type IRestFulEndpointsQueryReturn<TVariables> = TVariables extends void ? 
-  void | {fetchOptions?: RequestOptions;config?: QueryConfig;}: 
+  (void | {fetchOptions?: IRequestConfig;}): 
   {
       variables: TVariables;
-      fetchOptions?: RequestOptions;
+      fetchOptions?: IRequestConfig;
       config?: QueryConfig;
   };
 `;
@@ -538,6 +493,19 @@ export type IRestFulEndpointsQueryReturn<TVariables> = TVariables extends void ?
 // src/generators/component-schema-generator.ts
 init_esm_shims();
 import ts from "typescript";
+function toPascalCase(name) {
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+function renameIdentifier(node, oldName, newName) {
+  return ts.transform(node, [
+    (context) => (rootNode) => ts.visitNode(rootNode, function visit(node2) {
+      if (ts.isIdentifier(node2) && node2.text === oldName) {
+        return ts.factory.createIdentifier(newName);
+      }
+      return ts.visitEachChild(node2, visit, context);
+    })
+  ]).transformed[0];
+}
 function generateComponentSchemaFile(interfaces) {
   const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
   const resultFile = ts.createSourceFile(
@@ -547,10 +515,19 @@ function generateComponentSchemaFile(interfaces) {
     false,
     ts.ScriptKind.TS
   );
+  const renamedInterfaces = [];
+  const typeNameMapping = {};
+  Object.entries(interfaces).forEach(([originalName, node]) => {
+    const pascalCaseName = toPascalCase(originalName);
+    typeNameMapping[originalName] = pascalCaseName;
+    const renamedNode = renameIdentifier(node, originalName, pascalCaseName);
+    const printed = printer.printNode(ts.EmitHint.Unspecified, renamedNode, resultFile);
+    renamedInterfaces.push(printed);
+  });
   return `/* eslint-disable */
-// [Warning] Generated automatically - do not edit manually 
-    
-${Object.values(interfaces).map((i) => printer.printNode(ts.EmitHint.Unspecified, i, resultFile)).join("\n")}
+// [Warning] Generated automatically - do not edit manually
+
+${renamedInterfaces.join("\n")}
 `;
 }
 
@@ -606,7 +583,13 @@ var EndpointInfoExtractor = class {
    */
   extractSingleEndpointInfo(operationDefinition) {
     const { verb, path: path5, operation } = operationDefinition;
-    const { operationNameSuffix = "", argSuffix = "Req", responseSuffix = "Res", queryMatch, endpointOverrides } = this.options;
+    const {
+      operationNameSuffix = "",
+      argSuffix = "Req",
+      responseSuffix = "Res",
+      queryMatch,
+      endpointOverrides
+    } = this.options;
     const operationName = getOperationName({ verb, path: path5 });
     const finalOperationName = operationNameSuffix ? capitalize(operationName + operationNameSuffix) : operationName;
     const argTypeName = capitalize(operationName + operationNameSuffix + argSuffix);
@@ -614,7 +597,9 @@ var EndpointInfoExtractor = class {
     const isQuery2 = isQuery(verb, path5, getOverrides(operationDefinition, endpointOverrides), queryMatch);
     const queryKeyName = `${operationName.replace(/([A-Z])/g, "_$1").toUpperCase()}`;
     const summary = operation.summary || `${verb.toUpperCase()} ${path5}`;
-    const { queryParams, pathParams, isVoidArg } = this.extractParameters(operationDefinition);
+    const { queryParams, pathParams, isVoidArg, hasRequestBody } = this.extractParameters(operationDefinition);
+    const contentType = this.extractContentType(operation);
+    const tags = Array.isArray(operation.tags) ? operation.tags : [];
     return {
       operationName: finalOperationName,
       argTypeName,
@@ -626,7 +611,10 @@ var EndpointInfoExtractor = class {
       queryParams,
       pathParams,
       isVoidArg,
-      summary
+      summary,
+      contentType,
+      hasRequestBody,
+      tags
     };
   }
   /**
@@ -636,15 +624,21 @@ var EndpointInfoExtractor = class {
   extractParameters(operationDefinition) {
     const { operation, pathItem } = operationDefinition;
     const operationParameters = this.resolveArray(operation.parameters);
-    const pathItemParameters = this.resolveArray(pathItem.parameters).filter((pp) => !operationParameters.some((op) => op.name === pp.name && op.in === pp.in));
-    const allParameters = supportDeepObjects([...pathItemParameters, ...operationParameters]).filter((param) => param.in !== "header");
+    const pathItemParameters = this.resolveArray(pathItem.parameters).filter(
+      (pp) => !operationParameters.some((op) => op.name === pp.name && op.in === pp.in)
+    );
+    const allParameters = supportDeepObjects([...pathItemParameters, ...operationParameters]).filter(
+      (param) => param.in !== "header"
+    );
     const queryParams = allParameters.filter((param) => param.in === "query");
     const pathParams = allParameters.filter((param) => param.in === "path");
+    const hasRequestBody = !!operation.requestBody;
     const isVoidArg = queryParams.length === 0 && pathParams.length === 0 && !operation.requestBody;
     return {
       queryParams,
       pathParams,
-      isVoidArg
+      isVoidArg,
+      hasRequestBody
     };
   }
   /**
@@ -654,11 +648,46 @@ var EndpointInfoExtractor = class {
     if (!parameters) return [];
     return Array.isArray(parameters) ? parameters : [parameters];
   }
+  /**
+   * 提取操作的 content type
+   * @param operation - 操作對象
+   */
+  extractContentType(operation) {
+    if (!operation.requestBody) {
+      return "application/json";
+    }
+    const content = operation.requestBody.content;
+    if (!content || typeof content !== "object") {
+      return "application/json";
+    }
+    const contentTypes = Object.keys(content);
+    if (contentTypes.length === 0) {
+      return "application/json";
+    }
+    return contentTypes[0];
+  }
 };
 
 // src/generators/types-generator.ts
 init_esm_shims();
+var toPascalCase2 = (name) => {
+  return name.charAt(0).toUpperCase() + name.slice(1);
+};
 function generateTypesFile(endpointInfos, _options, schemaInterfaces, operationDefinitions) {
+  const schemaTypeMap = {};
+  if (schemaInterfaces) {
+    Object.keys(schemaInterfaces).forEach((actualTypeName) => {
+      schemaTypeMap[actualTypeName] = actualTypeName;
+      if (actualTypeName.endsWith("Vo")) {
+        const openApiName = actualTypeName.slice(0, -2) + "VO";
+        schemaTypeMap[openApiName] = actualTypeName;
+      }
+      if (actualTypeName.endsWith("Dto")) {
+        const openApiName = actualTypeName.slice(0, -3) + "DTO";
+        schemaTypeMap[openApiName] = actualTypeName;
+      }
+    });
+  }
   let importStatement = `/* eslint-disable */
 // [Warning] Generated automatically - do not edit manually 
   
@@ -675,35 +704,19 @@ function generateTypesFile(endpointInfos, _options, schemaInterfaces, operationD
     const reqTypeName = endpoint.argTypeName;
     const resTypeName = endpoint.responseTypeName;
     if (reqTypeName) {
-      const requestTypeContent = generateRequestTypeContent(endpoint, operationDefinitions);
-      if (requestTypeContent.trim() === "" || requestTypeContent.includes("TODO") || requestTypeContent.includes("[key: string]: any")) {
-        endpointTypes.push(
-          `export type ${reqTypeName} = void;`,
-          ``
-        );
+      const requestTypeContent = generateRequestTypeContent(endpoint, operationDefinitions, schemaTypeMap);
+      if (requestTypeContent.trim() === "") {
+        endpointTypes.push(`export type ${reqTypeName} = void;`, ``);
       } else {
-        endpointTypes.push(
-          `export type ${reqTypeName} = {`,
-          requestTypeContent,
-          `};`,
-          ``
-        );
+        endpointTypes.push(`export type ${reqTypeName} = {`, requestTypeContent, `};`, ``);
       }
     }
     if (resTypeName) {
-      const responseTypeContent = generateResponseTypeContent(endpoint, operationDefinitions);
-      if (responseTypeContent.trim() === "" || responseTypeContent.includes("TODO") || responseTypeContent.includes("[key: string]: any")) {
-        endpointTypes.push(
-          `export type ${resTypeName} = void;`,
-          ``
-        );
+      const responseTypeContent = generateResponseTypeContent(endpoint, operationDefinitions, schemaTypeMap);
+      if (responseTypeContent.trim() === "") {
+        endpointTypes.push(`export type ${resTypeName} = void;`, ``);
       } else {
-        endpointTypes.push(
-          `export type ${resTypeName} = {`,
-          responseTypeContent,
-          `};`,
-          ``
-        );
+        endpointTypes.push(`export type ${resTypeName} = {`, responseTypeContent, `};`, ``);
       }
     }
   });
@@ -711,27 +724,23 @@ function generateTypesFile(endpointInfos, _options, schemaInterfaces, operationD
     typeDefinitions.push(endpointTypes.join("\n"));
   }
   if (typeDefinitions.length === 0) {
-    typeDefinitions.push(
-      `// \u6B64\u6A94\u6848\u7528\u65BC\u5B9A\u7FA9 API \u76F8\u95DC\u7684\u985E\u578B`,
-      `// \u985E\u578B\u5B9A\u7FA9\u6703\u6839\u64DA OpenAPI Schema \u81EA\u52D5\u751F\u6210`,
-      ``
-    );
+    typeDefinitions.push(`// \u6B64\u6A94\u6848\u7528\u65BC\u5B9A\u7FA9 API \u76F8\u95DC\u7684\u985E\u578B`, `// \u985E\u578B\u5B9A\u7FA9\u6703\u6839\u64DA OpenAPI Schema \u81EA\u52D5\u751F\u6210`, ``);
   }
   return importStatement + typeDefinitions.join("\n\n");
 }
-function generateRequestTypeContent(endpoint, operationDefinitions) {
+function generateRequestTypeContent(endpoint, operationDefinitions, schemaTypeMap = {}) {
   const properties = [];
   if (endpoint.queryParams && endpoint.queryParams.length > 0) {
     endpoint.queryParams.forEach((param) => {
       const optional = param.required ? "" : "?";
-      const paramType = getTypeFromParameter(param);
+      const paramType = getTypeFromParameter(param, schemaTypeMap);
       properties.push(`  ${param.name}${optional}: ${paramType};`);
     });
   }
   if (endpoint.pathParams && endpoint.pathParams.length > 0) {
     endpoint.pathParams.forEach((param) => {
       const optional = param.required ? "" : "?";
-      const paramType = getTypeFromParameter(param);
+      const paramType = getTypeFromParameter(param, schemaTypeMap);
       properties.push(`  ${param.name}${optional}: ${paramType};`);
     });
   }
@@ -742,16 +751,22 @@ function generateRequestTypeContent(endpoint, operationDefinitions) {
   if (operationDef?.operation?.requestBody) {
     const requestBody = operationDef.operation.requestBody;
     const content = requestBody.content;
-    const jsonContent = content["application/json"];
+    const jsonContent = content["application/json"] || content["*/*"];
     const formContent = content["multipart/form-data"] || content["application/x-www-form-urlencoded"];
     if (jsonContent?.schema) {
-      const bodyType = getTypeFromSchema(jsonContent.schema);
+      const bodyType = getTypeFromSchema(jsonContent.schema, schemaTypeMap, 1);
       properties.push(`  body: ${bodyType};`);
     } else if (formContent?.schema) {
-      const bodyType = getTypeFromSchema(formContent.schema);
+      const bodyType = getTypeFromSchema(formContent.schema, schemaTypeMap, 1);
       properties.push(`  body: ${bodyType};`);
     } else {
-      properties.push(`  body?: any; // Request body from OpenAPI`);
+      const firstContent = Object.values(content)[0];
+      if (firstContent?.schema) {
+        const bodyType = getTypeFromSchema(firstContent.schema, schemaTypeMap, 1);
+        properties.push(`  body: ${bodyType};`);
+      } else {
+        properties.push(`  body?: any; // Request body from OpenAPI`);
+      }
     }
   }
   if (properties.length === 0) {
@@ -759,7 +774,7 @@ function generateRequestTypeContent(endpoint, operationDefinitions) {
   }
   return properties.join("\n");
 }
-function generateResponseTypeContent(endpoint, operationDefinitions) {
+function generateResponseTypeContent(endpoint, operationDefinitions, schemaTypeMap = {}) {
   const properties = [];
   const operationDef = operationDefinitions?.find((op) => {
     return op.operation?.operationId === endpoint.operationName || op.operation?.operationId === endpoint.operationName.toLowerCase() || // 也嘗試匹配 verb + path 組合
@@ -768,9 +783,9 @@ function generateResponseTypeContent(endpoint, operationDefinitions) {
   if (operationDef?.operation?.responses) {
     const successResponse = operationDef.operation.responses["200"] || operationDef.operation.responses["201"];
     if (successResponse?.content) {
-      const jsonContent = successResponse.content["application/json"];
+      const jsonContent = successResponse.content["application/json"] || successResponse.content["*/*"] || Object.values(successResponse.content)[0];
       if (jsonContent?.schema) {
-        const responseProps = parseSchemaProperties(jsonContent.schema);
+        const responseProps = parseSchemaProperties(jsonContent.schema, schemaTypeMap);
         properties.push(...responseProps);
       } else {
         properties.push(`  // Success response from OpenAPI`);
@@ -783,83 +798,114 @@ function generateResponseTypeContent(endpoint, operationDefinitions) {
   }
   return properties.join("\n");
 }
-function parseSchemaProperties(schema) {
+function parseSchemaProperties(schema, schemaTypeMap = {}) {
   const properties = [];
   if (schema.type === "object" && schema.properties) {
     const required = schema.required || [];
     Object.entries(schema.properties).forEach(([propName, propSchema]) => {
       const isRequired = required.includes(propName);
       const optional = isRequired ? "" : "?";
-      const propType = getTypeFromSchema(propSchema);
-      const description = propSchema.description ? ` // ${propSchema.description}` : "";
-      properties.push(`  ${propName}${optional}: ${propType};${description}`);
+      const propType = getTypeFromSchema(propSchema, schemaTypeMap, 1);
+      const needsQuotes = /[^a-zA-Z0-9_$]/.test(propName);
+      const quotedPropName = needsQuotes ? `"${propName}"` : propName;
+      if (propSchema.description) {
+        properties.push(`  /** ${propSchema.description} */`);
+      }
+      properties.push(`  ${quotedPropName}${optional}: ${propType};`);
     });
   }
   return properties;
 }
-function getTypeFromSchema(schema) {
+function getTypeFromSchema(schema, schemaTypeMap = {}, indentLevel = 0) {
   if (!schema) return "any";
   if (schema.$ref) {
     const refPath = schema.$ref;
     if (refPath.startsWith("#/components/schemas/")) {
-      const typeName = refPath.replace("#/components/schemas/", "");
-      return `Schema.${typeName}`;
+      const originalTypeName = refPath.replace("#/components/schemas/", "");
+      const actualTypeName = schemaTypeMap[originalTypeName] || originalTypeName;
+      const pascalCaseTypeName = toPascalCase2(actualTypeName);
+      const baseType2 = `Schema.${pascalCaseTypeName}`;
+      return schema.nullable ? `${baseType2} | null` : baseType2;
     }
   }
+  let baseType;
   switch (schema.type) {
     case "string":
       if (schema.enum) {
-        return schema.enum.map((val) => `"${val}"`).join(" | ");
+        baseType = schema.enum.map((val) => `"${val}"`).join(" | ");
+      } else if (schema.format === "binary") {
+        baseType = "Blob";
+      } else {
+        baseType = "string";
       }
-      return "string";
+      break;
     case "number":
     case "integer":
-      return "number";
+      baseType = "number";
+      break;
     case "boolean":
-      return "boolean";
+      baseType = "boolean";
+      break;
     case "array":
-      const itemType = schema.items ? getTypeFromSchema(schema.items) : "any";
-      return `${itemType}[]`;
+      const itemType = schema.items ? getTypeFromSchema(schema.items, schemaTypeMap, indentLevel) : "any";
+      const needsParentheses = itemType.includes("|");
+      baseType = needsParentheses ? `(${itemType})[]` : `${itemType}[]`;
+      break;
     case "object":
       if (schema.properties) {
-        const props = Object.entries(schema.properties).map(([key, propSchema]) => {
-          const required = schema.required || [];
-          const optional = required.includes(key) ? "" : "?";
-          const type = getTypeFromSchema(propSchema);
-          return `${key}${optional}: ${type}`;
-        }).join("; ");
-        return `{ ${props} }`;
+        const entries = Object.entries(schema.properties);
+        if (entries.length === 0) {
+          if (schema.additionalProperties) {
+            const valueType = schema.additionalProperties === true ? "any" : getTypeFromSchema(schema.additionalProperties, schemaTypeMap, indentLevel);
+            baseType = `Record<string, ${valueType}>`;
+          } else {
+            baseType = "{}";
+          }
+        } else {
+          const nextIndent = "  ".repeat(indentLevel + 1);
+          const currentIndent = "  ".repeat(indentLevel);
+          const props = [];
+          entries.forEach(([key, propSchema]) => {
+            const required = schema.required || [];
+            const optional = required.includes(key) ? "" : "?";
+            const type = getTypeFromSchema(propSchema, schemaTypeMap, indentLevel + 1);
+            const needsQuotes = /[^a-zA-Z0-9_$]/.test(key);
+            const quotedKey = needsQuotes ? `"${key}"` : key;
+            if (propSchema.description) {
+              props.push(`${nextIndent}/** ${propSchema.description} */`);
+            }
+            props.push(`${nextIndent}${quotedKey}${optional}: ${type};`);
+          });
+          baseType = `{
+${props.join("\n")}
+${currentIndent}}`;
+        }
+      } else if (schema.additionalProperties) {
+        const valueType = schema.additionalProperties === true ? "any" : getTypeFromSchema(schema.additionalProperties, schemaTypeMap, indentLevel);
+        baseType = `Record<string, ${valueType}>`;
+      } else {
+        baseType = "any";
       }
-      return "any";
+      break;
     default:
-      return "any";
+      baseType = "any";
+      break;
   }
+  return schema.nullable ? `${baseType} | null` : baseType;
 }
-function getTypeFromParameter(param) {
+function getTypeFromParameter(param, schemaTypeMap = {}) {
   if (!param.schema) return "any";
-  return getTypeFromSchema(param.schema);
-}
-
-// src/generators/index-generator.ts
-init_esm_shims();
-function generateIndexFile(groupKey, options) {
-  const { groupKey: optionsGroupKey } = options;
-  return `export * from './types';
-export * from './api.service';
-export * from './query.service';
-`;
+  return getTypeFromSchema(param.schema, schemaTypeMap);
 }
 
-// src/services/query-code-generator.ts
+// src/generators/rtk-query-generator.ts
 init_esm_shims();
-
-// src/generators/query-service-generator.ts
-init_esm_shims();
-function generateQueryServiceFile(endpointInfos, options) {
+function generateRtkQueryFile(endpointInfos, options) {
   const { groupKey, refetchOnMountOrArgChange = 60 } = options;
   const queryServiceName = groupKey ? `${groupKey.charAt(0).toUpperCase() + groupKey.slice(1)}QueryService` : "QueryService";
   const apiServiceName = groupKey ? `${groupKey.charAt(0).toUpperCase() + groupKey.slice(1)}ApiService` : "ApiService";
-  const queryMethods = endpointInfos.filter((info) => info.isQuery).map((info) => `
+  const queryMethods = endpointInfos.filter((info) => info.isQuery).map(
+    (info) => `
   /**
    * ${info.summary}
    */
@@ -872,8 +918,10 @@ function generateQueryServiceFile(endpointInfos, options) {
       fetchOptions: args?.fetchOptions,
       config: args?.config,
     })${info.argTypeName !== "VoidApiArg" ? "(args)" : "()"};
-  }`).join("");
-  const mutationMethods = endpointInfos.filter((info) => !info.isQuery).map((info) => `
+  }`
+  ).join("");
+  const mutationMethods = endpointInfos.filter((info) => !info.isQuery).map(
+    (info) => `
   /**
    * ${info.summary}
    */
@@ -887,8 +935,10 @@ function generateQueryServiceFile(endpointInfos, options) {
         return this.apiService.${info.operationName}(${info.argTypeName !== "VoidApiArg" ? "args" : ""});
       },
     });
-  }`).join("");
-  const lazyQueryMethods = endpointInfos.filter((info) => info.isQuery).map((info) => `
+  }`
+  ).join("");
+  const lazyQueryMethods = endpointInfos.filter((info) => info.isQuery).map(
+    (info) => `
   /**
    * ${info.summary}
    */
@@ -907,7 +957,8 @@ function generateQueryServiceFile(endpointInfos, options) {
         return this.apiService.${info.operationName}(${info.argTypeName !== "VoidApiArg" ? "args" : ""});
       }
     };
-  }`).join("");
+  }`
+  ).join("");
   return `/* eslint-disable */
 // [Warning] Generated automatically - do not edit manually 
   
@@ -931,38 +982,15 @@ ${queryMethods}${mutationMethods}${lazyQueryMethods}
 `;
 }
 
-// src/services/query-code-generator.ts
-var QueryCodeGenerator = class {
-  constructor(options) {
-    this.options = options;
-  }
-  /**
-   * 生成 Query Service 檔案內容
-   */
-  generateQueryService(endpointInfos) {
-    const generatorOptions = {
-      ...this.options,
-      apiConfiguration: this.options.apiConfiguration || {
-        file: "@/store/webapi",
-        importName: "WebApiConfiguration"
-      }
-    };
-    return generateQueryServiceFile(endpointInfos, generatorOptions);
-  }
-};
-
-// src/services/api-service-generator.ts
-init_esm_shims();
-
-// src/generators/api-service-generator.ts
+// src/generators/rtk-enhance-endpoints-generator.ts
 init_esm_shims();
-function generateApiServiceFile(endpointInfos, options) {
+function generateRtkEnhanceEndpointsFile(endpointInfos, options) {
   const { apiConfiguration, httpClient, groupKey } = options;
   const apiServiceClassName = groupKey ? `${groupKey.charAt(0).toUpperCase() + groupKey.slice(1)}ApiService` : "ApiService";
   return `/* eslint-disable */
 // [Warning] Generated automatically - do not edit manually 
   
-import { ${httpClient.importName} } from '${httpClient.file}';
+import { ${httpClient.importReturnTypeName} } from '${httpClient.file}';
 import { Injectable, inject } from '@angular/core';
 import { Observable } from 'rxjs';
 import { ${apiConfiguration.importName} } from '${apiConfiguration.file}';
@@ -975,11 +1003,12 @@ import {${endpointInfos.map((info) => ` ${info.argTypeName}, ${info.responseType
 })
 export class ${apiServiceClassName} {
   private config = inject(${apiConfiguration.importName});
-  private http = inject(${httpClient.importName});
+  private http = inject(${httpClient.importReturnTypeName});
 
 ${endpointInfos.map((info) => {
     const isGet = info.verb.toUpperCase() === "GET";
     const hasArgs = info.argTypeName !== "VoidApiArg";
+    const hasRequestBody = info.hasRequestBody;
     const generateUrlTemplate = (path5) => {
       const hasPathParams = path5.includes("{");
       if (hasPathParams && hasArgs) {
@@ -990,21 +1019,18 @@ ${endpointInfos.map((info) => {
       }
     };
     const hasQueryParams = info.queryParams.length > 0;
-    const hasBody = !isGet && hasArgs && !info.isVoidArg;
+    const hasBody = !isGet && hasArgs;
     const generateRequestOptions = () => {
-      const options2 = [
-        "...args.fetchOptions"
-      ];
-      if (hasBody || !isGet) {
-        options2.push(`headers: { 'Content-Type': 'application/json', ...args.fetchOptions?.headers }`);
-      }
-      if (hasQueryParams && hasArgs) {
-        options2.push(generateQueryParams(info.queryParams));
+      let paramsSection = "";
+      if (info.queryParams && info.queryParams.length > 0) {
+        const paramsLines = info.queryParams.map((param) => `${param.name}: args.variables.${param.name},`).join("\n");
+        paramsSection = `params: {${paramsLines}},`;
       }
-      if (hasBody) {
-        options2.push("body: args.variables.body");
-      }
-      return options2.length > 0 ? `{ ${options2.join(", ")} }` : "{}";
+      return `{
+        ...args.fetchOptions,
+        headers: { 'Content-Type': '${info.contentType}', ...args.fetchOptions?.headers },
+        ${paramsSection}${info.hasRequestBody ? `body: args.variables.body,` : ""}
+      }`;
     };
     return `
   /**
@@ -1020,32 +1046,6 @@ ${endpointInfos.map((info) => {
 }
 `;
 }
-function generateQueryParams(queryParams) {
-  const paramEntries = queryParams.map(
-    (param) => `${param.name}: args.variables.${param.name}`
-  ).join(", ");
-  return `params: withoutUndefined({ ${paramEntries} })`;
-}
-
-// src/services/api-service-generator.ts
-var ApiServiceGenerator = class {
-  constructor(options) {
-    this.options = options;
-  }
-  /**
-   * 生成 API Service 檔案內容
-   */
-  generateApiService(endpointInfos) {
-    const generatorOptions = {
-      ...this.options,
-      apiConfiguration: this.options.apiConfiguration || {
-        file: "@/store/webapi",
-        importName: "WebApiConfiguration"
-      }
-    };
-    return generateApiServiceFile(endpointInfos, generatorOptions);
-  }
-};
 
 // src/services/api-code-generator.ts
 var ApiCodeGenerator = class {
@@ -1053,36 +1053,41 @@ var ApiCodeGenerator = class {
     this.parserService = parserService;
     this.options = options;
     this.infoExtractor = new EndpointInfoExtractor(options);
-    this.queryGenerator = new QueryCodeGenerator(options);
-    this.apiServiceGenerator = new ApiServiceGenerator(options);
   }
   infoExtractor;
-  queryGenerator;
-  apiServiceGenerator;
   /**
-   * 生成完整的 API 程式碼
+   * 生成完整的 RTK Query 程式碼
    */
   async generate() {
     const operationDefinitions = this.parserService.getOperationDefinitions(this.options.filterEndpoints);
     const endpointInfos = this.infoExtractor.extractEndpointInfos(operationDefinitions);
+    return this.generateRtkQueryCode(endpointInfos);
+  }
+  /**
+   * 生成 RTK Query 代碼
+   */
+  generateRtkQueryCode(endpointInfos) {
     const typesContent = this.generateTypes(endpointInfos);
-    const apiServiceContent = this.generateApiService(endpointInfos);
-    const queryServiceContent = this.generateQueryService(endpointInfos);
+    const rtkQueryContent = generateRtkQueryFile(endpointInfos, this.options);
+    const enhanceEndpointsContent = generateRtkEnhanceEndpointsFile(endpointInfos, this.options);
     const indexContent = this.generateIndex();
-    const allEndpointCacheKeys = endpointInfos.filter((info) => info.isQuery).map((info) => ({
-      operationName: info.operationName,
-      queryKeyName: info.queryKeyName,
-      groupKey: this.options.groupKey || "_common"
-    }));
     const operationNames = endpointInfos.map((info) => info.operationName);
+    const allTags = /* @__PURE__ */ new Set();
+    endpointInfos.forEach((info) => {
+      if (info.tags && Array.isArray(info.tags)) {
+        info.tags.forEach((tag) => allTags.add(tag));
+      }
+    });
     return {
       operationNames,
+      tags: Array.from(allTags),
       files: {
         types: typesContent,
-        apiService: apiServiceContent,
-        queryService: queryServiceContent,
+        queryService: rtkQueryContent,
+        // RTK Query 檔案
         index: indexContent,
-        allEndpointCacheKeys
+        enhanceEndpoints: enhanceEndpointsContent
+        // 新增的 enhance endpoints 檔案
       }
     };
   }
@@ -1098,43 +1103,35 @@ var ApiCodeGenerator = class {
       }
     };
     const apiGen = this.parserService.getApiGenerator();
-    const schemaInterfaces = apiGen.aliases.reduce((curr, alias) => {
-      if (ts2.isInterfaceDeclaration(alias) || ts2.isTypeAliasDeclaration(alias)) {
-        const name = alias.name.text;
-        return {
-          ...curr,
-          [name]: alias
-        };
-      }
-      return curr;
-    }, {});
+    const schemaInterfaces = apiGen.aliases.reduce(
+      (curr, alias) => {
+        if (ts2.isInterfaceDeclaration(alias) || ts2.isTypeAliasDeclaration(alias)) {
+          const name = alias.name.text;
+          return {
+            ...curr,
+            [name]: alias
+          };
+        }
+        return curr;
+      },
+      {}
+    );
     const operationDefinitions = this.parserService.getOperationDefinitions(this.options.filterEndpoints);
     return generateTypesFile(endpointInfos, generatorOptions, schemaInterfaces, operationDefinitions);
   }
-  /**
-   * 生成 API Service 檔案內容
-   */
-  generateApiService(endpointInfos) {
-    return this.apiServiceGenerator.generateApiService(endpointInfos);
-  }
-  /**
-   * 生成 Query Service 檔案內容
-   */
-  generateQueryService(endpointInfos) {
-    return this.queryGenerator.generateQueryService(endpointInfos);
-  }
   /**
    * 生成 Index 檔案內容
    */
   generateIndex() {
-    const generatorOptions = {
-      ...this.options,
-      apiConfiguration: this.options.apiConfiguration || {
-        file: "@/store/webapi",
-        importName: "WebApiConfiguration"
-      }
-    };
-    return generateIndexFile(this.options.groupKey || "", generatorOptions);
+    const groupKey = this.options.groupKey || "";
+    const exportName = groupKey ? `${groupKey.charAt(0).toLowerCase() + groupKey.slice(1)}Api` : "api";
+    return `/* eslint-disable */
+// [Warning] Generated automatically - do not edit manually
+
+export { default as ${exportName} } from "./enhanceEndpoints";
+export * from "./query.generated";
+export * from "./types";
+`;
   }
   // /**
   //  * 獲取已解析的 parser service（供外部使用）
@@ -1151,6 +1148,46 @@ var ApiCodeGenerator = class {
   // }
 };
 
+// src/generators/utils-generator.ts
+init_esm_shims();
+function generateUtilsFile() {
+  return `/* eslint-disable */
+// [Warning] Generated automatically - do not edit manually 
+    
+/**
+* Clear undefined in object
+*/
+export function withoutUndefined(obj?: Record<string, any>) {
+  if(typeof obj === 'undefined') return;
+  return Object.fromEntries(
+      Object.entries(obj).filter(([_, v]) => v !== undefined && v !== null)
+  );
+}
+
+`;
+}
+
+// src/generators/tag-types-generator.ts
+init_esm_shims();
+function generateTagTypesFile(tags) {
+  if (tags.length === 0) {
+    return `/* eslint-disable */
+// [Warning] Generated automatically - do not edit manually
+
+export enum ECacheTagTypes {
+}
+`;
+  }
+  const enumEntries = tags.sort().map((tag) => `    ${tag} = '${tag}',`).join("\n");
+  return `/* eslint-disable */
+// [Warning] Generated automatically - do not edit manually
+
+export enum ECacheTagTypes {
+${enumEntries}
+}
+`;
+}
+
 // src/services/unified-code-generator.ts
 var UnifiedCodeGenerator = class {
   _options;
@@ -1161,17 +1198,18 @@ var UnifiedCodeGenerator = class {
   openApiDoc = null;
   parserService = null;
   schemaInterfaces = {};
-  allEndpointCacheKeys = [];
   actualSchemaFile = "";
   // 生成內容存儲
   generatedContent = {
     groups: [],
-    cacheKeys: null,
     commonTypes: "",
     componentSchema: "",
     doNotModify: "",
-    utils: ""
+    utils: "",
+    tagTypes: ""
   };
+  // 收集所有 tags
+  allTags = /* @__PURE__ */ new Set();
   constructor(options) {
     this._options = options;
   }
@@ -1181,11 +1219,11 @@ var UnifiedCodeGenerator = class {
   async generateAll() {
     await this.prepare();
     await this.generateApi();
-    this.generateCacheKeysContent();
     this.generateCommonTypesContent();
     this.generateSchemaContent();
     this.generateUtilsContent();
     this.generateDoNotModifyContent();
+    this.generateTagTypesContent();
     return await this.release();
   }
   /**
@@ -1238,18 +1276,15 @@ var UnifiedCodeGenerator = class {
             outputPath: groupInfo.outputPath,
             content: groupContent
           });
+          if (groupContent.tags && Array.isArray(groupContent.tags)) {
+            groupContent.tags.forEach((tag) => this.allTags.add(tag));
+          }
         }
       } catch (error) {
         throw new Error(`\u7FA4\u7D44 ${groupInfo.groupKey} \u751F\u6210\u5931\u6557: ${error}`);
       }
     }
   }
-  /**
-   * 生成 cache keys
-   */
-  async generateCacheKeysContent() {
-    this.generatedContent.cacheKeys = generateCacheKeysFile(this.allEndpointCacheKeys);
-  }
   /**
    * 生成 common types
    */
@@ -1274,6 +1309,13 @@ var UnifiedCodeGenerator = class {
   async generateUtilsContent() {
     this.generatedContent.utils = generateUtilsFile();
   }
+  /**
+   * 生成 Tag Types
+   */
+  async generateTagTypesContent() {
+    const tagsArray = Array.from(this.allTags);
+    this.generatedContent.tagTypes = generateTagTypesFile(tagsArray);
+  }
   /**
    * 發佈階段：統一寫入所有檔案
    */
@@ -1290,8 +1332,8 @@ var UnifiedCodeGenerator = class {
               groupOutputDir,
               {
                 types: group.content.files.types,
-                apiService: group.content.files.apiService,
                 queryService: group.content.files.queryService,
+                enhanceEndpoints: group.content.files.enhanceEndpoints,
                 index: group.content.files.index
               }
             );
@@ -1303,11 +1345,10 @@ var UnifiedCodeGenerator = class {
         }
       }
       const outputDir = this.generatedContent.groups[0] ? path4.dirname(path4.dirname(this.generatedContent.groups[0].outputPath)) : "./generated";
-      if (this.generatedContent.cacheKeys || this.generatedContent.commonTypes || this.generatedContent.doNotModify || this.generatedContent.utils) {
+      if (this.generatedContent.commonTypes || this.generatedContent.doNotModify || this.generatedContent.utils) {
         const sharedResults = await this.fileWriterService.writeSharedFiles(
           outputDir,
           {
-            cacheKeys: this.generatedContent.cacheKeys || void 0,
             commonTypes: this.generatedContent.commonTypes || void 0,
             doNotModify: this.generatedContent.doNotModify || void 0,
             utils: this.generatedContent.utils || void 0
@@ -1315,6 +1356,13 @@ var UnifiedCodeGenerator = class {
         );
         results.push(...sharedResults);
       }
+      if (this.generatedContent.tagTypes) {
+        const tagTypesResult = await this.fileWriterService.writeFile(
+          path4.join(outputDir, "tagTypes.ts"),
+          this.generatedContent.tagTypes
+        );
+        results.push(tagTypesResult);
+      }
       if (this.generatedContent.componentSchema) {
         const schemaResults = await this.fileWriterService.writeSchemaFile(
           outputDir,
@@ -1322,6 +1370,12 @@ var UnifiedCodeGenerator = class {
         );
         results.push(...schemaResults);
       }
+      const mainIndexContent = this.generateMainIndex(generatedGroups);
+      const mainIndexResult = await this.fileWriterService.writeFile(
+        path4.join(outputDir, "index.ts"),
+        mainIndexContent
+      );
+      results.push(mainIndexResult);
     } catch (error) {
       errors.push(error);
     }
@@ -1351,12 +1405,19 @@ var UnifiedCodeGenerator = class {
     }
     const apiGenerator = new ApiCodeGenerator(this.parserService, groupOptions);
     const result = await apiGenerator.generate();
-    if (result.files && "allEndpointCacheKeys" in result.files) {
-      const cacheKeys = result.files.allEndpointCacheKeys;
-      this.allEndpointCacheKeys.push(...cacheKeys);
-    }
     return result;
   }
+  /**
+   * 生成主 index.ts 檔案
+   */
+  generateMainIndex(generatedGroups) {
+    const exports = generatedGroups.map((groupKey) => `export * from "./${groupKey}";`).join("\n");
+    return `/* eslint-disable */
+// [Warning] Generated automatically - do not edit manually
+
+${exports}
+`;
+  }
 };
 
 // src/index.ts