openapi-ts-request 0.1.0

package/dist/parser-mock/index.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const lodash_1 = require("lodash");
+const memoizee_1 = tslib_1.__importDefault(require("memoizee"));
+const util_1 = require("../generator/util");
+const primitives_1 = require("./primitives");
+const util_2 = require("./util");
+function getDateByName(name, parentsKey) {
+    if (!name || name.length < 1) {
+        return 'string';
+    }
+    if (Array.isArray(name)) {
+        return getDateByName([...name].pop(), name);
+    }
+    if (['nickname', 'name'].includes(name)) {
+        return 'cname';
+    }
+    if (['owner', 'firstName', 'lastName', 'username'].includes(name)) {
+        return 'name';
+    }
+    if (['avatar'].includes(name)) {
+        return 'avatar';
+    }
+    if (['group'].includes(name)) {
+        return 'group';
+    }
+    if (name.toLocaleLowerCase().endsWith('id')) {
+        return 'uuid';
+    }
+    if (name.toLocaleLowerCase().endsWith('type') ||
+        name.toLocaleLowerCase().endsWith('key') ||
+        ['key'].includes(name)) {
+        return 'id';
+    }
+    if (name.toLocaleLowerCase().endsWith('label') || ['label'].includes(name)) {
+        const newParents = [...parentsKey];
+        newParents.pop();
+        const newType = getDateByName(newParents);
+        if (newType !== 'string' && newType !== 'csentence') {
+            return newType;
+        }
+        return 'label';
+    }
+    if (['email'].includes(name)) {
+        return 'email';
+    }
+    if (['password'].includes(name)) {
+        return 'string(16)';
+    }
+    if (['phone'].includes(name)) {
+        return 'phone';
+    }
+    if (['province'].includes(name)) {
+        return 'province';
+    }
+    if (['city'].includes(name)) {
+        return 'city';
+    }
+    if (['addr', 'address'].includes(name)) {
+        return 'county';
+    }
+    if (['country'].includes(name)) {
+        return 'country';
+    }
+    if (['url', 'imageUrl', 'href'].includes(name) ||
+        name.toLocaleLowerCase().endsWith('url') ||
+        name.toLocaleLowerCase().endsWith('urls') ||
+        name.toLocaleLowerCase().endsWith('image') ||
+        name.toLocaleLowerCase().endsWith('link')) {
+        return 'href';
+    }
+    if (name.toLocaleLowerCase().endsWith('errorcode')) {
+        return 'errorCode';
+    }
+    if (['type', 'status'].includes(name) ||
+        name.toLocaleLowerCase().endsWith('status') ||
+        name.toLocaleLowerCase().endsWith('type')) {
+        return 'status';
+    }
+    if (name.toLocaleLowerCase().endsWith('authority')) {
+        return 'authority';
+    }
+    return 'csentence';
+}
+function primitive(schemaParams, propsName) {
+    const schema = (0, util_2.objectify)(schemaParams);
+    const { type, format } = schema;
+    const value = primitives_1.primitives[`${type}_${format || getDateByName(propsName)}`] ||
+        primitives_1.primitives[type];
+    if ((0, lodash_1.isUndefined)(schema.example)) {
+        return value || `Unknown Type: ${schema.type}`;
+    }
+    return schema.example;
+}
+class OpenAPIGeneratorMockJs {
+    constructor(openAPI) {
+        this.sampleFromSchema = (schema, propsName, schemaSet = new Set()) => {
+            const schemaRef = (0, util_1.isReferenceObject)(schema) ? schema.$ref : null;
+            if (schemaRef) {
+                // 如果之前已经使用过该引用结构，直接返回null,不然会陷入无限递归的情况
+                if (schemaSet.has(schemaRef)) {
+                    return null;
+                }
+                else {
+                    schemaSet.add(schemaRef);
+                }
+            }
+            const localSchema = (schemaRef ? (0, util_2.get)(this.openAPI, schemaRef) : (0, util_2.objectify)(schema));
+            let type = localSchema.type;
+            const { properties, additionalProperties, items, anyOf, oneOf, allOf } = localSchema;
+            if (allOf) {
+                let obj = {};
+                allOf.forEach((item) => {
+                    const newObj = this.sampleFromSchema(item, propsName, new Set(schemaSet));
+                    if ((0, lodash_1.isObject)(newObj)) {
+                        obj = Object.assign(Object.assign({}, obj), newObj);
+                    }
+                });
+                return obj;
+            }
+            if (!type) {
+                if (properties) {
+                    type = 'object';
+                }
+                else if (items) {
+                    type = 'array';
+                }
+                else if (anyOf || oneOf) {
+                    type = 'union';
+                }
+                else {
+                    return null;
+                }
+            }
+            if (type === 'null') {
+                return null;
+            }
+            if (type === 'object') {
+                const props = (0, util_2.objectify)(properties);
+                const obj = {};
+                for (const name in props) {
+                    obj[name] = this.sampleFromSchema(props[name], [...(propsName || []), name], new Set(schemaSet));
+                }
+                if (additionalProperties === true) {
+                    obj.additionalProp1 = {};
+                    return obj;
+                }
+                if (additionalProperties) {
+                    const additionalProps = (0, util_2.objectify)(additionalProperties);
+                    const additionalPropVal = this.sampleFromSchema(additionalProps, propsName, new Set(schemaSet));
+                    for (let i = 1; i < 4; i += 1) {
+                        obj[`additionalProp${i}`] = additionalPropVal;
+                    }
+                }
+                return obj;
+            }
+            if (type === 'array') {
+                const item = this.sampleFromSchema(items, propsName, new Set(schemaSet));
+                return new Array(parseInt((Math.random() * 20).toFixed(0), 10)).fill(item);
+            }
+            if (type === 'union') {
+                const subschemas = anyOf || oneOf;
+                const subschemas_length = (subschemas && subschemas.length) || 0;
+                if (subschemas_length) {
+                    const index = (0, util_2.getRandomInt)(0, subschemas_length);
+                    const obj = this.sampleFromSchema(subschemas[index], propsName, new Set(schemaSet));
+                    return obj;
+                }
+            }
+            if (localSchema.enum) {
+                if (localSchema.default) {
+                    return localSchema.default;
+                }
+                return (0, util_2.normalizeArray)(localSchema.enum)[0];
+            }
+            if (type === 'file') {
+                return null;
+            }
+            return primitive(localSchema, propsName);
+        };
+        this.openAPI = openAPI;
+        this.sampleFromSchema = (0, memoizee_1.default)(this.sampleFromSchema);
+    }
+    parser() {
+        const openAPI = Object.assign({}, this.openAPI);
+        for (const path in openAPI.paths) {
+            for (const method in openAPI.paths[path]) {
+                const api = openAPI.paths[path][method];
+                for (const code in api.responses) {
+                    const response = api.responses[code];
+                    const mediaTypeKeys = (0, lodash_1.keys)(response.content);
+                    if (mediaTypeKeys.length) {
+                        let key;
+                        if (mediaTypeKeys.includes('application/json')) {
+                            key = 'application/json';
+                        }
+                        else if (mediaTypeKeys.includes('*/*')) {
+                            key = '*/*';
+                        }
+                        else {
+                            key = mediaTypeKeys[0];
+                        }
+                        const schema = (0, util_2.inferSchema)(response.content[key]);
+                        if (schema) {
+                            response.example = this.sampleFromSchema(schema);
+                        }
+                    }
+                }
+                if (!api.parameters)
+                    continue;
+                for (const parameter of api.parameters) {
+                    const schema = (0, util_2.inferSchema)(parameter);
+                    parameter.example = schema
+                        ? this.sampleFromSchema(schema)
+                        : null;
+                }
+            }
+        }
+        return openAPI;
+    }
+}
+exports.default = OpenAPIGeneratorMockJs;

package/dist/parser-mock/primitives.d.ts

@@ -0,0 +1 @@
+export declare const primitives: Record<string, string>;

package/dist/parser-mock/primitives.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.primitives = void 0;
+exports.primitives = {
+    string: '@string',
+    string_email: '@email',
+    string_phone: '@phone',
+    string_username: '@cname',
+    string_url: '@url',
+    string_uuid: '@guid',
+    string_id: '@increment',
+    string_status: '@status',
+    string_authority: '@authority',
+    string_label: '@label',
+    string_group: '@group',
+    string_csentence: '@csentence',
+    string_cname: '@cname',
+    string_name: '@last',
+    string_errorCode: '@increment',
+    string_country: '@country',
+    string_county: '@county(true)',
+    string_province: '@province',
+    string_city: '@city',
+    string_avatar: '@avatar',
+    string_href: '@href',
+    'string_string(16)': '@string(16)',
+    'string_date-time': '@datetime',
+    string_date: '@date',
+    number: '@integer(60, 100)',
+    number_float: '@float(60, 100, 3, 5)',
+    integer: '@integer(60, 100)',
+    boolean: '@boolean',
+};

package/dist/parser-mock/util.d.ts

@@ -0,0 +1,90 @@
+import { OpenAPIV3 } from 'openapi-types';
+import { OpenAPIObject, ParameterObject, ReferenceObject, SchemaObject } from '../type';
+export declare function objectify<T>(thing: T): T;
+export declare function get(openAPI: OpenAPIObject, path: string): OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject;
+export declare function normalizeArray(arr: string[] | string): string[];
+export declare function inferSchema(thing: ParameterObject | SchemaObject | ReferenceObject | OpenAPIV3.MediaTypeObject): OpenAPIV3.ReferenceObject | OpenAPIV3.MediaTypeObject | {
+    type: string;
+    enum?: any[];
+    title?: string;
+    description?: string;
+    default?: any;
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: boolean;
+    minimum?: number;
+    exclusiveMinimum?: boolean;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[];
+    not?: OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject;
+    nullable?: boolean;
+    discriminator?: OpenAPIV3.DiscriminatorObject;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    xml?: OpenAPIV3.XMLObject;
+    externalDocs?: OpenAPIV3.ExternalDocumentationObject;
+    example?: any;
+    deprecated?: boolean;
+    format?: "int32" | "int64" | "float" | "double" | "byte" | "binary" | "date" | "dateTime" | "password" | "base64";
+    additionalProperties?: boolean | import("../type").ISchemaObject;
+    properties?: {
+        [name: string]: import("../type").ISchemaObject;
+    };
+    allOf?: import("../type").ISchemaObject[];
+    oneOf?: import("../type").ISchemaObject[];
+    anyOf?: import("../type").ISchemaObject[];
+    'x-enum-varnames'?: string[];
+    'x-enum-comments'?: {
+        [name: string]: string;
+    };
+    items: import("../type").ISchemaObject;
+} | {
+    type: string;
+    enum?: any[];
+    title?: string;
+    description?: string;
+    default?: any;
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: boolean;
+    minimum?: number;
+    exclusiveMinimum?: boolean;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[];
+    not?: OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject;
+    nullable?: boolean;
+    discriminator?: OpenAPIV3.DiscriminatorObject;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    xml?: OpenAPIV3.XMLObject;
+    externalDocs?: OpenAPIV3.ExternalDocumentationObject;
+    example?: any;
+    deprecated?: boolean;
+    format?: "int32" | "int64" | "float" | "double" | "byte" | "binary" | "date" | "dateTime" | "password" | "base64";
+    additionalProperties?: boolean | import("../type").ISchemaObject;
+    properties?: {
+        [name: string]: import("../type").ISchemaObject;
+    };
+    allOf?: import("../type").ISchemaObject[];
+    oneOf?: import("../type").ISchemaObject[];
+    anyOf?: import("../type").ISchemaObject[];
+    'x-enum-varnames'?: string[];
+    'x-enum-comments'?: {
+        [name: string]: string;
+    };
+};
+export declare function getRandomInt(min: number, max: number): number;

package/dist/parser-mock/util.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRandomInt = exports.inferSchema = exports.normalizeArray = exports.get = exports.objectify = void 0;
+const lodash_1 = require("lodash");
+const util_1 = require("../generator/util");
+function objectify(thing) {
+    if (!(0, lodash_1.isObject)(thing))
+        return {};
+    return thing;
+}
+exports.objectify = objectify;
+function get(openAPI, path) {
+    var _a, _b;
+    const refPaths = path.split('/');
+    const schema = (_b = (_a = openAPI.components) === null || _a === void 0 ? void 0 : _a.schemas) === null || _b === void 0 ? void 0 : _b[refPaths[refPaths.length - 1]];
+    if (!schema) {
+        return null;
+    }
+    return schema;
+}
+exports.get = get;
+function normalizeArray(arr) {
+    if ((0, lodash_1.isArray)(arr))
+        return arr;
+    return [arr];
+}
+exports.normalizeArray = normalizeArray;
+function isParameterObject(thing) {
+    return (thing === null || thing === void 0 ? void 0 : thing.schema) !== undefined;
+}
+function inferSchema(thing) {
+    if (isParameterObject(thing)) {
+        return thing.schema;
+    }
+    if ((0, util_1.isSchemaObject)(thing)) {
+        return Object.assign(Object.assign({}, thing), { type: 'object' });
+    }
+    return thing;
+}
+exports.inferSchema = inferSchema;
+function getRandomInt(min, max) {
+    const minCeiled = Math.ceil(min);
+    const maxFloored = Math.floor(max);
+    return Math.floor(Math.random() * (maxFloored - minCeiled) + minCeiled);
+}
+exports.getRandomInt = getRandomInt;

package/dist/type.d.ts

@@ -0,0 +1,72 @@
+import { OpenAPIV3 } from 'openapi-types';
+type Modify<T, R> = Omit<T, keyof R> & R;
+type ICustomBaseSchemaObject = {
+    type: ISchemaObjectType;
+    format?: ISchemaObjectFormat;
+    additionalProperties?: boolean | ISchemaObject;
+    properties?: {
+        [name: string]: ISchemaObject;
+    };
+    allOf?: ISchemaObject[];
+    oneOf?: ISchemaObject[];
+    anyOf?: ISchemaObject[];
+    'x-enum-varnames'?: string[];
+    'x-enum-comments'?: {
+        [name: string]: string;
+    };
+};
+export type ArraySchemaObject = Modify<OpenAPIV3.ArraySchemaObject, ICustomBaseSchemaObject & {
+    items: ISchemaObject;
+}>;
+export type BinaryArraySchemaObject = ArraySchemaObject;
+export type NonArraySchemaObject = Modify<OpenAPIV3.NonArraySchemaObject, ICustomBaseSchemaObject>;
+export type SchemaObject = ArraySchemaObject | NonArraySchemaObject;
+export type ISchemaObject = SchemaObject | ReferenceObject;
+export type ReferenceObject = OpenAPIV3.ReferenceObject;
+export type PathItemObject = Modify<OpenAPIV3.PathItemObject, {
+    parameters?: (ReferenceObject | ParameterObject)[];
+}>;
+export type OperationObject = Modify<OpenAPIV3.OperationObject, {
+    parameters?: (ReferenceObject | ParameterObject)[];
+}>;
+export type ComponentsObject = OpenAPIV3.ComponentsObject;
+export type OpenAPIObject = OpenAPIV3.Document;
+export type ParameterObject = Modify<OpenAPIV3.ParameterObject, {
+    schema?: ISchemaObject;
+}>;
+export type ResponsesObject = OpenAPIV3.ResponsesObject;
+export type ResponseObject = OpenAPIV3.ResponseObject & {
+    example?: any;
+};
+export type RequestBodyObject = OpenAPIV3.RequestBodyObject;
+export type ContentObject = {
+    [media: string]: OpenAPIV3.MediaTypeObject;
+};
+export declare enum SchemaObjectFormat {
+    int32 = "int32",
+    int64 = "int64",
+    float = "float",
+    double = "double",
+    byte = "byte",
+    binary = "binary",
+    date = "date",
+    dateTime = "date-time",
+    password = "password",
+    base64 = "base64"
+}
+export type ISchemaObjectFormat = keyof typeof SchemaObjectFormat;
+export declare enum SchemaObjectType {
+    array = "array",
+    stringArray = "string[]",
+    boolean = "boolean",
+    object = "object",
+    number = "number",
+    string = "string",
+    integer = "integer",
+    enum = "enum",
+    null = "null",
+    union = "union",
+    file = "file"
+}
+export type ISchemaObjectType = keyof typeof SchemaObjectType;
+export {};

package/dist/type.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaObjectType = exports.SchemaObjectFormat = void 0;
+var SchemaObjectFormat;
+(function (SchemaObjectFormat) {
+    SchemaObjectFormat["int32"] = "int32";
+    SchemaObjectFormat["int64"] = "int64";
+    SchemaObjectFormat["float"] = "float";
+    SchemaObjectFormat["double"] = "double";
+    SchemaObjectFormat["byte"] = "byte";
+    SchemaObjectFormat["binary"] = "binary";
+    SchemaObjectFormat["date"] = "date";
+    SchemaObjectFormat["dateTime"] = "date-time";
+    SchemaObjectFormat["password"] = "password";
+    SchemaObjectFormat["base64"] = "base64";
+})(SchemaObjectFormat || (exports.SchemaObjectFormat = SchemaObjectFormat = {}));
+var SchemaObjectType;
+(function (SchemaObjectType) {
+    SchemaObjectType["array"] = "array";
+    SchemaObjectType["stringArray"] = "string[]";
+    SchemaObjectType["boolean"] = "boolean";
+    SchemaObjectType["object"] = "object";
+    SchemaObjectType["number"] = "number";
+    SchemaObjectType["string"] = "string";
+    SchemaObjectType["integer"] = "integer";
+    SchemaObjectType["enum"] = "enum";
+    SchemaObjectType["null"] = "null";
+    SchemaObjectType["union"] = "union";
+    SchemaObjectType["file"] = "file";
+})(SchemaObjectType || (exports.SchemaObjectType = SchemaObjectType = {}));

package/dist/util.d.ts

@@ -0,0 +1,2 @@
+export declare const getImportStatement: (requestLibPath: string) => string;
+export declare const getOpenAPIConfig: (schemaPath: string) => Promise<unknown>;

package/dist/util.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOpenAPIConfig = exports.getImportStatement = void 0;
+const tslib_1 = require("tslib");
+const axios_1 = tslib_1.__importDefault(require("axios"));
+const http_1 = tslib_1.__importDefault(require("http"));
+const https_1 = tslib_1.__importDefault(require("https"));
+const swagger2openapi_1 = tslib_1.__importDefault(require("swagger2openapi"));
+const log_1 = tslib_1.__importDefault(require("./log"));
+const getImportStatement = (requestLibPath) => {
+    if (requestLibPath) {
+        if (requestLibPath.startsWith('import')) {
+            return requestLibPath;
+        }
+        return `import request from '${requestLibPath}';`;
+    }
+    return `import request from 'axios';`;
+};
+exports.getImportStatement = getImportStatement;
+function getSchema(schemaPath) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (schemaPath.startsWith('http')) {
+            const isHttps = schemaPath.startsWith('https:');
+            const protocol = isHttps ? https_1.default : http_1.default;
+            try {
+                const agent = new protocol.Agent({
+                    rejectUnauthorized: false,
+                });
+                const config = isHttps ? { httpsAgent: agent } : { httpAgent: agent };
+                const json = yield axios_1.default
+                    .get(schemaPath, config)
+                    .then((res) => res.data);
+                return json;
+            }
+            catch (error) {
+                console.log('fetch openapi error:', error);
+            }
+            return;
+        }
+        if (require.cache[schemaPath]) {
+            delete require.cache[schemaPath];
+        }
+        const schema = (yield require(schemaPath));
+        return schema;
+    });
+}
+function converterSwaggerToOpenApi(swagger) {
+    if (!swagger.swagger) {
+        return swagger;
+    }
+    return new Promise((resolve, reject) => {
+        const convertOptions = {
+            patch: true,
+            warnOnly: true,
+            resolveInternal: true,
+        };
+        // options.patch = true; // fix up small errors in the source definition
+        // options.warnOnly = true; // Do not throw on non-patchable errors
+        // options.warnOnly = true; // enable resolution of internal $refs, also disables deduplication of requestBodies
+        swagger2openapi_1.default.convertObj(swagger, convertOptions, (err, options) => {
+            (0, log_1.default)(['💺 将 Swagger 转化为 openAPI']);
+            if (err) {
+                return reject(err);
+            }
+            resolve(options.openapi);
+        });
+    });
+}
+const getOpenAPIConfig = (schemaPath) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    const schema = yield getSchema(schemaPath);
+    if (!schema) {
+        return null;
+    }
+    const openAPI = yield converterSwaggerToOpenApi(schema);
+    return openAPI;
+});
+exports.getOpenAPIConfig = getOpenAPIConfig;

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "openapi-ts-request",
+  "version": "0.1.0",
+  "description": "Swagger2/OpenAPI3 to TypeScript, Request Client, Display Label",
+  "packageManager": "pnpm@9.4.0",
+  "repository": {
+    "type": "git",
+    "url": "git+git@github.com:openapi-ui/openapi-ts-request.git"
+  },
+  "license": "MIT",
+  "author": "rookie-luochao",
+  "main": "dist/index.js",
+  "types": "index.d.ts",
+  "bin": {
+    "openapi-ts-request": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "templates",
+    "prettier.config.cjs"
+  ],
+  "scripts": {
+    "start": "tsc -w",
+    "build": "tsc",
+    "changeset": "changeset",
+    "lint": "eslint ./src --report-unused-disable-directives --max-warnings=0",
+    "lint:fix": "eslint ./src --report-unused-disable-directives --max-warnings=0 --fix",
+    "test": "rm -rf ./test/apis/ ./test/mocks && npm run build && cd ./test && node ./test.js && cd ..",
+    "test:windows": "rimraf ./test/apis/ ./test/mocks && npm run build && cd ./test && node ./test.js && cd ..",
+    "prepare": "husky"
+  },
+  "dependencies": {
+    "@prettier/sync": "^0.5.2",
+    "axios": "^1.7.2",
+    "chalk": "^4.1.2",
+    "cosmiconfig": "^9.0.0",
+    "glob": "^10.4.2",
+    "lodash": "^4.17.21",
+    "memoizee": "^0.4.17",
+    "mockjs": "^1.1.0",
+    "nunjucks": "^3.2.4",
+    "prettier": "^3.3.2",
+    "reserved-words": "^0.1.2",
+    "rimraf": "^5.0.7",
+    "swagger2openapi": "^7.0.8",
+    "tiny-pinyin": "^1.3.2"
+  },
+  "devDependencies": {
+    "@changesets/changelog-github": "^0.5.0",
+    "@changesets/cli": "^2.27.6",
+    "@commitlint/cli": "^19.2.1",
+    "@commitlint/config-conventional": "^19.2.2",
+    "@trivago/prettier-plugin-sort-imports": "^4.3.0",
+    "@types/lodash": "^4.17.5",
+    "@types/memoizee": "^0.4.11",
+    "@types/mockjs": "^1.0.10",
+    "@types/node": "^20.14.6",
+    "@types/nunjucks": "^3.2.6",
+    "@types/reserved-words": "^0.1.4",
+    "@types/swagger2openapi": "^7.0.4",
+    "@typescript-eslint/eslint-plugin": "^7.9.0",
+    "@typescript-eslint/parser": "^7.9.0",
+    "eslint": "^8.56.0",
+    "husky": "^9.0.11",
+    "lint-staged": "^15.2.5",
+    "np": "^10.0.6",
+    "openapi-types": "^12.1.3",
+    "tslib": "^2.6.3",
+    "typescript": "5.4.5"
+  },
+  "keywords": [
+    "openapi",
+    "openapi3",
+    "swagger",
+    "openapi to ts",
+    "openapi to request client",
+    "openapi to axios client",
+    "openapi to fetch client",
+    "openapi to uni.request client"
+  ]
+}

package/prettier.config.cjs

@@ -0,0 +1,9 @@
+module.exports = {
+  singleQuote: true,
+  arrowParens: 'always',
+  trailingComma: 'es5',
+  importOrder: ['^@?\\w', '^@/(.*)$', '^[./]'],
+  importOrderSeparation: true,
+  importOrderSortSpecifiers: true,
+  plugins: ['@trivago/prettier-plugin-sort-imports'],
+};

package/templates/displayEnumLabel.njk

@@ -0,0 +1,10 @@
+/* eslint-disable */
+// @ts-ignore
+import * as {{ namespace }} from './{{ interfaceFileName }}';
+
+{% for type in list -%}
+export function {{ type.displayLabelFuncName }}(field: {{ namespace }}.I{{ type.typeName }}) {
+  return ({{ type.enumLabelType }})[field]
+}
+
+{% endfor -%}