openapi-ts-request 0.1.0

package/dist/generator/util.d.ts

@@ -0,0 +1,18 @@
+import { ArraySchemaObject, BinaryArraySchemaObject, ComponentsObject, ISchemaObject, NonArraySchemaObject, OperationObject, ReferenceObject, SchemaObject } from '../type';
+import { ITypeItem } from './type';
+export declare function stripDot(str: string): string;
+export declare function resolveTypeName(typeName: string): string;
+export declare function getDefaultType(schemaObject?: ISchemaObject | string, namespace?: string, schemas?: ComponentsObject['schemas']): string;
+export declare function getDefaultFileTag(operationObject: OperationObject, apiPath: string): string[];
+export declare function handleDuplicateTypeNames(interfaceTPConfigs: ITypeItem[]): void;
+export declare function getBasePrefix(paths: string[]): string;
+export declare function genDefaultFunctionName(path: string, pathBasePrefix: string): string;
+export declare function getFinalFileName(s: string): string;
+export declare function replaceDot(s: string): string;
+export declare function resolveFunctionName(functionName: string, methodName: string): string;
+export declare function markAllowSchema(schemaStr: string, schemas: ComponentsObject['schemas']): void;
+export declare function isReferenceObject(schema: unknown): schema is ReferenceObject;
+export declare function isSchemaObject(schema: unknown): schema is SchemaObject;
+export declare function isNonArraySchemaObject(schema: unknown): schema is NonArraySchemaObject;
+export declare function isArraySchemaObject(schema: unknown): schema is ArraySchemaObject;
+export declare function isBinaryArraySchemaObject(schema: unknown): schema is BinaryArraySchemaObject;

package/dist/generator/util.js

@@ -0,0 +1,314 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBinaryArraySchemaObject = exports.isArraySchemaObject = exports.isNonArraySchemaObject = exports.isSchemaObject = exports.isReferenceObject = exports.markAllowSchema = exports.resolveFunctionName = exports.replaceDot = exports.getFinalFileName = exports.genDefaultFunctionName = exports.getBasePrefix = exports.handleDuplicateTypeNames = exports.getDefaultFileTag = exports.getDefaultType = exports.resolveTypeName = exports.stripDot = void 0;
+const tslib_1 = require("tslib");
+const lodash_1 = require("lodash");
+const reserved_words_1 = tslib_1.__importDefault(require("reserved-words"));
+const tiny_pinyin_1 = tslib_1.__importDefault(require("tiny-pinyin"));
+const log_1 = tslib_1.__importDefault(require("../log"));
+const config_1 = require("./config");
+function stripDot(str) {
+    return str.replace(/[-_ .](\w)/g, (_all, letter) => letter.toUpperCase());
+}
+exports.stripDot = stripDot;
+// 兼容C#泛型的typeLastName取法
+function getTypeLastName(typeName) {
+    var _a, _b, _c, _d, _e;
+    const tempTypeName = typeName || '';
+    const childrenTypeName = (_a = tempTypeName === null || tempTypeName === void 0 ? void 0 : tempTypeName.match(/\[\[.+\]\]/g)) === null || _a === void 0 ? void 0 : _a[0];
+    if (!childrenTypeName) {
+        const publicKeyToken = ((_c = (_b = tempTypeName.split('PublicKeyToken=')) === null || _b === void 0 ? void 0 : _b[1]) !== null && _c !== void 0 ? _c : '').replace('null', '');
+        const firstTempTypeName = (_e = (_d = tempTypeName.split(',')) === null || _d === void 0 ? void 0 : _d[0]) !== null && _e !== void 0 ? _e : tempTypeName;
+        let typeLastName = firstTempTypeName.split('/').pop().split('.').pop();
+        if (typeLastName.endsWith('[]')) {
+            typeLastName =
+                typeLastName.substring(0, typeLastName.length - 2) + 'Array';
+        }
+        // 特殊处理C#默认系统类型，不追加publicKeyToken
+        const isCsharpSystemType = firstTempTypeName.startsWith('System.');
+        if (!publicKeyToken || isCsharpSystemType) {
+            return typeLastName;
+        }
+        return `${typeLastName}_${publicKeyToken}`;
+    }
+    const currentTypeName = getTypeLastName(tempTypeName.replace(childrenTypeName, ''));
+    const childrenTypeNameLastName = getTypeLastName(childrenTypeName.substring(2, childrenTypeName.length - 2));
+    return `${currentTypeName}_${childrenTypeNameLastName}`;
+}
+// 类型声明过滤关键字
+function resolveTypeName(typeName) {
+    if (reserved_words_1.default.check(typeName)) {
+        return `__openAPI__${typeName}`;
+    }
+    const typeLastName = getTypeLastName(typeName);
+    const name = typeLastName
+        .replace(/[-_ ](\w)/g, (_all, letter) => letter.toUpperCase())
+        .replace(/[^\w^\s^\u4e00-\u9fa5]/gi, '');
+    // 当model名称是number开头的时候，ts会报错。这种场景一般发生在后端定义的名称是中文
+    if (name === '_' || /^\d+$/.test(name)) {
+        (0, log_1.default)('⚠️  models不能以number开头，原因可能是Model定义名称为中文, 建议联系后台修改');
+        return `Pinyin_${name}`;
+    }
+    if (!/[\u3220-\uFA29]/.test(name) && !/^\d$/.test(name)) {
+        return name;
+    }
+    const noBlankName = name.replace(/ +/g, '');
+    return tiny_pinyin_1.default.convertToPinyin(noBlankName, '', true);
+}
+exports.resolveTypeName = resolveTypeName;
+function getRefName(refObject) {
+    if (!isReferenceObject(refObject)) {
+        return refObject;
+    }
+    const refPaths = refObject.$ref.split('/');
+    return resolveTypeName(refPaths[refPaths.length - 1]);
+}
+function getDefaultType(schemaObject, namespace = '', schemas) {
+    var _a, _b;
+    if ((0, lodash_1.isUndefined)(schemaObject) || (0, lodash_1.isNull)(schemaObject)) {
+        return 'any';
+    }
+    if (!(0, lodash_1.isObject)(schemaObject)) {
+        return schemaObject;
+    }
+    if (isReferenceObject(schemaObject)) {
+        return [namespace, getRefName(schemaObject)].filter((s) => s).join('.');
+    }
+    let type = schemaObject === null || schemaObject === void 0 ? void 0 : schemaObject.type;
+    const dateEnum = ['Date', 'date', 'dateTime', 'date-time', 'datetime'];
+    const stringEnum = ['string', 'email', 'password', 'url', 'byte', 'binary'];
+    if (type === 'null') {
+        return 'null';
+    }
+    if (config_1.numberEnum.includes(schemaObject.format)) {
+        type = 'number';
+    }
+    if (schemaObject.enum) {
+        type = 'enum';
+    }
+    if (config_1.numberEnum.includes(type)) {
+        return 'number';
+    }
+    if (dateEnum.includes(type)) {
+        return 'Date';
+    }
+    if (stringEnum.includes(type)) {
+        return 'string';
+    }
+    if (type === 'boolean') {
+        return 'boolean';
+    }
+    if (type === 'array') {
+        let items = schemaObject.items;
+        if ('schema' in schemaObject) {
+            items = schemaObject.schema.items;
+        }
+        if (Array.isArray(items)) {
+            const arrayItemType = items
+                .map((subType) => getDefaultType((subType.schema || subType), namespace))
+                .toString();
+            return `[${arrayItemType}]`;
+        }
+        const arrayType = getDefaultType(items, namespace);
+        return arrayType.includes(' | ') ? `(${arrayType})[]` : `${arrayType}[]`;
+    }
+    if (type === 'enum') {
+        return Array.isArray(schemaObject.enum)
+            ? Array.from(new Set(schemaObject.enum.map((v) => typeof v === 'string'
+                ? `"${v.replace(/"/g, '"')}"`
+                : getDefaultType(v)))).join(' | ')
+            : 'string';
+    }
+    if (schemaObject.oneOf && schemaObject.oneOf.length) {
+        return schemaObject.oneOf
+            .map((item) => getDefaultType(item, namespace))
+            .join(' | ');
+    }
+    if ((_a = schemaObject.anyOf) === null || _a === void 0 ? void 0 : _a.length) {
+        return schemaObject.anyOf
+            .map((item) => getDefaultType(item, namespace))
+            .join(' | ');
+    }
+    if ((_b = schemaObject.allOf) === null || _b === void 0 ? void 0 : _b.length) {
+        const allofList = schemaObject.allOf.map((item) => {
+            var _a;
+            if (isReferenceObject(item)) {
+                // 不使用 getRefName 函数处理，无法通过 schemas[schemaKey] 获取到schema
+                const refPaths = item.$ref.split('/');
+                const schemaKey = refPaths[refPaths.length - 1];
+                if ((_a = schemas === null || schemas === void 0 ? void 0 : schemas[schemaKey]) === null || _a === void 0 ? void 0 : _a.enum) {
+                    return `I${getDefaultType(item, namespace)}`;
+                }
+            }
+            return getDefaultType(item, namespace);
+        });
+        return `(${allofList.join(' & ')})`;
+    }
+    if (schemaObject.type === 'object' || schemaObject.properties) {
+        if (!(0, lodash_1.keys)(schemaObject.properties).length) {
+            return 'Record<string, any>';
+        }
+        return `{ ${(0, lodash_1.keys)(schemaObject.properties)
+            .map((key) => {
+            var _a, _b;
+            let required = false;
+            if ((0, lodash_1.isBoolean)(schemaObject.required) && schemaObject.required) {
+                required = true;
+            }
+            if ((0, lodash_1.isArray)(schemaObject.required) &&
+                schemaObject.required.includes(key)) {
+                required = true;
+            }
+            if ('required' in (schemaObject.properties[key] || {}) &&
+                ((_a = schemaObject.properties[key]) === null || _a === void 0 ? void 0 : _a.required)) {
+                required = true;
+            }
+            /**
+             * 将类型属性变为字符串，兼容错误格式如：
+             * 3d_tile(数字开头)等错误命名，
+             * 在后面进行格式化的时候会将正确的字符串转换为正常形式，
+             * 错误的继续保留字符串。
+             * */
+            return `'${key}'${required ? '' : '?'}: ${getDefaultType((_b = schemaObject.properties) === null || _b === void 0 ? void 0 : _b[key], namespace)}; `;
+        })
+            .join('')}}`;
+    }
+    return 'any';
+}
+exports.getDefaultType = getDefaultType;
+function getDefaultFileTag(operationObject, apiPath) {
+    return operationObject['x-swagger-router-controller']
+        ? [operationObject['x-swagger-router-controller']]
+        : operationObject.tags || [operationObject.operationId] || [
+            apiPath.replace('/', '').split('/')[1],
+        ];
+}
+exports.getDefaultFileTag = getDefaultFileTag;
+function findDuplicateTypeNames(arr) {
+    const counts = (0, lodash_1.countBy)(arr);
+    const duplicates = (0, lodash_1.filter)((0, lodash_1.keys)(counts), (key) => counts[key] > 1);
+    return duplicates;
+}
+function handleDuplicateTypeNames(interfaceTPConfigs) {
+    const duplicateTypeNames = findDuplicateTypeNames((0, lodash_1.map)(interfaceTPConfigs, (item) => item.typeName));
+    if (!(0, lodash_1.isEmpty)(duplicateTypeNames)) {
+        (0, lodash_1.forEach)(duplicateTypeNames, (typeName) => {
+            const selectInterfaceTPConfigs = (0, lodash_1.filter)(interfaceTPConfigs, (interfaceTP) => interfaceTP.typeName === typeName);
+            (0, lodash_1.forEach)(selectInterfaceTPConfigs, (interfaceTP, index) => {
+                if (index >= 1) {
+                    interfaceTP.typeName = `${interfaceTP.typeName}${index + 1}`;
+                    if (interfaceTP.displayLabelFuncName) {
+                        interfaceTP.displayLabelFuncName = `${interfaceTP.displayLabelFuncName}${index + 1}`;
+                    }
+                }
+            });
+        });
+    }
+}
+exports.handleDuplicateTypeNames = handleDuplicateTypeNames;
+// 检测所有path重复区域（prefix）
+function getBasePrefix(paths) {
+    const arr = [];
+    paths
+        .map((item) => item.split('/'))
+        .forEach((pathItem) => {
+        pathItem.forEach((item, key) => {
+            if (arr.length <= key) {
+                arr[key] = [];
+            }
+            arr[key].push(item);
+        });
+    });
+    const res = [];
+    arr
+        .map((item) => Array.from(new Set(item)))
+        .every((item) => {
+        const b = item.length === 1;
+        if (b) {
+            res.push(item);
+        }
+        return b;
+    });
+    return `${res.join('/')}/`;
+}
+exports.getBasePrefix = getBasePrefix;
+// 将地址path路径转为大驼峰
+function genDefaultFunctionName(path, pathBasePrefix) {
+    // 首字母转大写
+    function toUpperFirstLetter(text) {
+        return text.charAt(0).toUpperCase() + text.slice(1);
+    }
+    return path === null || path === void 0 ? void 0 : path.replace(pathBasePrefix, '').split('/').map((str) => {
+        /**
+         * 兼容错误命名如 /user/:id/:name
+         * 因为是typeName，所以直接进行转换
+         * */
+        let s = resolveTypeName(str);
+        if (s.includes('-')) {
+            s = s.replace(/(-\w)+/g, (_match, p1) => p1 === null || p1 === void 0 ? void 0 : p1.slice(1).toUpperCase());
+        }
+        if (s.match(/^{.+}$/gim)) {
+            return `By${toUpperFirstLetter(s.slice(1, s.length - 1))}`;
+        }
+        return toUpperFirstLetter(s);
+    }).join('');
+}
+exports.genDefaultFunctionName = genDefaultFunctionName;
+function getFinalFileName(s) {
+    // 支持下划线、中划线和空格分隔符，注意分隔符枚举值的顺序不能改变，否则正则匹配会报错
+    return s.replace(/[-_ ](\w)/g, (_all, letter) => letter.toUpperCase());
+}
+exports.getFinalFileName = getFinalFileName;
+function replaceDot(s) {
+    return s
+        .replace(/\./g, '_')
+        .replace(/[-_ ](\w)/g, (_all, letter) => letter.toUpperCase());
+}
+exports.replaceDot = replaceDot;
+function resolveFunctionName(functionName, methodName) {
+    // 类型声明过滤关键字
+    if (reserved_words_1.default.check(functionName)) {
+        return `${functionName}Using${methodName.toUpperCase()}`;
+    }
+    return functionName;
+}
+exports.resolveFunctionName = resolveFunctionName;
+// 标记引用的 $ref 对应的schema
+function markAllowSchema(schemaStr, schemas) {
+    const refs = schemaStr.match(/#\/components\/schemas\/([A-Za-z0-9._-]+)/g);
+    (0, lodash_1.forEach)(refs, (ref) => {
+        const refPaths = ref.split('/');
+        const schema = schemas === null || schemas === void 0 ? void 0 : schemas[refPaths[refPaths.length - 1]];
+        if (schema) {
+            schema.isAllowed = true;
+        }
+        markAllowSchema(JSON.stringify(schema), schemas);
+    });
+}
+exports.markAllowSchema = markAllowSchema;
+function isReferenceObject(schema) {
+    return (schema === null || schema === void 0 ? void 0 : schema.$ref) !== undefined;
+}
+exports.isReferenceObject = isReferenceObject;
+function isSchemaObject(schema) {
+    return (schema === null || schema === void 0 ? void 0 : schema.properties) !== undefined;
+}
+exports.isSchemaObject = isSchemaObject;
+function isNonArraySchemaObject(schema) {
+    return ((schema === null || schema === void 0 ? void 0 : schema.type) === 'object' &&
+        (schema === null || schema === void 0 ? void 0 : schema.properties) !== undefined);
+}
+exports.isNonArraySchemaObject = isNonArraySchemaObject;
+function isArraySchemaObject(schema) {
+    return (((schema === null || schema === void 0 ? void 0 : schema.type) === 'array' ||
+        (schema === null || schema === void 0 ? void 0 : schema.type) === 'stringArray') &&
+        (schema === null || schema === void 0 ? void 0 : schema.items) !== undefined);
+}
+exports.isArraySchemaObject = isArraySchemaObject;
+function isBinaryArraySchemaObject(schema) {
+    var _a, _b;
+    return (isArraySchemaObject(schema) &&
+        (((_a = schema.items) === null || _a === void 0 ? void 0 : _a.format) === 'binary' ||
+            ((_b = schema.items) === null || _b === void 0 ? void 0 : _b.format) === 'base64'));
+}
+exports.isBinaryArraySchemaObject = isBinaryArraySchemaObject;

package/dist/index.d.ts

@@ -0,0 +1,125 @@
+import { APIDataType } from './generator/type';
+import { ComponentsObject, OpenAPIObject, OperationObject, ReferenceObject, SchemaObject } from './type';
+export type GenerateServiceProps = {
+    /**
+     * Swagger 2.0 或 OpenAPI 3.0 的地址
+     */
+    schemaPath: string;
+    /**
+     * 生成的文件夹的路径
+     */
+    serversPath?: string;
+    /**
+     * 自定义请求方法路径
+     * 默认: import request from 'axios';
+     * 方式一: '@/request'
+     * 方式二: import request from '@/request';
+     */
+    requestLibPath?: string;
+    /**
+     * 只解析归属于 tags 集合的api 和 schema
+     */
+    allowedTags?: string[];
+    /**
+     * 自定义请求方法 options 参数类型
+     */
+    requestOptionsType?: string;
+    /**
+     * 自定义请求方法表达式
+     * 例如: const request = require('node-fetch');
+     */
+    requestImportStatement?: string;
+    /**
+     * api 的前缀
+     */
+    apiPrefix?: string | ((params: {
+        path: string;
+        method: string;
+        namespace: string;
+        functionName: string;
+    }) => string);
+    /**
+     * response中数据字段
+     * example: ['result', 'res']
+     */
+    dataFields?: string[];
+    /**
+     * mock目录
+     */
+    mockFolder?: string;
+    /**
+     * 默认为false，true时使用null代替可选值
+     */
+    nullable?: boolean;
+    /**
+     * 模板文件、请求函数采用小驼峰命名
+     */
+    isCamelCase?: boolean;
+    /**
+     * 命名空间名称，默认为API，不需要关注
+     */
+    namespace?: string;
+    /**
+     * 模板文件的文件路径，不需要关注
+     */
+    templatesFolder?: string;
+    /**
+     * 自定义 hook
+     */
+    hook?: {
+        /** change open api data after constructor */
+        afterOpenApiDataInited?: (openAPIData: OpenAPIObject) => OpenAPIObject;
+        /** 自定义函数名称 */
+        customFunctionName?: (data: APIDataType) => string;
+        /** 自定义类型名称 */
+        customTypeName?: (data: APIDataType) => string;
+        /** 自定义 options 默认值 */
+        customOptionsDefaultValue?: (data: OperationObject) => Record<string, any> | undefined;
+        /** 自定义类名 */
+        customClassName?: (tagName: string) => string;
+        /**
+         * 自定义获取type hook
+         * 返回非字符串将使用默认方法获取type
+         * @example set number to string
+         * function customType(schemaObject,namespace){
+         *  if(schemaObject.type==='number' && !schemaObject.format){
+         *    return 'BigDecimalString';
+         *  }
+         * }
+         */
+        customType?: ({ schemaObject, namespace, schemas, originGetType, }: {
+            schemaObject: SchemaObject | ReferenceObject;
+            namespace: string;
+            schemas?: ComponentsObject['schemas'];
+            originGetType: (schemaObject: SchemaObject, namespace: string) => string;
+        }) => string;
+        /**
+         * 自定义生成文件名，可返回多个，表示生成多个文件
+         * 返回为空，则使用默认的获取方法获取
+         * @example  使用operationId生成文件名
+         * function customFileNames(operationObject,apiPath){
+         *   const operationId=operationObject.operationId;
+         *   if (!operationId) {
+         *      console.warn('[Warning] no operationId', apiPath);
+         *      return;
+         *    }
+         *    const res = operationId.split('_');
+         *    if (res.length > 1) {
+         *      res.shift();
+         *      if (res.length > 2) {
+         *        console.warn('[Warning]  operationId has more than 2 part', apiPath);
+         *      }
+         *      return [res.join('_')];
+         *    } else {
+         *      const controllerName = (res || [])[0];
+         *      if (controllerName) {
+         *        return [controllerName];
+         *      }
+         *      return;
+         *    }
+         * }
+         */
+        customFileNames?: (operationObject: OperationObject, apiPath: string, apiMethod: string) => string[];
+    };
+};
+export declare function generateService({ requestLibPath, schemaPath, mockFolder, allowedTags, ...rest }: GenerateServiceProps): Promise<void>;

package/dist/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateService = void 0;
+const tslib_1 = require("tslib");
+const lodash_1 = require("lodash");
+const mockGenarator_1 = require("./generator/mockGenarator");
+const serviceGenarator_1 = tslib_1.__importDefault(require("./generator/serviceGenarator"));
+const util_1 = require("./util");
+function generateService(_a) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var { requestLibPath, schemaPath, mockFolder, allowedTags } = _a, rest = tslib_1.__rest(_a, ["requestLibPath", "schemaPath", "mockFolder", "allowedTags"]);
+        if (!schemaPath) {
+            return;
+        }
+        const openAPI = (yield (0, util_1.getOpenAPIConfig)(schemaPath));
+        if ((0, lodash_1.isEmpty)(openAPI)) {
+            return;
+        }
+        const requestImportStatement = (0, util_1.getImportStatement)(requestLibPath);
+        const serviceGenerator = new serviceGenarator_1.default(Object.assign({ schemaPath, serversPath: './src/apis', requestImportStatement, requestOptionsType: '{[key: string]: any}', namespace: 'API', nullable: false, isCamelCase: true, allowedTags: allowedTags
+                ? (0, lodash_1.map)(allowedTags, (item) => item.toLowerCase())
+                : null }, rest), openAPI);
+        serviceGenerator.genFile();
+        if (mockFolder) {
+            (0, mockGenarator_1.mockGenerator)({
+                openAPI,
+                mockFolder: mockFolder,
+            });
+        }
+    });
+}
+exports.generateService = generateService;

package/dist/log.d.ts

@@ -0,0 +1,2 @@
+declare const log: (...rest: any[]) => void;
+export default log;

package/dist/log.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const log = (...rest) => console.log(`${chalk_1.default.blue('[openAPI]')}: ${rest.join('\n')}`);
+exports.default = log;

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

@@ -0,0 +1,19 @@
+import { OpenAPIV3 } from 'openapi-types';
+import { OpenAPIObject } from '../type';
+export default class OpenAPIGeneratorMockJs {
+    protected openAPI: OpenAPIObject;
+    constructor(openAPI: OpenAPIObject);
+    private sampleFromSchema;
+    parser(): {
+        openapi: string;
+        info: OpenAPIV3.InfoObject;
+        servers?: OpenAPIV3.ServerObject[];
+        paths: OpenAPIV3.PathsObject<{}, {}>;
+        components?: OpenAPIV3.ComponentsObject;
+        security?: OpenAPIV3.SecurityRequirementObject[];
+        tags?: OpenAPIV3.TagObject[];
+        externalDocs?: OpenAPIV3.ExternalDocumentationObject;
+        'x-express-openapi-additional-middleware'?: (((request: any, response: any, next: any) => Promise<void>) | ((request: any, response: any, next: any) => void))[];
+        'x-express-openapi-validation-strict'?: boolean;
+    };
+}