@gopowerteam/request-generate 0.1.0

package/bin/index.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+'use strict'
+
+const path = require('node:path')
+const fs = require('node:fs')
+const { program } = require('commander')
+
+const RequestGenerate = require(path.resolve(
+  __dirname,
+  '..',
+  'dist',
+  'index.js'
+))
+
+const params = program
+  .name('@gopowerteam/request-generate')
+  .usage('[options]')
+  .option('--config <value>', '指定配置文件位置')
+  .parse(process.argv)
+  .opts()
+
+const configFilePaths = [
+  'request-generate.config.cjs',
+  'request-generate.config.js'
+]
+
+/**
+ * 加载配置文件
+ * @param {*} filePath
+ * @returns
+ */
+function loadConfigFile(filePath) {
+  if (filePath) {
+    configFilePaths.unshift(filePath)
+  }
+
+  const configFilePath = configFilePaths.find((file) =>
+    fs.existsSync(path.resolve(process.cwd(), file))
+  )
+
+  if (configFilePath) {
+    return require(path.resolve(process.cwd(), configFilePath))
+  } else {
+    throw new Error('无法找到RequestGenerate配置文件')
+  }
+}
+
+if (RequestGenerate) {
+  const config = loadConfigFile(params.config)
+  RequestGenerate.default(config)
+    .then(() => {
+      console.log('接口文件生成完成')
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error(error)
+      process.exit(1)
+    })
+}

package/dist/index.d.ts

@@ -0,0 +1,143 @@
+import { OpenAPIV2, OpenAPIV3 } from 'openapi-types';
+
+/**
+ * 生成全局选项
+ */
+type GenerateOptions = {
+  // 网关地址
+  gateway: string
+  // OpenAPI地址
+  openapi: string
+  // 输出目录
+  output: string
+  // 输出Model路径
+  exportModels: boolean
+  // 开启日志输出
+  logger?: boolean
+  // 输出Model路径
+  exportServices?: {
+    serviceResolve?: (options: {
+      path: string
+      method: string
+      object: OpenAPIV2.OperationObject | OpenAPIV3.OperationObject
+      tags: OpenAPIV2.TagObject[]
+    }) => string
+    operationResolve?: (options: {
+      path: string
+      method: string
+      object: OpenAPIV2.OperationObject | OpenAPIV3.OperationObject
+    }) => string
+    excludeQueryParams?: string[]
+    responseType?: 'promise' | 'observable'
+  }
+  // 多应用列表
+  applications?: Record<string, string>
+}
+
+/**
+ * 生成应用选项
+ */
+type GenerateApplicationOptions = Pick<
+  GenerateOptions,
+  'exportModels' | 'output'
+> & {
+  // 服务名称
+  name?: string
+  // OPENAPI地址
+  input: string
+}
+
+declare enum OpenAPIVersion {
+    V2 = 2,
+    V3 = 3
+}
+
+declare class Field {
+    name: string;
+    required: boolean;
+    type: string;
+    ref?: string;
+    enums?: string[];
+    description?: string;
+    imports?: string[];
+    constructor(name: string, required: boolean);
+}
+
+declare class Model {
+    name: string;
+    fields: Field[];
+    imports: string[];
+    constructor(name: string);
+}
+
+declare class OperationParameter {
+    in: 'path' | 'query' | 'body';
+    name: string;
+    type: string;
+    ref?: string;
+    enums?: string[];
+    description?: string;
+    required?: boolean;
+    imports: string[];
+}
+
+declare class Operation {
+    name: string;
+    method: string;
+    path: string;
+    description?: string;
+    responseRef: string;
+    responseType: 'promise' | 'observable';
+    parametersPath: OperationParameter[];
+    parametersQuery: OperationParameter[];
+    parametersBody?: OperationParameter;
+    imports: string[];
+    constructor(name: string, method: string, path: string);
+}
+
+declare class Service {
+    constructor(name: string);
+    name: string;
+    imports: string[];
+    operations: Operation[];
+    responseType: 'promise' | 'observable';
+}
+
+type GenerateClient = {
+  // 模型列表
+  models: Model[]
+  // 服务列表
+  services: Service[]
+}
+
+declare type UnkownVersionDocument = OpenAPIV3.Document & OpenAPIV2.Document;
+declare class Generate {
+    static options: GenerateOptions;
+    /**
+     * 生成入口
+     * @param options
+     * @returns
+     */
+    static startup(options: GenerateOptions): Promise<void[]>;
+    /**
+     * 生成应用
+     */
+    static generateApplication(options: GenerateApplicationOptions): Promise<void>;
+    /**
+     * 生成对象信息
+     * @param document
+     * @param version
+     * @returns
+     */
+    static generateClient(document: UnkownVersionDocument, version: OpenAPIVersion): GenerateClient;
+    /**
+     * 写入Client对象
+     * @param client
+     * @param options
+     */
+    static writeClient(client: GenerateClient, options: GenerateApplicationOptions): void;
+}
+
+declare const _default: typeof Generate.startup;
+
+export { _default as default };

package/dist/index.js

@@ -0,0 +1,898 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } var _class; var _class2; var _class3;var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/utils/get-openapi-document.ts
+var _swaggerparser = require('@apidevtools/swagger-parser'); var _swaggerparser2 = _interopRequireDefault(_swaggerparser);
+var getOpenApiDocument = async (input) => {
+  return await _swaggerparser2.default.parse(input);
+};
+
+// src/config/enum.config.ts
+var OpenAPIVersion = /* @__PURE__ */ ((OpenAPIVersion2) => {
+  OpenAPIVersion2[OpenAPIVersion2["V2"] = 2] = "V2";
+  OpenAPIVersion2[OpenAPIVersion2["V3"] = 3] = "V3";
+  return OpenAPIVersion2;
+})(OpenAPIVersion || {});
+
+// src/utils/get-openapi-version.ts
+function getOpenAPIVersion(document) {
+  const version = (document == null ? void 0 : document.swagger) || (document == null ? void 0 : document.openapi);
+  if (typeof version === "string") {
+    const v = Number.parseInt(version.charAt(0));
+    if (Object.values(OpenAPIVersion).includes(v)) {
+      return v;
+    }
+  }
+  throw new Error(`\u65E0\u6CD5\u8BC6\u522B\u7684OPENAPI\u7248\u672C: "${String(version)}"`);
+}
+
+// src/utils/get-services-options.ts
+var _path = require('path'); var path2 = _interopRequireWildcard(_path); var path3 = _interopRequireWildcard(_path); var path4 = _interopRequireWildcard(_path);
+function createOptions(options, name, application = "") {
+  return {
+    name,
+    input: `${options.gateway}${application}${options.openapi}`,
+    output: name ? path2.default.join(options.output, name) : options.output,
+    exportModels: options.exportModels
+  };
+}
+function generateServiceOptions(options) {
+  if (options.applications && Object.keys(options.applications).length) {
+    return Object.entries(options.applications).map(
+      ([name, application]) => createOptions(options, name, application)
+    );
+  } else {
+    return [createOptions(options)];
+  }
+}
+
+// src/utils/get-camel-name.ts
+function getCamelName(value) {
+  return value.replace(/^[^a-zA-Z]+/g, "").replace(/[^\w-]+/g, "-").replace(/-/g, "").replace(/^\S/, (s) => s.toUpperCase()).trim();
+}
+
+// src/entities/model.ts
+var Model = class {
+  
+  
+  
+  constructor(name) {
+    this.name = name;
+  }
+};
+
+// src/entities/field.ts
+var Field = class {
+  
+  
+  
+  
+  
+  
+  
+  constructor(name, required) {
+    this.name = name;
+    this.required = required;
+  }
+};
+
+// src/utils/get-mapped-type.ts
+var TYPE_MAPPINGS = /* @__PURE__ */ new Map([
+  ["file", "binary"],
+  ["any", "any"],
+  ["object", "any"],
+  ["array", "any[]"],
+  ["boolean", "boolean"],
+  ["byte", "number"],
+  ["int", "number"],
+  ["integer", "number"],
+  ["float", "number"],
+  ["double", "number"],
+  ["short", "number"],
+  ["long", "number"],
+  ["number", "number"],
+  ["char", "string"],
+  ["date", "string"],
+  ["date-time", "string"],
+  ["password", "string"],
+  ["string", "string"],
+  ["void", "void"],
+  ["null", "null"]
+]);
+var getMappedType = (type = "object", format) => {
+  if (format === "binary") {
+    return "binary";
+  }
+  return TYPE_MAPPINGS.get(type) || "any";
+};
+
+// src/parse/v2/strip-namespace.ts
+var stripNamespace = (value) => {
+  return value.trim().replace(/^#\/definitions\//, "").replace(/^#\/parameters\//, "").replace(/^#\/responses\//, "").replace(/^#\/securityDefinitions\//, "");
+};
+
+// src/parse/v2/parse-schema-type.ts
+function parseSchemaType(schema) {
+  if ("$ref" in schema && schema.$ref) {
+    const ref = getCamelName(stripNamespace(schema.$ref));
+    return {
+      type: "any",
+      ref,
+      imports: [ref]
+    };
+  }
+  if (!("$ref" in schema) && schema.type !== "array" && typeof schema.type === "string" && !schema.allOf && !schema.anyOf && !schema.oneOf) {
+    return {
+      type: getMappedType(schema.type || "any"),
+      ref: void 0,
+      enums: schema.enum
+    };
+  }
+  if (!("$ref" in schema) && schema.type === "array" && schema.items && "$ref" in schema.items && schema.items.$ref) {
+    const ref = getCamelName(stripNamespace(schema.items.$ref));
+    return {
+      type: "any[]",
+      ref: `${ref}[]`,
+      imports: [ref]
+    };
+  }
+  if (!("$ref" in schema) && schema.type === "array" && schema.items && !("$ref" in schema.items)) {
+    return {
+      type: `${getMappedType(schema.items.type)}[]`,
+      ref: void 0
+    };
+  }
+  throw new Error("\u65E0\u6CD5\u89E3\u6790\u76F8\u5E94\u7684schema");
+}
+
+// src/parse/v2/parse-field.ts
+function parseField(name, properties, required = false) {
+  const field = new Field(name, required);
+  const { type, ref, imports, enums } = parseSchemaType(properties);
+  field.type = type;
+  field.ref = ref;
+  field.imports = imports;
+  field.enums = enums;
+  if (!("$ref" in properties)) {
+    field.description = properties.description;
+  }
+  return field;
+}
+
+// src/parse/v2/parse-fields.ts
+function parseFields(schema) {
+  return Object.entries(schema.properties || {}).map(
+    ([name, property]) => {
+      var _a;
+      return parseField(name, property, (_a = schema.required) == null ? void 0 : _a.includes(name));
+    }
+  );
+}
+
+// src/parse/v2/parse-model.ts
+function parseModel(name, definition) {
+  const model = new Model(name);
+  model.fields = parseFields(definition);
+  const imports = model.fields.filter((field) => field.imports).reduce((r, m) => [...r, ...m.imports || []], []).filter((m) => m !== name);
+  model.imports = Array.from(new Set(imports));
+  return model;
+}
+
+// src/parse/v2/parse-models.ts
+function parseModels(document) {
+  const models = [];
+  if (document.definitions) {
+    for (const definitionName in document.definitions) {
+      if (Object.getOwnPropertyNames(document.definitions).includes(
+        definitionName
+      )) {
+        const definition = document.definitions[definitionName];
+        const model = parseModel(getCamelName(definitionName), definition);
+        models.push(model);
+      }
+    }
+  }
+  return models;
+}
+
+// src/entities/service.ts
+var Service = (_class = class {
+  constructor(name) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+    var _a, _b;
+    this.name = name;
+    this.responseType = ((_b = (_a = Generate.options) == null ? void 0 : _a.exportServices) == null ? void 0 : _b.responseType) || "promise";
+  }
+  
+  __init() {this.imports = []}
+  __init2() {this.operations = []}
+  
+}, _class);
+
+// src/utils/get-service-name.ts
+function getServiceName(path5, method, operationObject, tags) {
+  var _a, _b, _c;
+  const resolve2 = (_b = (_a = Generate.options) == null ? void 0 : _a.exportServices) == null ? void 0 : _b.serviceResolve;
+  if (resolve2) {
+    return resolve2({ path: path5, method, object: operationObject, tags });
+  } else {
+    return ((_c = operationObject.tags) == null ? void 0 : _c.map((tag) => getCamelName(tag))) || "Default";
+  }
+}
+
+// src/entities/operation.ts
+var Operation = (_class2 = class {
+  
+  
+  
+  
+  
+  
+  __init3() {this.parametersPath = []}
+  __init4() {this.parametersQuery = []}
+  
+  __init5() {this.imports = []}
+  constructor(name, method, path5) {;_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);
+    var _a, _b;
+    this.name = name;
+    this.method = method;
+    this.path = path5;
+    this.responseType = ((_b = (_a = Generate.options) == null ? void 0 : _a.exportServices) == null ? void 0 : _b.responseType) || "promise";
+  }
+}, _class2);
+
+// src/utils/get-operation-name.ts
+function getOperationName(path5, method, operationObject) {
+  var _a, _b;
+  const resolve2 = (_b = (_a = Generate.options) == null ? void 0 : _a.exportServices) == null ? void 0 : _b.operationResolve;
+  if (resolve2) {
+    return resolve2({ path: path5, method, object: operationObject });
+  } else {
+    return operationObject.operationId || "";
+  }
+}
+
+// src/entities/operation-parameter.ts
+var OperationParameter = (_class3 = class {constructor() { _class3.prototype.__init6.call(this); }
+  
+  
+  
+  
+  
+  
+  
+  __init6() {this.imports = []}
+}, _class3);
+
+// src/parse/v2/parse-parameters-body.ts
+function parseParametersBody(parameters) {
+  const requestBody = parameters.find(
+    (parameter) => !("$ref" in parameter) && parameter.in === "body"
+  );
+  if (requestBody && "schema" in requestBody) {
+    const { type, ref, imports } = parseSchemaType(requestBody.schema);
+    const parameter = new OperationParameter();
+    parameter.name = "requestBody";
+    parameter.in = "body";
+    parameter.type = type;
+    parameter.ref = ref;
+    parameter.imports = imports || [];
+    return parameter;
+  } else {
+    return;
+  }
+}
+
+// src/parse/v2/parse-parameters-path.ts
+function parseParametersPath(parameters) {
+  return parameters.reduce((r, p) => {
+    if (!("$ref" in p) && p.in === "path" && p.schema) {
+      const { type, ref, imports, enums } = parseSchemaType(p.schema);
+      const parameter = new OperationParameter();
+      parameter.name = p.name;
+      parameter.description = p.description;
+      parameter.in = "path";
+      parameter.type = type;
+      parameter.ref = ref;
+      parameter.imports = imports || [];
+      parameter.enums = enums;
+      r.push(parameter);
+    }
+    return r;
+  }, []);
+}
+
+// src/parse/v2/parse-parameters-query.ts
+function parseParametersQuery(parameters) {
+  var _a, _b;
+  const excludeParams = (_b = (_a = Generate.options) == null ? void 0 : _a.exportServices) == null ? void 0 : _b.excludeQueryParams;
+  return parameters.reduce((r, p) => {
+    if (!("$ref" in p) && p.in === "query" && p.schema && !(excludeParams && excludeParams.includes(p.name))) {
+      const { type, ref, imports, enums } = parseSchemaType(p.schema);
+      const parameter = new OperationParameter();
+      parameter.name = p.name;
+      parameter.description = p.description;
+      parameter.in = "query";
+      parameter.type = type;
+      parameter.ref = ref;
+      parameter.required = p.required;
+      parameter.imports = imports || [];
+      parameter.enums = enums;
+      r.push(parameter);
+    }
+    return r;
+  }, []);
+}
+
+// src/parse/v2/parse-operation.ts
+function parseOperation(path5, method, operationObject) {
+  var _a;
+  const name = getOperationName(path5, method, operationObject);
+  const operation = new Operation(name, method, path5);
+  operation.description = operationObject.summary || operation.description;
+  if (operationObject.parameters) {
+    operation.parametersBody = parseParametersBody(operationObject.parameters);
+    operation.parametersPath = parseParametersPath(operationObject.parameters);
+    operation.parametersQuery = parseParametersQuery(operationObject.parameters);
+  }
+  const responseSchema = parseResponseType(operationObject.responses);
+  operation.imports = Array.from(
+    /* @__PURE__ */ new Set([
+      ...((_a = operation.parametersBody) == null ? void 0 : _a.imports) || [],
+      ...operation.parametersPath.flatMap((p) => p.imports) || [],
+      ...operation.parametersQuery.flatMap((p) => p.imports) || [],
+      ...(responseSchema == null ? void 0 : responseSchema.imports) || []
+    ])
+  );
+  operation.responseRef = (responseSchema == null ? void 0 : responseSchema.ref) || "void";
+  return operation;
+}
+function parseResponseType(responses) {
+  const SUCCESS_STATUS_CODE = "200";
+  const response = responses == null ? void 0 : responses[SUCCESS_STATUS_CODE];
+  if (response && "$ref" in response) {
+    return parseSchemaType(response);
+  }
+  if (response && "schema" in response && (response == null ? void 0 : response.schema)) {
+    return parseSchemaType(response == null ? void 0 : response.schema);
+  }
+  return {
+    type: "void",
+    ref: "void",
+    imports: []
+  };
+}
+
+// src/parse/v2/parse-service.ts
+function parseService(path5, method, operationObject, tags, services) {
+  const toNames = (name) => Array.isArray(name) ? name : [name];
+  const names = toNames(
+    getServiceName(
+      path5,
+      method,
+      operationObject,
+      tags || []
+    )
+  );
+  const operation = parseOperation(path5, method, operationObject);
+  names.forEach((name) => {
+    let service = services.find((service2) => service2.name === name);
+    if (!service) {
+      service = new Service(name);
+      services.push(service);
+    }
+    if (service) {
+      service.operations.push(operation);
+    }
+    service.operations.flatMap((operation2) => operation2.imports).forEach((model) => {
+      if (service && !service.imports.includes(model)) {
+        service.imports.push(model);
+      }
+    });
+  });
+}
+
+// src/parse/v2/parse-services.ts
+function parseServices(document) {
+  const services = [];
+  Object.entries(document.paths).forEach(([path5, pathObject]) => {
+    if (pathObject) {
+      Object.entries(pathObject).forEach(([method, operationObject]) => {
+        parseService(
+          path5,
+          method,
+          operationObject,
+          document.tags || [],
+          services
+        );
+      });
+    }
+  });
+  return services;
+}
+
+// src/parse/v2/index.ts
+function parseV2(document) {
+  const models = parseModels(document);
+  const services = parseServices(document);
+  return {
+    models,
+    services
+  };
+}
+
+// src/parse/v3/strip-namespace.ts
+var stripNamespace2 = (value) => {
+  return value.trim().replace(/^#\/components\/schemas\//, "").replace(/^#\/components\/responses\//, "").replace(/^#\/components\/parameters\//, "").replace(/^#\/components\/examples\//, "").replace(/^#\/components\/requestBodies\//, "").replace(/^#\/components\/headers\//, "").replace(/^#\/components\/securitySchemes\//, "").replace(/^#\/components\/links\//, "").replace(/^#\/components\/callbacks\//, "");
+};
+
+// src/parse/v3/parse-schema-type.ts
+function parseSchemaType2(schema) {
+  if ("$ref" in schema) {
+    const ref = getCamelName(stripNamespace2(schema.$ref));
+    return {
+      type: "any",
+      ref,
+      imports: [ref]
+    };
+  }
+  if (!("$ref" in schema) && schema.type !== "array" && !schema.allOf && !schema.anyOf && !schema.oneOf) {
+    return {
+      type: getMappedType(schema.type || "any"),
+      ref: void 0,
+      enums: schema.enum
+    };
+  }
+  if (schema.type === "array" && "$ref" in schema.items) {
+    const ref = getCamelName(stripNamespace2(schema.items.$ref));
+    return {
+      type: "any[]",
+      ref: `${ref}[]`,
+      imports: [ref]
+    };
+  }
+  if (schema.type === "array" && !("$ref" in schema.items)) {
+    return {
+      type: `${getMappedType(schema.items.type)}[]`,
+      ref: void 0
+    };
+  }
+  if (schema.allOf || schema.anyOf || schema.oneOf) {
+    const ofSchema = schema.allOf || schema.anyOf || schema.oneOf;
+    const ofSchemaArray = ofSchema == null ? void 0 : ofSchema.map((s) => parseSchemaType2(s));
+    if (ofSchemaArray) {
+      const hasRef = ofSchemaArray.some((s) => s.ref);
+      return {
+        type: hasRef ? "any" : ofSchemaArray.map((s) => s.type).join("|"),
+        ref: hasRef ? ofSchemaArray.map((s) => s.ref && getCamelName(s.ref) || s.type).join("|") : void 0,
+        imports: hasRef ? ofSchemaArray.reduce(
+          (r, s) => (s.ref && !r.includes(s.ref) && r.push(getCamelName(s.ref)), r),
+          []
+        ) : void 0
+      };
+    }
+  }
+  throw new Error("\u65E0\u6CD5\u89E3\u6790\u76F8\u5E94\u7684schema");
+}
+
+// src/parse/v3/parse-field.ts
+function parseField2(name, properties, required = false) {
+  const field = new Field(name, required);
+  const { type, ref, imports, enums } = parseSchemaType2(properties);
+  field.type = type;
+  field.ref = ref;
+  field.imports = imports;
+  field.enums = enums;
+  if (!("$ref" in properties)) {
+    field.description = properties.description;
+  }
+  return field;
+}
+
+// src/parse/v3/parse-fields.ts
+function parseFields2(schema) {
+  return Object.entries(schema.properties || {}).map(
+    ([name, property]) => {
+      var _a;
+      return parseField2(name, property, (_a = schema.required) == null ? void 0 : _a.includes(name));
+    }
+  );
+}
+
+// src/parse/v3/parse-model.ts
+function parseModel2(name, definition) {
+  const model = new Model(name);
+  model.fields = parseFields2(definition);
+  const imports = model.fields.filter((field) => field.imports).reduce((r, m) => [...r, ...m.imports || []], []).filter((m) => m !== name);
+  model.imports = Array.from(new Set(imports));
+  return model;
+}
+
+// src/parse/v3/parse-models.ts
+function parseModels2(document) {
+  const models = [];
+  if (document.components) {
+    for (const definitionName in document.components.schemas) {
+      const { schemas } = document.components;
+      if (Object.getOwnPropertyNames(schemas).includes(definitionName)) {
+        const definition = document.components.schemas[definitionName];
+        const model = parseModel2(getCamelName(definitionName), definition);
+        models.push(model);
+      }
+    }
+  }
+  return models;
+}
+
+// src/parse/v3/parse-parameters-body.ts
+function parseParametersBody2(requestBody) {
+  const { type, ref, imports } = parseBodyType(requestBody);
+  const parameter = new OperationParameter();
+  parameter.name = "requestBody";
+  parameter.in = "body";
+  parameter.type = type;
+  parameter.ref = ref;
+  parameter.imports = imports || [];
+  return parameter;
+}
+function parseBodyType(requestBody) {
+  var _a, _b;
+  if ("$ref" in requestBody) {
+    return parseSchemaType2(requestBody);
+  }
+  if ("content" in requestBody && ((_a = requestBody == null ? void 0 : requestBody.content["application/json"]) == null ? void 0 : _a.schema)) {
+    const schema = (_b = requestBody == null ? void 0 : requestBody.content["application/json"]) == null ? void 0 : _b.schema;
+    return parseSchemaType2(schema);
+  }
+  throw new Error("\u65E0\u6CD5\u89E3\u6790RequestBody Schema");
+}
+
+// src/parse/v3/parse-parameters-path.ts
+function parseParametersPath2(parameters) {
+  return parameters.reduce((r, p) => {
+    if (!("$ref" in p) && p.in === "path" && p.schema) {
+      const { type, ref, imports, enums } = parseSchemaType2(p.schema);
+      const parameter = new OperationParameter();
+      parameter.name = p.name;
+      parameter.description = p.description;
+      parameter.in = "path";
+      parameter.type = type;
+      parameter.ref = ref;
+      parameter.imports = imports || [];
+      parameter.enums = enums;
+      r.push(parameter);
+    }
+    return r;
+  }, []);
+}
+
+// src/parse/v3/parse-parameters-query.ts
+function parseParametersQuery2(parameters) {
+  var _a, _b;
+  const excludeParams = (_b = (_a = Generate.options) == null ? void 0 : _a.exportServices) == null ? void 0 : _b.excludeQueryParams;
+  return parameters.reduce((r, p) => {
+    if (!("$ref" in p) && p.in === "query" && p.schema && !(excludeParams && excludeParams.includes(p.name))) {
+      const { type, ref, imports, enums } = parseSchemaType2(p.schema);
+      const parameter = new OperationParameter();
+      parameter.name = p.name;
+      parameter.description = p.description;
+      parameter.in = "query";
+      parameter.type = type;
+      parameter.ref = ref;
+      parameter.required = p.required;
+      parameter.imports = imports || [];
+      parameter.enums = enums;
+      r.push(parameter);
+    }
+    return r;
+  }, []);
+}
+
+// src/parse/v3/parse-operation.ts
+function parseOperation2(path5, method, operationObject) {
+  var _a;
+  const name = getOperationName(path5, method, operationObject);
+  const operation = new Operation(name, method, path5);
+  operation.description = operationObject.summary;
+  if (operationObject.requestBody) {
+    operation.parametersBody = parseParametersBody2(operationObject.requestBody);
+  }
+  if (operationObject.parameters) {
+    operation.parametersPath = parseParametersPath2(operationObject.parameters);
+    operation.parametersQuery = parseParametersQuery2(operationObject.parameters);
+  }
+  const responseSchema = parseResponseType2(operationObject.responses);
+  operation.imports = Array.from(
+    /* @__PURE__ */ new Set([
+      ...((_a = operation.parametersBody) == null ? void 0 : _a.imports) || [],
+      ...operation.parametersPath.flatMap((p) => p.imports) || [],
+      ...operation.parametersQuery.flatMap((p) => p.imports) || [],
+      ...(responseSchema == null ? void 0 : responseSchema.imports) || []
+    ])
+  );
+  operation.responseRef = (responseSchema == null ? void 0 : responseSchema.ref) || "void";
+  return operation;
+}
+function parseResponseType2(responses) {
+  var _a, _b, _c, _d;
+  const SUCCESS_STATUS_CODE = "200";
+  const response = responses == null ? void 0 : responses[SUCCESS_STATUS_CODE];
+  if (response && "$ref" in response) {
+    return parseSchemaType2(responses);
+  }
+  if (response && "content" in response && ((_b = (_a = response == null ? void 0 : response.content) == null ? void 0 : _a["application/json"]) == null ? void 0 : _b.schema)) {
+    return parseSchemaType2((_d = (_c = response == null ? void 0 : response.content) == null ? void 0 : _c["application/json"]) == null ? void 0 : _d.schema);
+  }
+  return {
+    type: "void",
+    ref: "void",
+    imports: []
+  };
+}
+
+// src/parse/v3/parse-service.ts
+function parseService2(path5, method, operationObject, tags, services) {
+  const toNames = (name) => Array.isArray(name) ? name : [name];
+  const names = toNames(
+    getServiceName(
+      path5,
+      method,
+      operationObject,
+      tags || []
+    )
+  );
+  const operation = parseOperation2(path5, method, operationObject);
+  names.forEach((name) => {
+    let service = services.find((service2) => service2.name === name);
+    if (!service) {
+      service = new Service(name);
+      services.push(service);
+    }
+    if (service) {
+      service.operations.push(operation);
+    }
+    service.operations.flatMap((operation2) => operation2.imports).forEach((model) => {
+      if (service && !service.imports.includes(model)) {
+        service.imports.push(model);
+      }
+    });
+  });
+}
+
+// src/parse/v3/parse-services.ts
+function parseServices2(document) {
+  const services = [];
+  Object.entries(document.paths).forEach(([path5, pathObject]) => {
+    if (pathObject) {
+      Object.entries(pathObject).forEach(([method, operationObject]) => {
+        parseService2(
+          path5,
+          method,
+          operationObject,
+          document.tags || [],
+          services
+        );
+      });
+    }
+  });
+  return services;
+}
+
+// src/parse/v3/index.ts
+function parseV3(document) {
+  const models = parseModels2(document);
+  const services = parseServices2(document);
+  return {
+    models,
+    services
+  };
+}
+
+// src/template.ts
+var _fs = require('fs'); var fs = _interopRequireWildcard(_fs); var fs3 = _interopRequireWildcard(_fs); var fs2 = _interopRequireWildcard(_fs); var fs4 = _interopRequireWildcard(_fs);
+
+var _handlebars = require('handlebars'); var _handlebars2 = _interopRequireDefault(_handlebars);
+
+// src/template-helpers/equal.helper.ts
+var equalHelper = {
+  name: "equal",
+  fn(v1, v2, options) {
+    if (v1 === v2) {
+      return options.fn(this);
+    } else {
+      return options.inverse(this);
+    }
+  }
+};
+
+// src/template-helpers/is-array.helper.ts
+var isArrayHelper = {
+  name: "is-array",
+  fn(v1, options) {
+    if (Array.isArray(v1)) {
+      return options.fn(this);
+    } else {
+      return options.inverse(this);
+    }
+  }
+};
+
+// src/template-helpers/to-upper.helper.ts
+var toUpperHelper = {
+  name: "to-upper",
+  fn(v1, onlyFirst) {
+    if (onlyFirst) {
+      return v1.replace(/^\S/, function(s) {
+        return s.toUpperCase();
+      });
+    } else {
+      return v1.toUpperCase();
+    }
+  }
+};
+
+// src/template.ts
+function registerHandlebarTemplates() {
+  registerHandlebarPartials();
+  registerHandlebarHelpers();
+}
+function registerHandlebarPartials() {
+  registerHandlebarPartial("is-required");
+  registerHandlebarPartial("export-header");
+  registerHandlebarPartial("export-description");
+  registerHandlebarPartial("export-model-import");
+  registerHandlebarPartial("export-model-type");
+  registerHandlebarPartial("export-model-field");
+  registerHandlebarPartial("export-schema-type");
+  registerHandlebarPartial("export-service-import");
+  registerHandlebarPartial("export-service-class");
+  registerHandlebarPartial("export-service-namespace");
+  registerHandlebarPartial("export-service-namespace-type");
+  registerHandlebarPartial("export-service-operation");
+  registerHandlebarPartial("export-operation-params-path");
+  registerHandlebarPartial("export-operation-params-query");
+  registerHandlebarPartial("export-operation-params-body");
+  registerHandlebarPartial("export-operation-response");
+}
+function registerHandlebarHelpers() {
+  registerHandlebarHelper(equalHelper);
+  registerHandlebarHelper(isArrayHelper);
+  registerHandlebarHelper(toUpperHelper);
+}
+function registerHandlebarHelper(helper) {
+  _handlebars2.default.registerHelper(helper.name, helper.fn);
+}
+function registerHandlebarPartial(input) {
+  const template = loadHandlebarTemplate(`partials/${input}`);
+  _handlebars2.default.registerPartial(input, template);
+}
+function loadHandlebarTemplate(input) {
+  const templatePath = path2.resolve(__dirname, "templates", `${input}.hbs`);
+  return fs.readFileSync(templatePath, "utf-8");
+}
+
+// src/generate/write-models.ts
+
+
+
+// src/generate/write-model.ts
+
+
+// src/generate/write-file.ts
+
+var ConsoleLogBlue = "\x1B[34m";
+var ConsoleLogGreen = "\x1B[32m";
+var ConsoleLogReset = "\x1B[0m";
+function writeFile(output, content) {
+  var _a;
+  fs2.writeFileSync(output, content, "utf-8");
+  if ((_a = Generate.options) == null ? void 0 : _a.logger) {
+    console.log(
+      ConsoleLogBlue,
+      "Generate File: ",
+      ConsoleLogGreen,
+      output,
+      ConsoleLogReset
+    );
+  }
+}
+
+// src/generate/write-model.ts
+function writeModel(model, output) {
+  const templateSource = loadHandlebarTemplate("export-model");
+  const template = _handlebars2.default.compile(templateSource);
+  const templateResult = template(model);
+  writeFile(output, templateResult);
+}
+
+// src/generate/write-models.ts
+var _rimraf = require('rimraf'); var _rimraf2 = _interopRequireDefault(_rimraf);
+function writeModels(client, options) {
+  if (!options.exportModels || !client.models) {
+    return;
+  }
+  const output = path3.join(options.output, "models");
+  if (fs3.existsSync(output)) {
+    _rimraf2.default.sync(output);
+  }
+  fs3.mkdirSync(output, { recursive: true });
+  client.models.forEach((model) => {
+    const filename = `${model.name}.ts`;
+    writeModel(model, path3.join(output, filename));
+  });
+}
+
+// src/generate/write-services.ts
+
+
+
+
+// src/generate/write-service.ts
+
+function writeService(service, output) {
+  const templateSource = loadHandlebarTemplate("export-service");
+  const template = _handlebars2.default.compile(templateSource);
+  const templateResult = template(service);
+  writeFile(output, templateResult);
+}
+
+// src/generate/write-services.ts
+function writeServices(client, options) {
+  if (!client.services) {
+    return;
+  }
+  const output = path4.join(options.output, "services");
+  if (fs4.existsSync(output)) {
+    _rimraf2.default.sync(output);
+  }
+  fs4.mkdirSync(output, { recursive: true });
+  client.services.forEach((service) => {
+    const filename = `${service.name}Service.ts`;
+    writeService(service, path4.join(output, filename));
+  });
+}
+
+// src/generate/index.ts
+var _Generate = class {
+  static startup(options) {
+    _Generate.options = options;
+    registerHandlebarTemplates();
+    const applicationOptions = generateServiceOptions(options);
+    return Promise.all(
+      applicationOptions.map(
+        (applicationOption) => _Generate.generateApplication(applicationOption)
+      )
+    );
+  }
+  static async generateApplication(options) {
+    const document = await getOpenApiDocument(
+      options.input
+    );
+    const version = getOpenAPIVersion(document);
+    const client = _Generate.generateClient(document, version);
+    _Generate.writeClient(client, options);
+  }
+  static generateClient(document, version) {
+    switch (version) {
+      case 2 /* V2 */:
+        return parseV2(document);
+      case 3 /* V3 */:
+        return parseV3(document);
+    }
+  }
+  static writeClient(client, options) {
+    writeModels(client, options);
+    writeServices(client, options);
+  }
+};
+var Generate = _Generate;
+__publicField(Generate, "options");
+
+// src/index.ts
+var src_default = Generate.startup;
+
+
+exports.default = src_default;

package/dist/templates/export-model.hbs

@@ -0,0 +1,7 @@
+{{>export-header}}
+{{!-- 生成导入代码 --}}
+{{>export-model-import}}
+
+{{!-- 生成类型代码 --}}
+{{>export-model-type}}
+

package/dist/templates/export-service.hbs

@@ -0,0 +1,9 @@
+{{>export-header}}
+{{!-- 生成导入代码 --}}
+{{>export-service-import}}
+
+{{!-- 生成类型代码 --}}
+{{>export-service-class}}
+
+{{!-- 生成类型代码 --}}
+{{>export-service-namespace}}

package/dist/templates/partials/export-description.hbs

@@ -0,0 +1,5 @@
+{{#if description}}
+/**
+ * {{{description}}}
+ */
+{{/if}}

package/dist/templates/partials/export-header.hbs

@@ -0,0 +1,3 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */

package/dist/templates/partials/export-model-field.hbs

@@ -0,0 +1,2 @@
+{{>export-description}}
+{{{name}}}{{>is-required}}: {{>export-schema-type}};

package/dist/templates/partials/export-model-import.hbs

@@ -0,0 +1,5 @@
+{{#if imports}}
+{{#each imports}}
+import type { {{{this}}} } from './{{{this}}}';
+{{/each}}
+{{/if}}

package/dist/templates/partials/export-model-type.hbs

@@ -0,0 +1,5 @@
+export type {{{name}}} = {
+{{#each fields}}
+  {{>export-model-field}}
+{{/each}}
+}

package/dist/templates/partials/export-operation-params-body.hbs

@@ -0,0 +1,3 @@
+{{#if parametersBody}}
+requestBody: {{>export-schema-type parametersBody}},
+{{/if}}

package/dist/templates/partials/export-operation-params-path.hbs

@@ -0,0 +1,5 @@
+{{#if parametersPath}}
+{{#each parametersPath}}
+{{{name}}}: {{>export-schema-type}},
+{{/each}}
+{{/if}}

package/dist/templates/partials/export-operation-params-query.hbs

@@ -0,0 +1,3 @@
+{{#if parametersQuery}}
+requestQuery: RequestQueryParams.{{to-upper name true}},
+{{/if}}

package/dist/templates/partials/export-operation-response.hbs

@@ -0,0 +1,6 @@
+{{~#equal responseType 'promise'~}}
+Promise<{{{responseRef}}}>
+{{~/equal~}}
+{{~#equal responseType 'observable'~}}
+Observable<{{{responseRef}}}>
+{{~/equal~}}

package/dist/templates/partials/export-schema-type.hbs

@@ -0,0 +1,11 @@
+{{~#if ref~}}
+{{{ref}}}
+{{~else~}}
+{{~#if enums~}}
+{{~#each enums~}}
+'{{{this}}}'{{#unless @last}} | {{/unless}}
+{{~/each~}}
+{{else}}
+{{{type}}}
+{{~/if~}}
+{{~/if~}}

package/dist/templates/partials/export-service-class.hbs

@@ -0,0 +1,9 @@
+export class {{{name}}}Service {
+  // 请求实例
+  private request = RequestService.getInstance();
+
+  {{#each operations}}
+  {{>export-service-operation}}
+  {{/each}}
+}
+

package/dist/templates/partials/export-service-import.hbs

@@ -0,0 +1,9 @@
+{{#if imports}}
+{{#each imports}}
+import type { {{{this}}} } from '../models/{{{this}}}';
+{{/each}}
+{{/if}}
+{{#equal responseType 'observable'}}
+import { from, type Observable } from 'rxjs';
+{{/equal}}
+import { RequestService, RequestPlugin } from '@gopowerteam/request';

package/dist/templates/partials/export-service-namespace-type.hbs

@@ -0,0 +1,2 @@
+{{>export-description}}
+{{{name}}}{{>is-required}}: {{>export-schema-type}};

package/dist/templates/partials/export-service-namespace.hbs

@@ -0,0 +1,11 @@
+namespace RequestQueryParams {
+{{#each operations}}
+  {{#if parametersQuery}}
+  export type {{to-upper name true}} = {
+    {{#each parametersQuery}}
+    {{>export-service-namespace-type}}
+    {{/each}}
+  }
+  {{/if}}
+{{/each}}
+}

package/dist/templates/partials/export-service-operation.hbs

@@ -0,0 +1,36 @@
+{{>export-description}}
+public {{{name}}}(
+  {{>export-operation-params-path}}
+  {{>export-operation-params-query}}
+  {{>export-operation-params-body}}
+  requestPlugins: RequestPlugin[] = []
+): {{>export-operation-response }} {
+  // 请求数据
+  const result = this.request.send(
+    {
+      path: '{{{path}}}',
+      method: '{{{method}}}',
+      {{#if parametersPath}}
+      {{#each parametersPath}}
+      paramsPath: {
+        {{{name}}},
+      },
+      {{/each}}
+      {{/if}}
+      {{#if parametersQuery}}
+      paramsQuery: requestQuery,
+      {{/if}}
+      {{#if parametersBody}}
+      paramsBody: requestBody,
+      {{/if}}
+    },
+    requestPlugins
+  );
+
+  {{#equal responseType 'observable'}}
+  return from(result)
+  {{else}}
+  return result
+  {{/equal}}
+}
+

package/dist/templates/partials/is-required.hbs

@@ -0,0 +1 @@
+{{#unless required}}?{{/unless}}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@gopowerteam/request-generate",
+  "private": false,
+  "version": "0.1.0",
+  "type": "commonjs",
+  "files": [
+    "dist",
+    "bin",
+    "README.md"
+  ],
+  "bin": {
+    "request-generate": "bin/index.js"
+  },
+  "keywords": [
+    "gopowerteam",
+    "request-generate"
+  ],
+  "scripts": {
+    "build": "tsup"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "devDependencies": {
+    "@gopowerteam/request": "*",
+    "@types/jest": "^29.1.2",
+    "@types/node": "16",
+    "@types/qs": "^6.9.7",
+    "@types/rimraf": "^3.0.2",
+    "commander": "^9.4.1",
+    "fs-extra": "^10.1.0",
+    "jest": "^29.1.2",
+    "openapi-types": "^12.0.2",
+    "ts-jest": "^29.0.3",
+    "ts-node": "^10.9.1",
+    "tsup": "^6.2.3",
+    "typescript": "^4.8.4"
+  },
+  "dependencies": {
+    "@apidevtools/swagger-parser": "^10.1.0",
+    "handlebars": "^4.7.7",
+    "qs": "^6.11.0",
+    "rimraf": "^3.0.2",
+    "rxjs": "^7.5.7"
+  }
+}