@fairys/mocker-cli 0.0.1

package/esm/controller/mock.router.js

@@ -0,0 +1,497 @@
+import node_fs from "node:fs";
+import { Controller, Get, Post } from "../utils/decorator.js";
+import { utils } from "../utils/index.js";
+import { MockRouter } from "../router/mock.js";
+import { BaseController } from "./base.js";
+import { createMockFile, getMcokFile } 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('/_mock'), _dec2 = Get('/_mock'), _dec3 = Get('/_mock/_is_enabled'), _dec4 = Get('/_mock/_start'), _dec5 = Get('/_mock/_destroy');
+let _MockRouterController;
+class MockRouterController extends (_BaseController = BaseController) {
+    static{
+        ({ e: [_initProto], c: [_MockRouterController, _initClass] } = _apply_decs_2203_r(this, [
+            [
+                _dec1,
+                2,
+                "post_mock"
+            ],
+            [
+                _dec2,
+                2,
+                "get_mock"
+            ],
+            [
+                _dec3,
+                2,
+                "get_mock_enabled"
+            ],
+            [
+                _dec4,
+                2,
+                "get_mock_start"
+            ],
+            [
+                _dec5,
+                2,
+                "get_mock_destroy"
+            ]
+        ], [
+            _dec
+        ], _BaseController));
+    }
+    constructor(){
+        super();
+        this.router = new MockRouter();
+    }
+    router = (_initProto(this), null);
+    post_mock(req, res) {
+        try {
+            const { mockList, dir, fileName = 'index.mock', rootDir } = req.body;
+            let _rootDir = rootDir || utils.rootDir;
+            if (rootDir && !node_fs.existsSync(rootDir)) _rootDir = utils.rootDir;
+            const mockData = createMockFile(mockList, _rootDir, dir, fileName);
+            if (mockData?.mockConfig) {
+                if (this.router?.isEnabled) this.router?.load(mockData.mockConfig);
+                res.json({
+                    code: 200,
+                    message: 'Mock 配置保存成功',
+                    data: mockData.mockConfig,
+                    mockList: mockList,
+                    rootDir: mockData.rootDir,
+                    dir: mockData.dir,
+                    cache: mockData.cache,
+                    fileName: mockData.fileName
+                });
+            }
+        } catch (error) {
+            res.status(500).json({
+                code: 500,
+                message: '保存 Mock 配置失败',
+                error: error.message
+            });
+        }
+    }
+    get_mock(req, res) {
+        try {
+            const savePath = req.query?.dir?.trim();
+            const saveFileName = req.query?.fileName?.trim();
+            const rootDir = req.query?.rootDir?.trim();
+            const mockData = getMcokFile(rootDir, savePath, saveFileName);
+            if (mockData?.mockList) res.json({
+                code: 200,
+                message: '读取 Mock 配置成功',
+                data: mockData.mockList,
+                rootDir: mockData.rootDir,
+                dir: mockData.dir,
+                cache: mockData.cache,
+                fileName: mockData.fileName
+            });
+            else res.json({
+                code: 404,
+                message: 'Mock 配置文件不存在'
+            });
+        } catch (error) {
+            res.status(500).json({
+                code: 500,
+                message: '读取 Mock 配置失败',
+                error: error.message
+            });
+        }
+    }
+    get_mock_enabled(req, res) {
+        res.json({
+            code: 200,
+            message: 'Mock 配置服务是否启用',
+            data: this.router?.isEnabled
+        });
+    }
+    get_mock_start(req, res) {
+        try {
+            const mockData = getMcokFile(req.query.rootDir, req.query.dir, req.query.fileName);
+            if (mockData?.mockList) {
+                this.router?.load(mockData.mockList);
+                res.json({
+                    code: 200,
+                    message: '启动 Mock 配置服务成功',
+                    data: mockData.mockList,
+                    rootDir: mockData.rootDir,
+                    dir: mockData.dir,
+                    cache: mockData.cache,
+                    fileName: mockData.fileName,
+                    isEnabled: true
+                });
+            } else res.json({
+                code: 404,
+                message: 'Mock 配置文件不存在'
+            });
+        } catch (error) {
+            res.status(500).json({
+                code: 500,
+                message: '启动 Mock 配置失败',
+                error: error.message
+            });
+        }
+    }
+    get_mock_destroy(req, res) {
+        try {
+            if (this.router?.router) this.router?.destroy("销毁mock路由器实例");
+            else res.json({
+                code: 404,
+                message: 'Mock 配置服务不存在'
+            });
+            res.json({
+                code: 200,
+                message: '销毁 Mock 配置服务成功'
+            });
+        } catch (error) {
+            res.status(500).json({
+                code: 500,
+                message: '销毁 Mock 配置服务',
+                error: error.message
+            });
+        }
+    }
+    start = (rootDir, dir, fileName)=>{
+        try {
+            const mockData = getMcokFile(rootDir, dir, fileName);
+            if (mockData?.mockList) try {
+                this.router?.load(mockData.mockList);
+                console.log(chalk.green(`  启动 Mock 配置服务成功，配置文件：${mockData.rootDir}/${mockData.dir}/${mockData.fileName}.ts`));
+                console.log('');
+            } catch (error) {
+                console.log(chalk.red(`  启动 Mock 配置服务失败，配置文件：${mockData.rootDir}/${mockData.dir}/${mockData.fileName}.ts`));
+                console.log('');
+            }
+        } catch (error) {
+            console.log(chalk.red("  启动 Mock 配置服务失败"));
+            console.log('');
+        }
+    };
+    static{
+        _initClass();
+    }
+}
+export { _MockRouterController as MockRouterController };

package/esm/controller/proxy.router.d.ts

@@ -0,0 +1,18 @@
+import express from 'express';
+import { ProxyRouter } from '../router/proxy.js';
+import { BaseController } from './base.js';
+/**路由*/
+export declare class ProxyRouterController extends BaseController {
+    /**代理 路由器实例*/
+    router: ProxyRouter | null;
+    constructor();
+    post_proxy(req: express.Request, res: express.Response): void;
+    get_proxy(req: express.Request, res: express.Response): void;
+    /**检查代理服务是否启用*/
+    get_proxy_enabled(req: express.Request, res: express.Response): void;
+    /**启动代理服务*/
+    get_proxy_start(req: express.Request, res: express.Response): void;
+    /**销毁代理服务*/
+    get_proxy_destroy(req: express.Request, res: express.Response): void;
+    start: (rootDir?: string, dir?: string, fileName?: string) => void;
+}