@1szx1/vite-plugin-swagger2ts 1.0.8 → 1.0.9

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@1szx1/vite-plugin-swagger2ts",
     "description": "fork for https://github.com/1SZX1/vite-plugin-swagger2ts",
-    "version": "1.0.8",
+    "version": "1.0.9",
     "main": "dist/index.js",
     "module": "dist/index.mjs",
     "types": "index.d.ts",
@@ -14,20 +14,18 @@
     "homepage": "https://github.com/1SZX1/vite-plugin-swagger2ts",
     "bugs": "https://github.com/1SZX1/vite-plugin-swagger2ts/issues",
     "files": [
-        "dist",
-        "src",
-        "index.d.ts"
+        "dist"
     ],
     "exports": {
         ".": {
-          "types": "./dist/index.d.ts",
-          "require": "./dist/index.js",
-          "import": "./dist/index.mjs"
+            "types": "./dist/index.d.ts",
+            "require": "./dist/index.js",
+            "import": "./dist/index.mjs"
         },
         "./adapters": {
-          "types": "./dist/adapters/index.d.ts",
-          "require": "./dist/adapters/index.js",
-          "import": "./dist/adapters/index.mjs"
+            "types": "./dist/adapters/index.d.ts",
+            "require": "./dist/adapters/index.js",
+            "import": "./dist/adapters/index.mjs"
         }
     },
     "scripts": {

package/index.d.ts

@@ -1,4 +0,0 @@
-import plugin from "./dist";
-
-export * from "./dist";
-export default plugin;

package/src/adapters/axios.ts

@@ -1,41 +0,0 @@
-import type { AxiosInstance, AxiosRequestConfig } from 'axios'
-import {Get, mergeUrlParam} from './utils'
-
-function axiosAdapter<T>(httpInstance: AxiosInstance) {
-  type UrlKey = string & keyof T
-  type MethodKey<U extends UrlKey> = string & keyof T[U]
-
-  type SwaggerInterfaceSingle<U extends UrlKey, M extends MethodKey<U>> = T[U][M]
-  type SwaggerField<U extends UrlKey, M extends MethodKey<U>> = keyof SwaggerInterfaceSingle<U, M>
-  type SwaggerFieldType<U extends UrlKey, M extends MethodKey<U>, F extends SwaggerField<U, M>> = SwaggerInterfaceSingle<U, M>[F]
-
-  type Param<U extends UrlKey, M extends MethodKey<U>> = SwaggerFieldType<U, M, 'param' & SwaggerField<U, M>>
-  type Response<U extends UrlKey, M extends MethodKey<U>> = SwaggerFieldType<U, M, 'response' & SwaggerField<U, M>>
-
-  async function request<U extends UrlKey, M extends MethodKey<U>>(
-    url: U, method: M,
-    param?: Get<Param<U, M>, M extends 'get' ? 'query' : 'body'>,
-    config?: AxiosRequestConfig & {
-      data?: Get<Param<U, M>, 'body'>
-      params?: Get<Param<U, M>, 'query'>
-      path?: Get<Param<U, M>, 'path'>
-    },
-  ) {
-    if (config?.path)
-      (url as string) = mergeUrlParam(url, config.path)
-
-    const response = await httpInstance.request<Response<U, M>>({
-      url,
-      method,
-      params: method === 'get' ? param : config?.params,
-      data: method !== 'get' ? param : config?.data,
-      ...config,
-    })
-    return response.data
-  }
-
-  return { request }
-}
-
-
-export { axiosAdapter }

package/src/adapters/index.ts

@@ -1 +0,0 @@
-export * from './axios'

package/src/adapters/utils.ts

@@ -1,5 +0,0 @@
-export type Get<T, K> = T[K & keyof T]
-
-export function mergeUrlParam(url: string, paths: Record<string, any>) {
-    return url.replace(/{(.*?)}/g, (_, key) => paths[key])
-}

package/src/generator.ts

@@ -1,176 +0,0 @@
-import { OpenAPIObject, RequestBodyObject, ResponseObject, ReferenceObject, OperationObject, ParameterObject, SchemaObject } from "openapi3-ts";
-import { getRefName, isTypeAny } from "./utils";
-import { GenerateDocOption } from "./types";
-
-export function generateDocs(input: OpenAPIObject, { docsName, baseUrl, formatSchema }: GenerateDocOption) {
-    function getRefObject(ref: string) {
-        return ref
-            .split("/")
-            .slice(1)
-            .reduce((obj, item) => {
-                return obj[item] || {};
-            }, input);
-    }
-
-    const pathsTypeString = Object.entries(input.paths)
-        .map(([endPoint, value]) => {
-            const pathValue = value as OperationObject;
-            const parametersExtended = pathValue.parameters;
-            // 处理请求方法里面的类型
-            const result = Object.entries(pathValue)
-                .map(([method, options]: [string, OperationObject]) => {
-                    //  不是请求方法的属性都跳过
-                    if (!["get", "put", "post", "delete", "options", "head", "patch", "trace"].includes(method)) {
-                        return;
-                    }
-                    let allParameters = [...(parametersExtended || []), ...(options.parameters || [])].map((item) => {
-                        //  将 $ref 转换为正常的 ParameterObject 的对象
-                        if ("$ref" in item) {
-                            return getRefObject(item.$ref) as any as ParameterObject;
-                        } else {
-                            return item;
-                        }
-                    });
-                    const queryParameters = allParameters.filter((item) => item.in === "query");
-                    const pathParameters = allParameters.filter((item) => item.in === "path");
-                    const bodyParameters = allParameters.filter((item) => !item.in);
-
-                    // 将 $ref 转换为 requestBody 对象
-                    const requestBody = options.requestBody ? ("$ref" in options.requestBody ? (getRefObject(options.requestBody.$ref) as any as RequestBodyObject) : options.requestBody) : undefined;
-
-                    // 找到状态码为 200 或者 default 的 responses 体，并将 ReferenceObject 格式的转换为 ResponseObject；
-                    let responses = Object.entries(options.responses)
-                        .filter((items) => items[0] == "200" || items[0] == "default")
-                        .sort()?.[0]?.[1] as ResponseObject | ReferenceObject;
-
-                    if ("$ref" in responses) {
-                        responses = getRefObject(responses.$ref) as any as ResponseObject;
-                    }
-
-                    const queryString = queryParameters.length > 0 ? jsDoc({}, { key: "query", result: `{${queryParameters.map((item) => generatorParameterType(item, docsName)).join("")}\n}` }) : "";
-                    const pathString = pathParameters.length > 0 ? jsDoc({}, { key: "path", result: `{${pathParameters.map((item) => generatorParameterType(item, docsName)).join("")}\n}` }) : "";
-                    const bodyExtraString = bodyParameters.length > 0 ? jsDoc({}, { key: "body", result: `{${bodyParameters.map((item) => generatorParameterType(item, docsName)).join("")}\n}` }) : "";
-                    const bodyString = requestBody ? generatorRequestBodyType(requestBody, docsName) : "";
-                    const responseString = generatorResponseBodyType(responses, docsName);
-
-                    const paramString = `${queryString}${pathString}${bodyString || bodyExtraString}`;
-                    return jsDoc({}, { key: method, result: `{${paramString ? `\nparam:{${paramString}}` : ""}${responseString}}` });
-                })
-                .join("");
-
-            return jsDoc({}, { key: `'${baseUrl}${endPoint}'`, result: `{${result}}` });
-        })
-        .join("");
-    const typeString = input.components?.schemas
-        ? Object.entries(input.components.schemas)
-              .map(([name, schema]) => {
-                  if (typeof formatSchema == "function") {
-                      schema = formatSchema(schema);
-                  }
-                  if ("$ref" in schema) {
-                      schema = getRefObject(schema.$ref) as any as SchemaObject;
-                  }
-                  return generatorSchemaType(getRefName(`#/components/schemas/${name}`, docsName), schema, { isRoot: true, isExport: true, docsName });
-              })
-              .join("")
-        : "";
-    const apiString = `${typeString}\nexport interface Paths${getRefName(docsName)}{${pathsTypeString}}\n`;
-    return apiString.replaceAll(/\n\n/g, "\n").replaceAll(/\n\n/g, "\n");
-}
-
-const TYPES = {
-    integer: "number",
-    number: "number",
-    boolean: "boolean",
-    object: "object",
-    string: "string",
-    array: "array"
-};
-
-interface GeneratorSchemaTypeOption {
-    isRoot?: boolean;
-    isRequired?: boolean;
-    isExport?: boolean;
-    docsName?: string;
-}
-export function generatorSchemaType(
-    key: string,
-    schema: SchemaObject | boolean | {} | undefined,
-    { isRoot = false, isRequired, isExport = false, docsName = "" }: GeneratorSchemaTypeOption = {}
-): string {
-    if (isTypeAny(schema)) {
-        return `\n${key}${isRequired === false ? "?" : ""}: any;\n`;
-    }
-
-    const { type, $ref, enum: Enum, items, properties, oneOf, additionalProperties, required, allOf } = schema as SchemaObject;
-    let result = "";
-    if ($ref) {
-        // 引用
-        result = getRefName($ref, docsName);
-    } else if (Enum) {
-        // 枚举
-        result = `${Enum.map((t) => `"${t}"`).join(" | ")}`;
-    } else if (items) {
-        // 数组
-        result = `${generatorSchemaType("", items, { docsName })}[]`;
-    } else if (properties) {
-        // 对象
-        result += `{${Object.entries(properties)
-            .map(([pName, _schema]) => generatorSchemaType(pName, _schema, { isRequired: !required || required.includes(pName) ? true : false, docsName }))
-            .join("")}\n}`;
-    } else if (oneOf) {
-        // 联合类型
-        result = `${oneOf.map((_schema) => `${generatorSchemaType("", _schema, { docsName })}`).join(" | ")}`;
-    } else if (allOf) {
-        // 交叉类型
-        result = `${allOf.map((_schema) => generatorSchemaType("", _schema, { docsName })).join(" & ")}`;
-    } else if (type === "object" && !result) {
-        // additionalProperties
-        if (additionalProperties) {
-            result = `{${generatorSchemaType("[x: string | number]", additionalProperties, { docsName })}\n}`;
-        } else {
-            result = "{[x: string | number]: any}";
-        }
-    } else {
-        // 基本类型，如果没有在基础类型里面默认为 string
-        result = TYPES[type as keyof typeof TYPES] || "string";
-    }
-    if (!key) {
-        return result;
-    }
-    return jsDoc(schema, { key, result, isExport, isRequired, isRoot });
-}
-
-export function generatorParameterType(schemas: ParameterObject, docsName?: string): string {
-    const { name, required, schema, description } = schemas;
-    const result = generatorSchemaType("", schema, { docsName });
-    return jsDoc({ description, ...schema }, { key: name, result, isRequired: required });
-}
-export function generatorRequestBodyType(schemas: RequestBodyObject, docsName?: string): string {
-    const { description, content, required } = schemas;
-    const schema = content && Object.values(content)[0]?.["schema"];
-    if (!schema) return "";
-    const result = generatorSchemaType("", schema, { docsName });
-    return jsDoc({ description }, { key: "body", result, isRequired: required });
-}
-export function generatorResponseBodyType(schemas: ResponseObject, docsName?: string): string {
-    const { description, content } = schemas;
-    const schema = content && Object.values(content)[0]?.["schema"];
-    let result: string;
-    if (!schema) {
-        result = "any";
-    } else {
-        result = generatorSchemaType("", schema, { docsName });
-    }
-    return jsDoc({ description }, { key: "response", result });
-}
-
-export function jsDoc(
-    { description, title, format, example, default: default1 }: any,
-    { key, result, isRoot, isExport, isRequired }: { key: string; result: string; isRoot?: boolean; isExport?: boolean; isRequired?: boolean }
-): string {
-    const jsDoc = `\n/**\n${title ? ` * @title ${title}\n` : ""}${description ? ` * @description ${description}\n` : ""}${format ? ` * @format ${format}\n` : ""}${
-        default1 ? ` * @default ${default1}\n` : ""
-    }${example ? ` * @example ${example}\n` : ""} **/\n`;
-    return `${jsDoc == "\n/**\n **/\n" ? "" : jsDoc}${isRoot ? `${isExport ? "export " : ""}type ${key} = ${result};\n` : `${key}${isRequired === false ? "?" : ""}: ${result};\n`}`;
-}

package/src/global.d.ts

@@ -1,7 +0,0 @@
-declare module "swagger2openapi" {
-    import { OpenAPIObject } from "openapi3-ts";
-    interface ConverObjCallbackData {
-        openapi: OpenAPIObject;
-    }
-    function convertObj(schema: unknown, options: {}, callback: (err: Error, data: ConverObjCallbackData) => void): void;
-}

package/src/index.ts

@@ -1,57 +0,0 @@
-import { writeFileSync } from "fs";
-import { resolve } from "path";
-import { convertObj } from "swagger2openapi";
-import { OpenAPIObject } from "openapi3-ts";
-import { doc, format } from "prettier";
-import { UserOptions, ExportPlugin, SwaggerSource, SwaggerDoc } from "./types";
-import { resolveOptions, fetchUrl, getPrettierOptions } from "./utils";
-import { generateDocs } from "./generator";
-
-function convertObjPromise(docs: any): Promise<OpenAPIObject> {
-    return new Promise((resolve, reject) => {
-        convertObj(docs, { patch: true }, function (err, option) {
-            // err && console.log("err", err);
-            if (err || !option.openapi) return reject(err);
-            resolve(option.openapi);
-        });
-    });
-}
-
-function swagger2TsPlugin(userOptions: UserOptions): ExportPlugin {
-    const { swaggerUrl, output, prettierPath, formatDocs, formatSchema } = resolveOptions(userOptions);
-    const prettierOptions = getPrettierOptions(prettierPath);
-
-    async function loadSwaggerSource() {
-        const sources = (await fetchUrl(`${swaggerUrl}/swagger-resources`)) as SwaggerSource[];
-        let code = "";
-        for (let i = 0; i < sources.length; i++) {
-            const { url, name: docsName } = sources[i];
-            try {
-                const docs = (await fetchUrl(`${swaggerUrl}${url}`)) as SwaggerDoc | OpenAPIObject;
-                let openapiDocs = formatDocs ? formatDocs(docs) : docs;
-                if (!("openapi" in openapiDocs)) {
-                    if (docs.swagger) openapiDocs = await convertObjPromise(openapiDocs);
-                    else continue;
-                }
-                const apistrings = generateDocs(openapiDocs, { docsName, baseUrl: docs.basePath ?? "", formatSchema });
-                code += apistrings;
-                // console.log("apistrings", apistrings);
-            } catch (error) {
-                // console.log("vite-plugin-swagger2ts convert error", error);
-            }
-        }
-        const outputFile = resolve(process.cwd(), output);
-        writeFileSync(outputFile, format(code, prettierOptions));
-    }
-
-    loadSwaggerSource();
-
-    return {
-        name: "vite-plugin-swagger2ts",
-        enforce: "pre",
-        apply: "serve"
-    };
-}
-
-export * from "./types";
-export default swagger2TsPlugin;

package/src/tmpl.ts

@@ -1,52 +0,0 @@
-interface SwaggerInterface1 {
-    // SwaggerInterface start
-    adsf: {
-        get: {
-            param: {
-                path: { id: string };
-            };
-            response: any;
-        };
-    };
-    adsf2: {
-        get: {
-            param: {
-                path: { id: string };
-            };
-            response: any;
-        };
-    };
-}
-interface SwaggerInterface2 {
-    // SwaggerInterface start
-    ccccc1: {
-        get: {
-            param: {
-                path: { id: string };
-            };
-            response: any;
-        };
-    };
-    ccccc2: {
-        get: {
-            param: {
-                path: { id: string };
-            };
-            response: any;
-        };
-    };
-}
-
-type SwaggerInterface = SwaggerInterface1 & SwaggerInterface2;
-type ReturnDataType = { code: number; data: any; message: string };
-type ReturnData<T extends ReturnDataType | any> = T extends ReturnDataType ? T["data"] : T;
-
-export type UrlKey = keyof SwaggerInterface;
-export type MethodKey<U extends UrlKey> = string & keyof SwaggerInterface[U];
-
-type SwaggerInterfaceSingle<U extends UrlKey, M extends MethodKey<U>> = SwaggerInterface[U][M];
-type SwaggerField<U extends UrlKey, M extends MethodKey<U>> = keyof SwaggerInterfaceSingle<U, M>;
-type SwaggerFieldType<U extends UrlKey, M extends MethodKey<U>, F extends SwaggerField<U, M>> = SwaggerInterfaceSingle<U, M>[F];
-
-export type Param<U extends UrlKey, M extends MethodKey<U>> = SwaggerFieldType<U, M, "param" & SwaggerField<U, M>>;
-export type Response<U extends UrlKey, M extends MethodKey<U>> = ReturnData<SwaggerFieldType<U, M, "response" & SwaggerField<U, M>>>;

package/src/types.ts

@@ -1,43 +0,0 @@
-import type { OpenAPIObject, SchemaObject } from "openapi3-ts";
-import type { Plugin } from "vite";
-
-type FormatSchema = (schema: SchemaObject) => SchemaObject;
-
-interface Options {
-    swaggerUrl: string;
-    output?: string;
-    prettierPath?: string;
-    formatDocs?: (docs: SwaggerDoc | OpenAPIObject) => typeof docs;
-    formatSchema?: FormatSchema;
-}
-
-export type UserOptions = Options;
-export interface ResolvedOptions extends Options {
-    output: string;
-}
-
-export type ExportPlugin = Required<Pick<Plugin, "name" | "enforce" | "apply">>;
-
-export interface SwaggerSource {
-    name: string;
-    url: string;
-    swaggerVersion: string;
-    location: string;
-}
-
-export interface SwaggerDoc {
-    basePath: string;
-    swagger: string;
-    paths: { [key: string]: any };
-    definitions: { [key: string]: any };
-    host: string;
-    info: any;
-    tags: any[];
-    securityDefinitions: any;
-}
-
-export interface GenerateDocOption {
-    docsName: string;
-    baseUrl: string;
-    formatSchema?: FormatSchema;
-}

package/src/utils.ts

@@ -1,83 +0,0 @@
-import { existsSync, readFileSync } from "fs";
-import { resolve } from "path";
-import { UserOptions, ResolvedOptions } from "./types";
-import { OpenAPIObject, SchemaObject } from "openapi3-ts";
-import fetch from "cross-fetch";
-
-export function resolveOptions(userOptions: UserOptions): ResolvedOptions {
-    const { output } = userOptions;
-
-    const root = process.cwd();
-    const outputFile = output ? (output?.endsWith(".ts") ? output : output + ".ts") : "./src/swagger.ts";
-
-    return Object.assign({ output: resolve(root, outputFile) }, userOptions);
-}
-
-export async function fetchUrl(url: string) {
-    return await fetch(url).then((res) => res.json());
-}
-
-export function getRef(ref: string, apiDocs: OpenAPIObject) {
-    const paths = ref.split("/").slice(1);
-    return paths.reduce((obj: any, key) => {
-        return obj[key];
-    }, apiDocs) as SchemaObject;
-}
-
-export function isTypeAny(type: true | undefined | {} | SchemaObject) {
-    if (type === true) {
-        return true;
-    }
-
-    if (typeof type === "object" && Object.keys(type).length <= 0) {
-        return true;
-    }
-
-    if (!type) {
-        return true;
-    }
-
-    return false;
-}
-
-export function toPascalCase(str: string): string {
-    return `${str.substring(0, 1).toUpperCase()}${str.substring(1)}`;
-}
-function replaceWithUpper(str: string, sp: string) {
-    let pointArray = str.split(sp);
-    pointArray = pointArray.map((point) => toPascalCase(point));
-
-    return pointArray.join("");
-}
-function getSchemaName(name: string): string {
-    const removePound = replaceWithUpper(name, "#");
-    const removeDot = replaceWithUpper(removePound, ".");
-    const removeBackTick = replaceWithUpper(removeDot, "`");
-    const removeFirstBracket = replaceWithUpper(removeBackTick, "[");
-    const removeLastBracket = replaceWithUpper(removeFirstBracket, "]");
-    const removeDash = replaceWithUpper(removeLastBracket, "-");
-    const removeSlash = replaceWithUpper(removeDash, "/");
-    return removeSlash;
-}
-export function getRefName($ref: string, prefix: string = ""): string {
-    return getSchemaName(prefix) + getSchemaName($ref || "");
-}
-
-export function getPrettierOptions(prettierPath?: string) {
-    let prettierOptions: any = {};
-    if (prettierPath && existsSync(prettierPath)) {
-        prettierOptions = JSON.parse(readFileSync(prettierPath).toString());
-    } else {
-        if (existsSync(".prettierrc")) {
-            prettierOptions = JSON.parse(readFileSync(".prettierrc").toString());
-        } else if (existsSync("prettier.json")) {
-            prettierOptions = JSON.parse(readFileSync("prettier.json").toString());
-        }
-    }
-
-    if (!prettierOptions.parser) {
-        prettierOptions.parser = "typescript";
-    }
-
-    return prettierOptions;
-}