@1szx1/vite-plugin-swagger2ts 1.0.4

package/index.d.ts

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

package/package.json

@@ -0,0 +1,89 @@
+{
+    "name": "@1szx1/vite-plugin-swagger2ts",
+    "description": "fork for https://github.com/1SZX1/vite-plugin-swagger2ts",
+    "version": "1.0.4",
+    "main": "dist/index.js",
+    "module": "dist/index.mjs",
+    "types": "index.d.ts",
+    "license": "MIT",
+    "author": "1SZX1 <2414126198@qq.com>",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/1SZX1/vite-plugin-swagger2ts"
+    },
+    "homepage": "https://github.com/1SZX1/vite-plugin-swagger2ts",
+    "bugs": "https://github.com/1SZX1/vite-plugin-swagger2ts/issues",
+    "files": [
+        "dist",
+        "src",
+        "index.d.ts"
+    ],
+    "scripts": {
+        "dev": "pnpm run build -- --watch --ignore-watch examples",
+        "build": "tsup src/index.ts --dts --format cjs,esm",
+        "prepublishOnly": "pnpm run build",
+        "release": "pnpx git-ensure -a && pnpx bumpp --commit --tag --push",
+        "demo:dev": "pnpm -C examples/demo run dev",
+        "demo:build": "pnpm -C examples/demo run build",
+        "demo:preview": "pnpm -C examples/demo run preview",
+        "test": "jest",
+        "lint": "eslint --fix --ext .ts ./",
+        "prepare": "[ -d '.husky' ] &&  echo '' || (pnpx husky install && pnpm commitprepare && pnpm lintprepare)",
+        "commitprepare": "pnpx husky add .husky/commit-msg 'pnpx commitlint --edit $1'",
+        "lintprepare": "pnpx husky add .husky/pre-commit 'pnpx lint-staged'",
+        "version": "conventional-changelog -p angular -i CHANGELOG.md -s -r 0 && git add CHANGELOG.md",
+        "preinstall": "npx only-allow pnpm"
+    },
+    "dependencies": {
+        "cross-fetch": "^3.1.5",
+        "openapi3-ts": "^2.0.2",
+        "swagger2openapi": "^7.0.8"
+    },
+    "peerDependencies": {
+        "vite": "^2.0.0"
+    },
+    "devDependencies": {
+        "@antfu/eslint-config": "^0.6.6",
+        "@commitlint/cli": "^12.1.4",
+        "@commitlint/config-conventional": "^12.1.4",
+        "@types/jest": "^26.0.24",
+        "@types/node": "^14.18.12",
+        "@typescript-eslint/eslint-plugin": "^4.33.0",
+        "@typescript-eslint/parser": "^5.14.0",
+        "conventional-changelog": "^3.1.25",
+        "cz-conventional-changelog": "^3.3.0",
+        "eslint": "^7.32.0",
+        "eslint-config-prettier": "^8.5.0",
+        "eslint-plugin-prettier": "^3.4.1",
+        "husky": "^6.0.0",
+        "jest": "^26.6.3",
+        "jest-esbuild": "^0.1.6",
+        "lint-staged": "^10.5.4",
+        "prettier": "^2.5.1",
+        "rollup": "^2.70.0",
+        "ts-node": "^9.1.1",
+        "tsup": "^4.14.0",
+        "typescript": "^4.6.2",
+        "vite": "^2.8.6"
+    },
+    "lint-staged": {
+        "*.{ts}": "eslint --fix --ext",
+        "*.{ts,md}": "prettier --write"
+    },
+    "husky": {
+        "hooks": {
+            "commit-msg": "commitlint -E HUSKY_GIT_PARAMS",
+            "pre-commit": "lint-staged"
+        }
+    },
+    "commitlint": {
+        "extends": [
+            "@commitlint/config-conventional"
+        ]
+    },
+    "config": {
+        "commitizen": {
+            "path": "./node_modules/cz-conventional-changelog"
+        }
+    }
+}

package/src/generator.ts

@@ -0,0 +1,176 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,57 @@
+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(docs);
+                    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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,83 @@
+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;
+}