@gopowerteam/request-generate 0.1.2 → 0.1.3

package/dist/chunk-7BMEVKSG.mjs

@@ -0,0 +1,18 @@
+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;
+};
+
+// ../../node_modules/.pnpm/tsup@6.3.0_mwhvu7sfp6vq5ryuwb6hlbjfka/node_modules/tsup/assets/esm_shims.js
+import { fileURLToPath } from "url";
+import path from "path";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+
+export {
+  __publicField,
+  __dirname
+};

package/dist/chunk-XXPGZHWZ.js

@@ -0,0 +1,10 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});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;
+};
+
+
+
+exports.__publicField = __publicField;

package/dist/index.js

@@ -1,9 +1,6 @@
-"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;
-};
+"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 _chunkXXPGZHWZjs = require('./chunk-XXPGZHWZ.js');
 
 // src/utils/get-openapi-document.ts
 var _swaggerparser = require('@apidevtools/swagger-parser'); var _swaggerparser2 = _interopRequireDefault(_swaggerparser);
@@ -889,7 +886,7 @@ var _Generate = class {
   }
 };
 var Generate = _Generate;
-__publicField(Generate, "options");
+_chunkXXPGZHWZjs.__publicField.call(void 0, Generate, "options");
 
 // src/index.ts
 var src_default = Generate.startup;

package/dist/index.mjs

@@ -0,0 +1,896 @@
+import {
+  __dirname,
+  __publicField
+} from "./chunk-7BMEVKSG.mjs";
+
+// src/utils/get-openapi-document.ts
+import swaggerParse from "@apidevtools/swagger-parser";
+var getOpenApiDocument = async (input) => {
+  return await swaggerParse.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
+import path from "node:path";
+function createOptions(options, name, application = "") {
+  return {
+    name,
+    input: `${options.gateway}${application}${options.openapi}`,
+    output: name ? path.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 {
+  name;
+  fields;
+  imports;
+  constructor(name) {
+    this.name = name;
+  }
+};
+
+// src/entities/field.ts
+var Field = class {
+  name;
+  required;
+  type;
+  ref;
+  enums;
+  description;
+  imports;
+  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 {
+  constructor(name) {
+    var _a, _b;
+    this.name = name;
+    this.responseType = ((_b = (_a = Generate.options) == null ? void 0 : _a.exportServices) == null ? void 0 : _b.responseType) || "promise";
+  }
+  name;
+  imports = [];
+  operations = [];
+  responseType;
+};
+
+// 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 = class {
+  name;
+  method;
+  path;
+  description;
+  responseRef;
+  responseType;
+  parametersPath = [];
+  parametersQuery = [];
+  parametersBody;
+  imports = [];
+  constructor(name, method, path5) {
+    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";
+  }
+};
+
+// 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 = class {
+  in;
+  name;
+  type;
+  ref;
+  enums;
+  description;
+  required;
+  imports = [];
+};
+
+// 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
+import * as fs from "node:fs";
+import * as path2 from "node:path";
+import Handlebars from "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) {
+  Handlebars.registerHelper(helper.name, helper.fn);
+}
+function registerHandlebarPartial(input) {
+  const template = loadHandlebarTemplate(`partials/${input}`);
+  Handlebars.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
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+
+// src/generate/write-model.ts
+import Handlebars2 from "handlebars";
+
+// src/generate/write-file.ts
+import * as fs2 from "node:fs";
+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.compile(templateSource);
+  const templateResult = template(model);
+  writeFile(output, templateResult);
+}
+
+// src/generate/write-models.ts
+import rimraf from "rimraf";
+function writeModels(client, options) {
+  if (!options.exportModels || !client.models) {
+    return;
+  }
+  const output = path3.join(options.output, "models");
+  if (fs3.existsSync(output)) {
+    rimraf.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
+import * as path4 from "node:path";
+import * as fs4 from "node:fs";
+import rimraf2 from "rimraf";
+
+// src/generate/write-service.ts
+import Handlebars3 from "handlebars";
+function writeService(service, output) {
+  const templateSource = loadHandlebarTemplate("export-service");
+  const template = Handlebars3.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.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;
+export {
+  src_default as default
+};

package/dist/vite-plugin/index.d.ts

@@ -0,0 +1,13 @@
+import { Plugin } from 'vite';
+
+declare type PluginOptions = {
+    alias: string;
+    dir: string;
+    dts: string;
+};
+/**
+ * Request插件
+ */
+declare const _default: (options: PluginOptions) => Plugin;
+
+export { _default as default };

package/dist/vite-plugin/index.js

@@ -0,0 +1,173 @@
+"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 _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }require('../chunk-XXPGZHWZ.js');
+
+// src/vite-plugin/index.ts
+var _fs = require('fs'); var fs = _interopRequireWildcard(_fs);
+var _path = require('path'); var path = _interopRequireWildcard(_path);
+var _handlebars = require('handlebars'); var Handlebars = _interopRequireWildcard(_handlebars);
+
+// src/vite-plugin/templates.ts
+var useRequestFunctionCodeTemplate = `
+export function useRequest(
+  select
+) {
+  const service = select(serviceMap)
+  return new service()
+}
+`;
+var useRequestFunctionTypeTemplate = `
+export function useRequest<T>(
+  select: (services: typeof serviceMap) => { new (): T }
+): T
+`;
+var importServiceTemplate = `
+{{#if groups}}
+{{#each groups}}
+{{#each services}}
+import { {{{name}}} as {{group}}_{{name}} } from '{{path}}'
+{{/each}}
+{{/each}}
+{{else}}
+{{#each services}}
+import { {{{name}}} } from '{{path}}'
+{{/each}}
+{{/if}}
+`;
+var defineServiceMapTemplate = `
+{{#if groups}}
+const serviceMap = {
+  {{#each groups}}
+  {{{name}}}: {
+    {{#each services}}
+    {{{name}}}: {{group}}_{{name}},
+    {{/each}}
+  },
+  {{/each}}
+}
+{{else}}
+const serviceMap = {
+{{#each services}}
+  {{{name}}},
+{{/each}}
+}
+{{/if}}
+`;
+var generateCodeTemplate = `
+${importServiceTemplate.trim()}
+
+${defineServiceMapTemplate.trim()}
+
+${useRequestFunctionCodeTemplate.trim()}
+`;
+var generateDeclareTemplate = `declare module '{{{MODULE_ID}}}' {
+  ${importServiceTemplate.trim()}
+
+  ${defineServiceMapTemplate.trim()}
+
+  ${useRequestFunctionTypeTemplate.trim()}
+}
+`;
+
+// src/vite-plugin/index.ts
+var MODULE_ID = "virtual:request";
+var DECLARATION_FILE = "request.d.ts";
+var viteConfig;
+var vite_plugin_default = (options) => {
+  return {
+    name: "vite-plugin-request",
+    enforce: "pre",
+    resolveId(id) {
+      return id === MODULE_ID ? MODULE_ID : void 0;
+    },
+    configResolved(config) {
+      viteConfig = config;
+    },
+    load(id) {
+      if (id !== MODULE_ID)
+        return;
+      const paths = getServicePaths(options);
+      const services = getServiceItems(paths);
+      const groups = getServiceGroups(services);
+      if (services && services.length) {
+        generateDeclare(services, groups, options);
+        return generateCode(services, groups);
+      } else {
+        return void 0;
+      }
+    }
+  };
+};
+function getServicePaths(options) {
+  const paths = [];
+  const walk = (dir) => {
+    fs.readdirSync(dir).forEach(function(file) {
+      const fullpath = path.join(dir, file).replace(/\\/g, "/");
+      const stat = fs.statSync(fullpath);
+      if (stat.isFile() && fullpath.endsWith("Service.ts")) {
+        paths.push(fullpath);
+      } else if (stat.isDirectory()) {
+        const subdir = path.join(dir, file);
+        walk(subdir);
+      }
+    });
+  };
+  const { replacement } = viteConfig.resolve.alias.find(
+    (alias) => alias.find === options.alias
+  );
+  if (fs.existsSync(path.resolve(options.dir))) {
+    walk(path.resolve(options.dir));
+  }
+  return paths.map(
+    (filepath) => filepath.replace(replacement.replace(/\\/g, "/"), options.alias)
+  );
+}
+function getServiceItems(paths) {
+  const toCaseString = (str = "") => str.replace(/-(\w)/g, (_, $1) => $1.toUpperCase()).replace(/^\S/, (s) => s.toUpperCase());
+  return paths.map((filePath) => {
+    const [name] = /[^\\]+(?=\.ts$)/.exec(toCaseString(path.basename(filePath))) || [];
+    const [group] = /(?<=^.\/http\/)(.*?)(?=\/.*?Service\.ts$)/.exec(filePath) || [];
+    return {
+      name: toCaseString(name),
+      group: group !== "services" ? toCaseString(group) : void 0,
+      path: filePath.replace(/\.ts$/g, "")
+    };
+  });
+}
+function getServiceGroups(services) {
+  return services.reduce((r, s) => {
+    if (!s.group) {
+      return r;
+    }
+    const group = r.find((x) => x.name === s.group) || {
+      name: s.group,
+      services: []
+    };
+    group.services.push(s);
+    if (!r.find((g) => g === group)) {
+      r.push(group);
+    }
+    return r;
+  }, []);
+}
+function generateCode(services, groups) {
+  const template = Handlebars.compile(generateCodeTemplate);
+  return template({
+    groups: groups.length ? groups : void 0,
+    services
+  });
+}
+function generateDeclare(services, groups, options) {
+  const template = Handlebars.compile(generateDeclareTemplate);
+  const content = template({
+    groups: groups.length ? groups : void 0,
+    services,
+    MODULE_ID
+  });
+  fs.writeFileSync(
+    path.resolve(viteConfig.root, _nullishCoalesce(options.dts, () => ( DECLARATION_FILE))),
+    content.replace(/\r\n/g, "\n"),
+    "utf-8"
+  );
+}
+
+
+exports.default = vite_plugin_default;

package/dist/vite-plugin/index.mjs

@@ -0,0 +1,173 @@
+import "../chunk-7BMEVKSG.mjs";
+
+// src/vite-plugin/index.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as Handlebars from "handlebars";
+
+// src/vite-plugin/templates.ts
+var useRequestFunctionCodeTemplate = `
+export function useRequest(
+  select
+) {
+  const service = select(serviceMap)
+  return new service()
+}
+`;
+var useRequestFunctionTypeTemplate = `
+export function useRequest<T>(
+  select: (services: typeof serviceMap) => { new (): T }
+): T
+`;
+var importServiceTemplate = `
+{{#if groups}}
+{{#each groups}}
+{{#each services}}
+import { {{{name}}} as {{group}}_{{name}} } from '{{path}}'
+{{/each}}
+{{/each}}
+{{else}}
+{{#each services}}
+import { {{{name}}} } from '{{path}}'
+{{/each}}
+{{/if}}
+`;
+var defineServiceMapTemplate = `
+{{#if groups}}
+const serviceMap = {
+  {{#each groups}}
+  {{{name}}}: {
+    {{#each services}}
+    {{{name}}}: {{group}}_{{name}},
+    {{/each}}
+  },
+  {{/each}}
+}
+{{else}}
+const serviceMap = {
+{{#each services}}
+  {{{name}}},
+{{/each}}
+}
+{{/if}}
+`;
+var generateCodeTemplate = `
+${importServiceTemplate.trim()}
+
+${defineServiceMapTemplate.trim()}
+
+${useRequestFunctionCodeTemplate.trim()}
+`;
+var generateDeclareTemplate = `declare module '{{{MODULE_ID}}}' {
+  ${importServiceTemplate.trim()}
+
+  ${defineServiceMapTemplate.trim()}
+
+  ${useRequestFunctionTypeTemplate.trim()}
+}
+`;
+
+// src/vite-plugin/index.ts
+var MODULE_ID = "virtual:request";
+var DECLARATION_FILE = "request.d.ts";
+var viteConfig;
+var vite_plugin_default = (options) => {
+  return {
+    name: "vite-plugin-request",
+    enforce: "pre",
+    resolveId(id) {
+      return id === MODULE_ID ? MODULE_ID : void 0;
+    },
+    configResolved(config) {
+      viteConfig = config;
+    },
+    load(id) {
+      if (id !== MODULE_ID)
+        return;
+      const paths = getServicePaths(options);
+      const services = getServiceItems(paths);
+      const groups = getServiceGroups(services);
+      if (services && services.length) {
+        generateDeclare(services, groups, options);
+        return generateCode(services, groups);
+      } else {
+        return void 0;
+      }
+    }
+  };
+};
+function getServicePaths(options) {
+  const paths = [];
+  const walk = (dir) => {
+    fs.readdirSync(dir).forEach(function(file) {
+      const fullpath = path.join(dir, file).replace(/\\/g, "/");
+      const stat = fs.statSync(fullpath);
+      if (stat.isFile() && fullpath.endsWith("Service.ts")) {
+        paths.push(fullpath);
+      } else if (stat.isDirectory()) {
+        const subdir = path.join(dir, file);
+        walk(subdir);
+      }
+    });
+  };
+  const { replacement } = viteConfig.resolve.alias.find(
+    (alias) => alias.find === options.alias
+  );
+  if (fs.existsSync(path.resolve(options.dir))) {
+    walk(path.resolve(options.dir));
+  }
+  return paths.map(
+    (filepath) => filepath.replace(replacement.replace(/\\/g, "/"), options.alias)
+  );
+}
+function getServiceItems(paths) {
+  const toCaseString = (str = "") => str.replace(/-(\w)/g, (_, $1) => $1.toUpperCase()).replace(/^\S/, (s) => s.toUpperCase());
+  return paths.map((filePath) => {
+    const [name] = /[^\\]+(?=\.ts$)/.exec(toCaseString(path.basename(filePath))) || [];
+    const [group] = /(?<=^.\/http\/)(.*?)(?=\/.*?Service\.ts$)/.exec(filePath) || [];
+    return {
+      name: toCaseString(name),
+      group: group !== "services" ? toCaseString(group) : void 0,
+      path: filePath.replace(/\.ts$/g, "")
+    };
+  });
+}
+function getServiceGroups(services) {
+  return services.reduce((r, s) => {
+    if (!s.group) {
+      return r;
+    }
+    const group = r.find((x) => x.name === s.group) || {
+      name: s.group,
+      services: []
+    };
+    group.services.push(s);
+    if (!r.find((g) => g === group)) {
+      r.push(group);
+    }
+    return r;
+  }, []);
+}
+function generateCode(services, groups) {
+  const template = Handlebars.compile(generateCodeTemplate);
+  return template({
+    groups: groups.length ? groups : void 0,
+    services
+  });
+}
+function generateDeclare(services, groups, options) {
+  const template = Handlebars.compile(generateDeclareTemplate);
+  const content = template({
+    groups: groups.length ? groups : void 0,
+    services,
+    MODULE_ID
+  });
+  fs.writeFileSync(
+    path.resolve(viteConfig.root, options.dts ?? DECLARATION_FILE),
+    content.replace(/\r\n/g, "\n"),
+    "utf-8"
+  );
+}
+export {
+  vite_plugin_default as default
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gopowerteam/request-generate",
   "private": false,
-  "version": "0.1.2",
+  "version": "0.1.3",
   "type": "commonjs",
   "files": [
     "dist",
@@ -23,6 +23,11 @@
       "require": "./dist/index.js",
       "import": "./dist/index.mjs",
       "types": "./dist/index.d.ts"
+    },
+    "./vite-plugin": {
+      "require": "./dist/vite-plugin/index.js",
+      "import": "./dist/vite-plugin/index.mjs",
+      "types": "./dist/vite-plugin/index.d.ts"
     }
   },
   "devDependencies": {
@@ -38,7 +43,8 @@
     "ts-jest": "^29.0.3",
     "ts-node": "^10.9.1",
     "tsup": "^6.2.3",
-    "typescript": "^4.8.4"
+    "typescript": "^4.8.4",
+    "vite": "^3.1.8"
   },
   "dependencies": {
     "@apidevtools/swagger-parser": "^10.1.0",