@fairys/mocker-cli 0.0.1

package/esm/controller/proxy.router.js

@@ -0,0 +1,503 @@
+import node_fs from "node:fs";
+import { Controller, Get, Post } from "../utils/decorator.js";
+import { utils } from "../utils/index.js";
+import { ProxyRouter } from "../router/proxy.js";
+import { BaseController } from "./base.js";
+import { createProxyFile, getProxyFile } from "../utils/mcok.proxy.js";
+import chalk from "chalk";
+function applyDecs2203RFactory() {
+    function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+        return function(initializer) {
+            assertNotFinished(decoratorFinishedRef, "addInitializer");
+            assertCallable(initializer, "An initializer");
+            initializers.push(initializer);
+        };
+    }
+    function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+        var kindStr;
+        switch(kind){
+            case 1:
+                kindStr = "accessor";
+                break;
+            case 2:
+                kindStr = "method";
+                break;
+            case 3:
+                kindStr = "getter";
+                break;
+            case 4:
+                kindStr = "setter";
+                break;
+            default:
+                kindStr = "field";
+        }
+        var ctx = {
+            kind: kindStr,
+            name: isPrivate ? "#" + name : name,
+            static: isStatic,
+            private: isPrivate,
+            metadata: metadata
+        };
+        var decoratorFinishedRef = {
+            v: false
+        };
+        ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+        var get, set;
+        if (0 === kind) if (isPrivate) {
+            get = desc.get;
+            set = desc.set;
+        } else {
+            get = function() {
+                return this[name];
+            };
+            set = function(v) {
+                this[name] = v;
+            };
+        }
+        else if (2 === kind) get = function() {
+            return desc.value;
+        };
+        else {
+            if (1 === kind || 3 === kind) get = function() {
+                return desc.get.call(this);
+            };
+            if (1 === kind || 4 === kind) set = function(v) {
+                desc.set.call(this, v);
+            };
+        }
+        if (get) {
+            var originalGet = get;
+            get = function(target) {
+                if (0 === arguments.length) target = this;
+                return originalGet.call(target);
+            };
+        }
+        if (set) {
+            var originalSet = set;
+            set = function(target, value) {
+                if (1 === arguments.length) {
+                    value = target;
+                    target = this;
+                }
+                return originalSet.call(target, value);
+            };
+        }
+        if (isPrivate) ctx.access = get && set ? {
+            get: get,
+            set: set
+        } : get ? {
+            get: get
+        } : {
+            set: set
+        };
+        else {
+            var has = function(target) {
+                return name in target;
+            };
+            ctx.access = get && set ? {
+                has: has,
+                get: get,
+                set: set
+            } : get ? {
+                has: has,
+                get: get
+            } : {
+                has: has,
+                set: set
+            };
+        }
+        var newValue = dec(value, ctx);
+        decoratorFinishedRef.v = true;
+        return newValue;
+    }
+    function assertNotFinished(decoratorFinishedRef, fnName) {
+        if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+    }
+    function assertCallable(fn, hint) {
+        if ("function" != typeof fn) throw new TypeError(hint + " must be a function");
+    }
+    function assertValidReturnValue(kind, value) {
+        var type = typeof value;
+        if (1 === kind) {
+            if ("object" !== type || null === value) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+            if (void 0 !== value.get) assertCallable(value.get, "accessor.get");
+            if (void 0 !== value.set) assertCallable(value.set, "accessor.set");
+            if (void 0 !== value.init) assertCallable(value.init, "accessor.init");
+        } else if ("function" !== type) {
+            var hint;
+            hint = 0 === kind ? "field" : 10 === kind ? "class" : "method";
+            throw new TypeError(hint + " decorators must return a function or void 0");
+        }
+    }
+    function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+        var decs = decInfo[0];
+        var desc, init, value;
+        if (isPrivate) desc = 0 === kind || 1 === kind ? {
+            get: decInfo[3],
+            set: decInfo[4]
+        } : 3 === kind ? {
+            get: decInfo[3]
+        } : 4 === kind ? {
+            set: decInfo[3]
+        } : {
+            value: decInfo[3]
+        };
+        else if (0 !== kind) desc = Object.getOwnPropertyDescriptor(base, name);
+        if (1 === kind) value = {
+            get: desc.get,
+            set: desc.set
+        };
+        else if (2 === kind) value = desc.value;
+        else if (3 === kind) value = desc.get;
+        else if (4 === kind) value = desc.set;
+        var newValue, get, set;
+        if ("function" == typeof decs) {
+            newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+            if (void 0 !== newValue) {
+                assertValidReturnValue(kind, newValue);
+                if (0 === kind) init = newValue;
+                else if (1 === kind) {
+                    init = newValue.init;
+                    get = newValue.get || value.get;
+                    set = newValue.set || value.set;
+                    value = {
+                        get: get,
+                        set: set
+                    };
+                } else value = newValue;
+            }
+        } else for(var i = decs.length - 1; i >= 0; i--){
+            var dec = decs[i];
+            newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+            if (void 0 !== newValue) {
+                assertValidReturnValue(kind, newValue);
+                var newInit;
+                if (0 === kind) newInit = newValue;
+                else if (1 === kind) {
+                    newInit = newValue.init;
+                    get = newValue.get || value.get;
+                    set = newValue.set || value.set;
+                    value = {
+                        get: get,
+                        set: set
+                    };
+                } else value = newValue;
+                if (void 0 !== newInit) if (void 0 === init) init = newInit;
+                else if ("function" == typeof init) init = [
+                    init,
+                    newInit
+                ];
+                else init.push(newInit);
+            }
+        }
+        if (0 === kind || 1 === kind) {
+            if (void 0 === init) init = function(instance, init) {
+                return init;
+            };
+            else if ("function" != typeof init) {
+                var ownInitializers = init;
+                init = function(instance, init) {
+                    var value = init;
+                    for(var i = 0; i < ownInitializers.length; i++)value = ownInitializers[i].call(instance, value);
+                    return value;
+                };
+            } else {
+                var originalInitializer = init;
+                init = function(instance, init) {
+                    return originalInitializer.call(instance, init);
+                };
+            }
+            ret.push(init);
+        }
+        if (0 !== kind) {
+            if (1 === kind) {
+                desc.get = value.get;
+                desc.set = value.set;
+            } else if (2 === kind) desc.value = value;
+            else if (3 === kind) desc.get = value;
+            else if (4 === kind) desc.set = value;
+            if (isPrivate) if (1 === kind) {
+                ret.push(function(instance, args) {
+                    return value.get.call(instance, args);
+                });
+                ret.push(function(instance, args) {
+                    return value.set.call(instance, args);
+                });
+            } else if (2 === kind) ret.push(value);
+            else ret.push(function(instance, args) {
+                return value.call(instance, args);
+            });
+            else Object.defineProperty(base, name, desc);
+        }
+    }
+    function applyMemberDecs(Class, decInfos, metadata) {
+        var ret = [];
+        var protoInitializers;
+        var staticInitializers;
+        var existingProtoNonFields = new Map();
+        var existingStaticNonFields = new Map();
+        for(var i = 0; i < decInfos.length; i++){
+            var decInfo = decInfos[i];
+            if (Array.isArray(decInfo)) {
+                var kind = decInfo[1];
+                var name = decInfo[2];
+                var isPrivate = decInfo.length > 3;
+                var isStatic = kind >= 5;
+                var base;
+                var initializers;
+                if (isStatic) {
+                    base = Class;
+                    kind -= 5;
+                    staticInitializers = staticInitializers || [];
+                    initializers = staticInitializers;
+                } else {
+                    base = Class.prototype;
+                    protoInitializers = protoInitializers || [];
+                    initializers = protoInitializers;
+                }
+                if (0 !== kind && !isPrivate) {
+                    var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+                    var existingKind = existingNonFields.get(name) || 0;
+                    if (true === existingKind || 3 === existingKind && 4 !== kind || 4 === existingKind && 3 !== kind) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+                    if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+                    else existingNonFields.set(name, true);
+                }
+                applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+            }
+        }
+        pushInitializers(ret, protoInitializers);
+        pushInitializers(ret, staticInitializers);
+        return ret;
+    }
+    function pushInitializers(ret, initializers) {
+        if (initializers) ret.push(function(instance) {
+            for(var i = 0; i < initializers.length; i++)initializers[i].call(instance);
+            return instance;
+        });
+    }
+    function applyClassDecs(targetClass, classDecs, metadata) {
+        if (classDecs.length > 0) {
+            var initializers = [];
+            var newClass = targetClass;
+            var name = targetClass.name;
+            for(var i = classDecs.length - 1; i >= 0; i--){
+                var decoratorFinishedRef = {
+                    v: false
+                };
+                var nextNewClass = classDecs[i](newClass, {
+                    kind: "class",
+                    name: name,
+                    addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+                    metadata
+                });
+                decoratorFinishedRef.v = true;
+                if (void 0 !== nextNewClass) {
+                    assertValidReturnValue(10, nextNewClass);
+                    newClass = nextNewClass;
+                }
+            }
+            return [
+                defineMetadata(newClass, metadata),
+                function() {
+                    for(var i = 0; i < initializers.length; i++)initializers[i].call(newClass);
+                }
+            ];
+        }
+    }
+    function defineMetadata(Class, metadata) {
+        return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+            configurable: true,
+            enumerable: true,
+            value: metadata
+        });
+    }
+    return function(targetClass, memberDecs, classDecs, parentClass) {
+        if (void 0 !== parentClass) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+        var metadata = Object.create(void 0 === parentMetadata ? null : parentMetadata);
+        var e = applyMemberDecs(targetClass, memberDecs, metadata);
+        if (!classDecs.length) defineMetadata(targetClass, metadata);
+        return {
+            e: e,
+            get c () {
+                return applyClassDecs(targetClass, classDecs, metadata);
+            }
+        };
+    };
+}
+function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+    return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
+}
+var _dec, _initClass, _BaseController, _dec1, _dec2, _dec3, _dec4, _dec5, _initProto;
+_dec = Controller('/_fairys'), _dec1 = Post('/_proxy'), _dec2 = Get('/_proxy'), _dec3 = Get('/_proxy/_is_enabled'), _dec4 = Get('/_proxy/_start'), _dec5 = Get('/_proxy/_destroy');
+let _ProxyRouterController;
+class ProxyRouterController extends (_BaseController = BaseController) {
+    static{
+        ({ e: [_initProto], c: [_ProxyRouterController, _initClass] } = _apply_decs_2203_r(this, [
+            [
+                _dec1,
+                2,
+                "post_proxy"
+            ],
+            [
+                _dec2,
+                2,
+                "get_proxy"
+            ],
+            [
+                _dec3,
+                2,
+                "get_proxy_enabled"
+            ],
+            [
+                _dec4,
+                2,
+                "get_proxy_start"
+            ],
+            [
+                _dec5,
+                2,
+                "get_proxy_destroy"
+            ]
+        ], [
+            _dec
+        ], _BaseController));
+    }
+    constructor(){
+        super();
+        this.router = new ProxyRouter();
+    }
+    router = (_initProto(this), null);
+    post_proxy(req, res) {
+        try {
+            const { proxyList, dir, fileName = 'proxy', rootDir } = req.body;
+            let _rootDir = rootDir || utils.rootDir;
+            if (rootDir && !node_fs.existsSync(rootDir)) _rootDir = utils.rootDir;
+            const proxyData = createProxyFile(proxyList, _rootDir, dir, fileName);
+            if (proxyData?.proxyConfig) {
+                if (this.router?.isEnabled) this.router?.load(proxyList);
+                res.json({
+                    code: 200,
+                    message: '代理配置保存成功',
+                    data: proxyData.proxyConfig,
+                    proxyList: proxyList,
+                    rootDir: proxyData.rootDir,
+                    dir: proxyData.dir,
+                    cache: proxyData.cache,
+                    fileName: proxyData.fileName
+                });
+            } else res.json({
+                code: 404,
+                message: '生成配置文件错误'
+            });
+        } catch (error) {
+            res.status(500).json({
+                code: 500,
+                message: '保存代理配置失败',
+                error: error.message
+            });
+        }
+    }
+    get_proxy(req, res) {
+        try {
+            const savePath = req.query.dir?.trim();
+            const saveFileName = req.query.fileName?.trim();
+            const rootDir = req.query.rootDir?.trim();
+            const proxyData = getProxyFile(rootDir, savePath, saveFileName);
+            if (proxyData?.proxyList) res.json({
+                code: 200,
+                message: '读取代理配置成功',
+                data: proxyData.proxyList,
+                rootDir: proxyData.rootDir,
+                dir: proxyData.dir,
+                cache: proxyData.cache,
+                fileName: proxyData.fileName
+            });
+            else res.json({
+                code: 404,
+                message: '代理配置文件不存在'
+            });
+        } catch (error) {
+            res.status(500).json({
+                code: 500,
+                message: '读取代理配置失败',
+                error: error.message
+            });
+        }
+    }
+    get_proxy_enabled(req, res) {
+        res.json({
+            code: 200,
+            message: '代理服务是否启用',
+            data: this.router?.isEnabled
+        });
+    }
+    get_proxy_start(req, res) {
+        try {
+            const savePath = req.query.dir?.trim();
+            const saveFileName = req.query.fileName?.trim();
+            const rootDir = req.query.rootDir?.trim();
+            const proxyData = getProxyFile(rootDir, savePath, saveFileName);
+            if (proxyData?.proxyList) {
+                this.router?.load(proxyData.proxyList);
+                res.json({
+                    code: 200,
+                    message: '启动代理服务成功',
+                    data: proxyData.proxyList,
+                    rootDir: rootDir,
+                    dir: proxyData.dir,
+                    cache: proxyData.cache,
+                    fileName: proxyData.fileName,
+                    isEnabled: true
+                });
+            } else res.json({
+                code: 404,
+                message: '代理配置文件不存在'
+            });
+        } catch (error) {
+            res.status(500).json({
+                code: 500,
+                message: '启动代理配置失败',
+                error: error.message
+            });
+        }
+    }
+    get_proxy_destroy(req, res) {
+        try {
+            if (this.router?.router) this.router?.destroy("销毁proxy路由器实例");
+            else res.json({
+                code: 404,
+                message: '代理服务不存在'
+            });
+            res.json({
+                code: 200,
+                message: '销毁代理服务成功'
+            });
+        } catch (error) {
+            res.status(500).json({
+                code: 500,
+                message: '销毁代理服务失败',
+                error: error.message
+            });
+        }
+    }
+    start = (rootDir, dir, fileName)=>{
+        try {
+            const proxyData = getProxyFile(rootDir, dir, fileName);
+            if (proxyData?.proxyList) try {
+                this.router?.load(proxyData.proxyList);
+                console.log(chalk.green(`  启动代理服务成功，配置文件：${proxyData.rootDir}/${proxyData.dir}/${proxyData.fileName}.ts`));
+                console.log('');
+            } catch (error) {
+                console.log(chalk.red(`  启动代理服务失败，配置文件：${proxyData.rootDir}/${proxyData.dir}/${proxyData.fileName}.ts`));
+                console.log('');
+            }
+        } catch (error) {
+            console.log(chalk.red("  启动代理服务失败"));
+            console.log('');
+        }
+    };
+    static{
+        _initClass();
+    }
+}
+export { _ProxyRouterController as ProxyRouterController };

package/esm/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./base.js";
+export * from "./main.js";
+export * from "./connect.js";
+export * from "./ci.js";
+export * from "./plugins/rsbuild.js";

package/esm/index.js

@@ -0,0 +1,5 @@
+export * from "./base.js";
+export * from "./main.js";
+export * from "./connect.js";
+export * from "./ci.js";
+export * from "./plugins/rsbuild.js";

package/esm/main.d.ts

@@ -0,0 +1,15 @@
+import express from 'express';
+export declare class FairysMockerExpress {
+    base: import("./base.js").FairysMockerBase;
+    /**创建 app*/
+    createApp: (cb?: () => void) => express.Express | import("connect").Server;
+    /**检测端口，返回实际端口*/
+    detectPort: (port?: number) => Promise<unknown>;
+    /**启动服务器*/
+    listen: (port?: number, callback?: (error?: Error) => void) => Promise<import("node:http").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse> | undefined>;
+    staticServer: (dir: string, prefix?: string, isRegister?: boolean) => void;
+    /**启动 app*/
+    start: (cb?: () => void) => void;
+    close: () => void;
+}
+export declare const fairysMockerExpress: FairysMockerExpress;

package/esm/main.js

@@ -0,0 +1,38 @@
+import express from "express";
+import chalk from "chalk";
+import { fairysMockerBase } from "./base.js";
+import { detect } from "detect-port";
+class FairysMockerExpress {
+    base = fairysMockerBase;
+    createApp = (cb)=>fairysMockerBase.initApp(express(), cb);
+    detectPort = (port)=>{
+        const PORT = port || process.env.PORT || 6901;
+        return new Promise((resolve, reject)=>{
+            detect(PORT).then((realPort)=>{
+                resolve(realPort);
+            }).catch((err)=>{
+                reject(err);
+            });
+        });
+    };
+    listen = async (port, callback)=>{
+        if (!fairysMockerBase.app) return void console.log(chalk.red('请先初始化 app'));
+        const app = fairysMockerBase.mainApp;
+        const realPort = await this.detectPort(port);
+        fairysMockerBase.server = app.listen(realPort, (...rest)=>{
+            fairysMockerBase.logServer(realPort);
+            callback?.(...rest);
+        });
+        return fairysMockerBase.server;
+    };
+    staticServer = fairysMockerBase.staticServer;
+    start = (cb)=>{
+        this.createApp(cb);
+        this.listen();
+    };
+    close = ()=>{
+        if (fairysMockerBase.server) fairysMockerBase.server.close();
+    };
+}
+const fairysMockerExpress = new FairysMockerExpress();
+export { FairysMockerExpress, fairysMockerExpress };

package/esm/plugins/rsbuild.d.ts

@@ -0,0 +1,2 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+export declare const fairysMockerRsbuildPlugin: () => RsbuildPlugin;

package/esm/plugins/rsbuild.js

@@ -0,0 +1,12 @@
+import { fairysMockerBase } from "../base.js";
+const fairysMockerRsbuildPlugin = ()=>({
+        setup (api) {
+            api.onBeforeStartDevServer(({ server })=>{
+                fairysMockerBase.initApp(server.middlewares, ()=>{
+                    fairysMockerBase.logServer(server.port);
+                });
+                fairysMockerBase.server = server.httpServer;
+            });
+        }
+    });
+export { fairysMockerRsbuildPlugin };

package/esm/router/base.d.ts

@@ -0,0 +1,12 @@
+import express from 'express';
+export declare class BaseRouter<T> {
+    /**mock 路由器实例*/
+    router: express.Router | null;
+    /**服务是否启用*/
+    isEnabled: boolean;
+    /**加载*/
+    load: (data: T[]) => void;
+    /**销毁路由器实例*/
+    destroy: (msg?: string) => void;
+    useRouter(): void;
+}

package/esm/router/base.js

@@ -0,0 +1,23 @@
+import { fairysMockerBase } from "../base.js";
+import chalk from "chalk";
+class BaseRouter {
+    router = null;
+    isEnabled = false;
+    load = (data)=>{
+        this.destroy();
+    };
+    destroy = (msg)=>{
+        if (this.router) {
+            this.router.stack = [];
+            this.isEnabled = false;
+        }
+        if (msg) {
+            console.log(chalk.red(msg));
+            console.log('');
+        }
+    };
+    useRouter() {
+        if (this.router && fairysMockerBase.router) fairysMockerBase.router.use(this.router);
+    }
+}
+export { BaseRouter };

package/esm/router/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./base.js";
+export * from "./mock.js";
+export * from "./proxy.js";

package/esm/router/index.js

@@ -0,0 +1,3 @@
+export * from "./base.js";
+export * from "./mock.js";
+export * from "./proxy.js";

package/esm/router/mock.d.ts

@@ -0,0 +1,7 @@
+import { MockerItem } from "@fairys/create-mock-data";
+import { BaseRouter } from "./base.js";
+/**mock 路由器实例*/
+export declare class MockRouter extends BaseRouter<MockerItem> {
+    /**加载mock路由*/
+    load: (mockList: MockerItem[]) => void;
+}

package/esm/router/mock.js

@@ -0,0 +1,32 @@
+import express from "express";
+import { createMockItemData } from "@fairys/create-mock-data";
+import { BaseRouter } from "./base.js";
+import chalk from "chalk";
+class MockRouter extends BaseRouter {
+    load = (mockList)=>{
+        this.destroy();
+        const router = this.router = express.Router();
+        this.isEnabled = true;
+        for(let index = 0; index < mockList.length; index++){
+            const mockItem = mockList[index];
+            const method = mockItem.method.toLowerCase();
+            const handler = (req, res)=>{
+                console.log(chalk.cyan(`  🦄 mock请求:\t` + chalk.yellow(`${method}`) + "\t" + chalk.bold(`${mockItem.url}`)));
+                try {
+                    const mockData = createMockItemData(mockItem);
+                    res.status(Number(mockData.status) || 200).json(mockData.body);
+                } catch (error) {
+                    res.status(500).json({
+                        code: 500,
+                        message: '加载失败'
+                    });
+                }
+            };
+            console.log(chalk.green(`  🦄 mock加载:\t` + chalk.yellow(`${method}`) + "\t" + chalk.bold(`${mockItem.url}`)));
+            router[method](mockItem.url, handler);
+        }
+        console.log('');
+        this.useRouter();
+    };
+}
+export { MockRouter };