@domain.js/main 0.1.15 → 0.2.2

package/.eslintrc.js

@@ -8,6 +8,7 @@ module.exports = {
     node: true,
     commonjs: true,
     es6: true,
+    jest: true,
   },
   globals: {
     // Your global variables (setting to false means it's not allowed to be reassigned)

package/.husky/pre-commit

@@ -5,5 +5,4 @@ fi
 . "$(dirname "$0")/_/husky.sh"
 
 ts-node src/cli/index.ts loadDeps ./src/deps ts && npm run lint-staged && npm run build 
-npm run build
 npm tst

package/dist/http/defines.d.ts

@@ -1,20 +1,13 @@
+import { Opt as Sign } from "../deps/signer";
 export interface Cnf {
     proxyIps?: string;
     port?: number;
     host?: string;
     bodyMaxBytes?: number;
     apisRoute?: string;
+    socket?: boolean;
     [propName: string]: any;
 }
-interface Sign {
-    signature: string;
-    uri: string;
-    key: string;
-    timestamp: number;
-    signMethod: string;
-    signVersion: string;
-    method: string;
-}
 export interface Profile {
     clientIp: string;
     remoteIp: string;
@@ -22,12 +15,19 @@ export interface Profile {
     userAgent: string;
     startedAt: Date;
     requestId: string;
+    /** 用户类型，例如 user, worker */
+    type: string;
     /** 自由挂载信息的节点 */
     extra: Record<string, any>;
     revision?: string;
     uuid?: string;
     token?: string;
-    sign?: Sign;
+    sign?: Sign & {
+        signature: string;
+    };
+    isSocket?: boolean;
+    /** socket 的时候加入的房间 */
+    roomId?: string;
 }
 export interface HttpCodes {
     [propName: string]: number;
@@ -35,12 +35,9 @@ export interface HttpCodes {
 export interface Domain {
     [propName: string]: (profile: Profile, params: any) => any | Domain;
 }
-export interface GetSchemaByPath {
-    (methodPath: string): [any, any];
-}
+export declare type GetSchemaByPath = (methodPath: string) => [any, any];
 export interface Err {
     message: string;
     code?: number | string;
     data?: any;
 }
-export {};

package/dist/http/index.d.ts

@@ -1,8 +1,8 @@
 import * as restify from "restify";
+import { Cnf, Domain, GetSchemaByPath, HttpCodes, Profile } from "./defines";
 import { Router } from "./router";
-import { Cnf, Domain, Profile, HttpCodes, GetSchemaByPath } from "./defines";
 interface Deps {
-    routers(r: ReturnType<typeof Router>): void;
+    routers: (r: ReturnType<typeof Router>) => void;
     domain: Domain;
     httpCodes: HttpCodes;
     getSchemaByPath: GetSchemaByPath;

package/dist/http/index.js

@@ -21,7 +21,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Main = void 0;
 const restify = __importStar(require("restify"));
+const socket_io_1 = require("socket.io");
 const router_1 = require("./router");
+const socket_1 = require("./socket");
 const utils_1 = require("./utils");
 function Main(cnf, deps) {
     const utils = (0, utils_1.Utils)(cnf);
@@ -42,6 +44,11 @@ function Main(cnf, deps) {
         apisRoute: cnf.apisRoute,
     });
     routers(router);
+    // 根据需求起送socket服务
+    if (cnf.socket) {
+        const io = new socket_io_1.Server(server);
+        (0, socket_1.BridgeSocket)(io, domain);
+    }
     // Http server start
     return () => {
         server.listen(cnf.port || 8088, cnf.host || "127.0.0.1", () => {

package/dist/http/router.d.ts

@@ -1,13 +1,13 @@
 import * as restify from "restify";
+import { Domain, GetSchemaByPath, HttpCodes, Profile } from "./defines";
 import { Utils } from "./utils";
-import { HttpCodes, Domain, Profile, GetSchemaByPath } from "./defines";
 interface Deps {
     domain: Domain;
     getSchemaByPath: GetSchemaByPath;
     utils: ReturnType<typeof Utils>;
     server: restify.Server;
     httpCodes: HttpCodes;
-    makeProfileHook?(obj: Profile, req: restify.Request): any;
+    makeProfileHook?: (obj: Profile, req: restify.Request) => any;
     apisRoute?: string;
     swagger?: [any, any];
 }

package/dist/http/router.js

@@ -71,6 +71,7 @@ function Router(deps) {
             next();
         });
     }
+    // eslint-disable-next-line max-params
     function register(verb, route, methodPath, code = 200, isList = false, handler, resHandler) {
         /**
          * 暂存起来，提供给apis接口来用
@@ -93,7 +94,7 @@ function Router(deps) {
             try {
                 let results = await method(profile, params);
                 res.header("X-ConsumedTime", Date.now() - profile.startedAt.valueOf());
-                if (results == null)
+                if (results === null || results === undefined)
                     results = "Ok";
                 if (resHandler) {
                     resHandler(results, res);

package/dist/http/socket.d.ts

@@ -0,0 +1,15 @@
+import { Server, Socket } from "socket.io";
+import { DefaultEventsMap } from "socket.io/dist/typed-events";
+import { Opt as Sign } from "../deps/signer";
+import { Domain, Profile } from "./defines";
+declare type Signature = Sign & {
+    signature: string;
+};
+export declare type Client = Socket<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any> & {
+    profile?: ReturnType<typeof makeProfile>;
+    inited?: boolean;
+    roomId?: string;
+};
+declare const makeProfile: (client: Client, type: string | undefined, auth: string | Signature, extra?: Profile["extra"]) => Profile;
+export declare function BridgeSocket(io: Server, domain: Domain): void;
+export {};

package/dist/http/socket.js

@@ -0,0 +1,178 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BridgeSocket = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const proxyIps = new Set(["127.0.0.1"]);
+class MyError extends Error {
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+    }
+}
+const utils = {
+    /** 真实的连接请求端ip */
+    remoteIp(client) {
+        return client.handshake.address;
+    },
+    /**
+     * 获取客户端真实ip地址
+     */
+    clientIp(client) {
+        const { headers } = client.handshake;
+        const clientIp = headers["x-forwarded-for"] || headers["x-real-ip"] || utils.remoteIp(client);
+        if (Array.isArray(clientIp))
+            return clientIp[0];
+        return clientIp.split(",")[0];
+    },
+    /**
+     * 获取可信任的真实ip
+     */
+    realIp(client) {
+        const remoteIp = utils.remoteIp(client);
+        if (!proxyIps.has(remoteIp))
+            return remoteIp;
+        const realIp = client.handshake.headers["x-real-ip"] || remoteIp;
+        if (Array.isArray(realIp))
+            return realIp[0];
+        return realIp.split(",")[0];
+    },
+};
+const makeProfile = (client, type = "user", auth, extra = {}) => {
+    const obj = {
+        clientIp: utils.clientIp(client),
+        remoteIp: utils.remoteIp(client),
+        realIp: utils.realIp(client),
+        isSocket: true,
+        startedAt: new Date(),
+        userAgent: client.handshake.headers["user-agent"] || "Not captured",
+        requestId: client.id,
+        type,
+        extra,
+    };
+    if (extra) {
+        /** 客户端发布号 */
+        if (extra.revision)
+            obj.revision = extra.revision;
+        /** 用户uuid 可以长期跨app */
+        if (extra.uuid)
+            obj.uuid = extra.uuid;
+    }
+    if (typeof auth === "string") {
+        obj.token = auth;
+    }
+    else {
+        obj.sign = auth;
+        obj.sign.uri = "/socket.io";
+        obj.sign.method = "socket.init";
+    }
+    return obj;
+};
+function BridgeSocket(io, domain) {
+    const subscribe = lodash_1.default.get(domain, "message.subscribe");
+    const unsubscribe = lodash_1.default.get(domain, "message.unsubscribe");
+    const entrance = lodash_1.default.get(domain, "message.entrance");
+    if (!subscribe)
+        throw Error("要启用 socket 服务，必须要要有 message.subscribe 方法，用来处理 socket 订阅");
+    if (!unsubscribe)
+        throw Error("要启用 socket 服务，必须要要有 message.unsubscribe 方法，用来处理 socket 退订");
+    if (!entrance)
+        throw Error("要启用 socket 服务，必须要要有 message.entrance 方法，用来处理 加入某个房间");
+    io.on("connection", (client) => {
+        // 定义toJSON 避免 schema 验证报错
+        Object.assign(client, {
+            toJSON() {
+                return {};
+            },
+        });
+        console.log("[%s] connection: client.id: %s", new Date(), client.id);
+        client.on("init", async (type, auth, extra = {}) => {
+            console.log("[%s] socket.init: client.id: %s", new Date(), client.id);
+            if (!auth) {
+                client.emit("initError", "auth info lost");
+                return;
+            }
+            try {
+                Object.assign(client, { profile: makeProfile(client, type, auth, extra) });
+                if (!client.profile)
+                    throw new MyError("noAuth", "请先登录");
+                // 创建消息监听函数
+                if (!client.inited)
+                    client.inited = true;
+                // 向领域注册改用户的监听函数
+                const session = await subscribe(client.profile, client);
+                client.emit("inited", session);
+            }
+            catch (e) {
+                client.inited = false;
+                if (e instanceof MyError) {
+                    client.emit("internalError", e.message, e.code || "unknown");
+                    return;
+                }
+                console.error(e);
+            }
+        });
+        client.on("entrance", async (roomId) => {
+            try {
+                if (!client.profile || !client.inited)
+                    return;
+                const res = await entrance({ roomId, ...client.profile }, client);
+                client.profile.roomId = roomId;
+                client.roomId = roomId;
+                client.emit("entranced", res);
+            }
+            catch (e) {
+                client.roomId = undefined;
+                if (client.profile)
+                    client.profile.roomId = undefined;
+                if (e instanceof MyError) {
+                    client.emit("internalError", e.message, e.code || "unknown");
+                    return;
+                }
+                console.error(e);
+            }
+        });
+        client.use(async ([name, params, responseId], next) => {
+            if (name === "init" || name === "entrance")
+                return next();
+            const method = domain[name];
+            try {
+                if (!method)
+                    throw new MyError("notFound", "不存在该领域方法");
+                if (!client.profile)
+                    throw new MyError("noAuth", "请先执行 init");
+                const res = await method(client.profile, params);
+                if (responseId) {
+                    client.emit("response", responseId, res);
+                }
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    if (responseId) {
+                        client.emit("responseError", responseId, e.code, e.message, e.data);
+                    }
+                    else {
+                        client.emit(`${name}Error`, e.code, e.message, e.data);
+                    }
+                }
+                else {
+                    console.error(e);
+                }
+            }
+            return next();
+        });
+        // 掉线
+        client.on("disconnect", () => {
+            if (!client.profile)
+                return;
+            if (!client.inited)
+                return;
+            // 这里要取消对领域消息的监听
+            unsubscribe(client.profile, client);
+        });
+    });
+}
+exports.BridgeSocket = BridgeSocket;

package/dist/http/utils.d.ts

@@ -15,7 +15,7 @@ export declare function Utils(cnf: Cnf): {
     /**
      * 构造profile参数
      */
-    makeProfile(req: restify.Request, method: string, customFn?: Function | undefined): Readonly<Profile>;
+    makeProfile<T extends {} = {}>(req: restify.Request, method: string, customFn?: ((obj: Profile, req: restify.Request) => T) | undefined): Profile & T;
     /**
      * 构造领域方法所需的 params 参数
      */

package/dist/http/utils.js

@@ -18,14 +18,17 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Utils = void 0;
-const os = __importStar(require("os"));
-const fs = __importStar(require("fs"));
 const crypto = __importStar(require("crypto"));
-const _ = __importStar(require("lodash"));
-const xlsx = __importStar(require("xlsx"));
 const csv_stringify_1 = require("csv-stringify");
+const fs = __importStar(require("fs"));
+const lodash_1 = __importDefault(require("lodash"));
+const os = __importStar(require("os"));
+const xlsx = __importStar(require("xlsx"));
 const str2arr = ["_includes", "dimensions", "metrics", "_attrs"];
 const enc = encodeURI;
 const TMPDIR = os.tmpdir();
@@ -68,8 +71,12 @@ function Utils(cnf) {
                 userAgent: req.userAgent(),
                 startedAt: new Date(),
                 requestId: req.id(),
+                type: "user",
                 extra: {},
             };
+            if (req.headers["x-auth-user-type"]) {
+                obj.type = req.headers["x-auth-user-type"].toString();
+            }
             const token = req.headers["x-auth-token"] || req.query.access_token || req.query.accessToken;
             // token 和签名认证只能二选一
             if (token) {
@@ -103,7 +110,7 @@ function Utils(cnf) {
          */
         makeParams(req) {
             let params = { ...req.params, ...req.query };
-            if (_.isObject(req.body) && !Array.isArray(req.body)) {
+            if (lodash_1.default.isObject(req.body) && !Array.isArray(req.body)) {
                 params = { ...req.body, ...params };
             }
             else if (req.body) {
@@ -111,10 +118,10 @@ function Utils(cnf) {
             }
             // 逗号分隔的属性，自动转换为 array
             for (const k of str2arr) {
-                if (params[k] && _.isString(params[k]))
+                if (params[k] && lodash_1.default.isString(params[k]))
                     params[k] = params[k].split(",");
             }
-            if (_.size(req.files))
+            if (lodash_1.default.size(req.files))
                 params.__files = req.files;
             return params;
         },
@@ -124,9 +131,9 @@ function Utils(cnf) {
          */
         async outputCSV(rows, params, res, isXLSX = false) {
             const { _names, _cols, _filename } = params;
-            if (!_.isString(_cols))
+            if (!lodash_1.default.isString(_cols))
                 return false;
-            if (_names && !_.isString(_names))
+            if (_names && !lodash_1.default.isString(_names))
                 return false;
             const keys = _cols.split(",");
             const titles = (_names || _cols).split(",");
@@ -156,7 +163,7 @@ function Utils(cnf) {
                 await new Promise((resolve) => {
                     const stream = (0, csv_stringify_1.stringify)(rows, {
                         header: true,
-                        columns: _.zipObject(keys, titles),
+                        columns: lodash_1.default.zipObject(keys, titles),
                     });
                     stream.pipe(res);
                     stream.on("end", resolve);

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 import { Defaults } from "./defaults";
 import Deps = require("./deps/defines");
-export { Main as Http } from "./http";
-export { Errors } from "./Errors";
+export { Main as Cfg } from "./cfg";
 export * as DM from "./dm";
+export { Errors } from "./Errors";
+export { Main as Http } from "./http";
 export * as utils from "./utils";
-export { Main as Cfg } from "./cfg";
 export declare const basicErrors: Readonly<Record<"notFound" | "notAllowed" | "noAuth", import("./Errors").ErrorFn>>;
 declare type TDeps = typeof Deps;
 declare type Merge<T> = {

package/dist/index.js

@@ -19,18 +19,18 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Main = exports.basicErrors = exports.Cfg = exports.utils = exports.DM = exports.Errors = exports.Http = void 0;
+exports.Main = exports.basicErrors = exports.utils = exports.Http = exports.Errors = exports.DM = exports.Cfg = void 0;
 const defaults_1 = require("./defaults");
 const DM = __importStar(require("./dm"));
 const Deps = require("./deps/defines");
-var http_1 = require("./http");
-Object.defineProperty(exports, "Http", { enumerable: true, get: function () { return http_1.Main; } });
+var cfg_1 = require("./cfg");
+Object.defineProperty(exports, "Cfg", { enumerable: true, get: function () { return cfg_1.Main; } });
+exports.DM = __importStar(require("./dm"));
 var Errors_1 = require("./Errors");
 Object.defineProperty(exports, "Errors", { enumerable: true, get: function () { return Errors_1.Errors; } });
-exports.DM = __importStar(require("./dm"));
+var http_1 = require("./http");
+Object.defineProperty(exports, "Http", { enumerable: true, get: function () { return http_1.Main; } });
 exports.utils = __importStar(require("./utils"));
-var cfg_1 = require("./cfg");
-Object.defineProperty(exports, "Cfg", { enumerable: true, get: function () { return cfg_1.Main; } });
 exports.basicErrors = defaults_1.defaults.errors;
 function Main(features) {
     const { _ } = defaults_1.defaults;

package/dist/utils/index.d.ts

@@ -75,4 +75,10 @@ declare type Params = {
  * @returns Modified address
  */
 export declare const modifiyURL: (address: string, adds?: Params | undefined, removes?: string[] | undefined) => string;
+/**
+ * 等待，知道 test 返回 true
+ * @param test 检测函数
+ * @param intervalMS 间隔多久判断一次, 单位毫秒 默认 100
+ */
+export declare const waitFor: (test: () => boolean, intervalMS?: number) => Promise<void>;
 export {};

package/dist/utils/index.js

@@ -18,8 +18,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.modifiyURL = exports.inExpired = exports.tryCatchLog = exports.deepFreeze = exports.sleep = exports.lcfirst = exports.ucfirst = exports.nt2space = exports.randStr = exports.md5 = void 0;
+exports.waitFor = exports.modifiyURL = exports.inExpired = exports.tryCatchLog = exports.deepFreeze = exports.sleep = exports.lcfirst = exports.ucfirst = exports.nt2space = exports.randStr = exports.md5 = void 0;
+const async_1 = __importDefault(require("async"));
 const crypto = __importStar(require("crypto"));
 /** 随机字符串字典 */
 const RAND_STR_DICT = {
@@ -147,3 +151,14 @@ const modifiyURL = (address, adds, removes) => {
     return obj.toString();
 };
 exports.modifiyURL = modifiyURL;
+/**
+ * 等待，知道 test 返回 true
+ * @param test 检测函数
+ * @param intervalMS 间隔多久判断一次, 单位毫秒 默认 100
+ */
+const waitFor = async (test, intervalMS = 100) => {
+    await async_1.default.doUntil(async () => {
+        await (0, exports.sleep)(intervalMS);
+    }, async () => test());
+};
+exports.waitFor = waitFor;

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "@domain.js/main",
-  "version": "0.1.15",
+  "version": "0.2.2",
   "description": "DDD framework",
   "main": "dist/index.js",
   "bin": {
     "domain-cli": "dist/cli/index.js"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "rm -rf ./dist/* && tsc",
     "test": "export NODE_ENV=test && jest ./src --coverage",
     "test:watch": "export NODE_ENV=test && jest ./src --watch",
     "prepare": "husky install",
     "lint-staged": "lint-staged",
     "lint-staged:js": "eslint --ext .js,.ts",
-    "loadDeps": "ts-node src/cli/index.ts loadDeps ./ ts"
+    "loadDeps": "ts-node src/cli/index.ts loadDeps ./src/deps ts"
   },
   "author": "Redstone Zhao",
   "license": "MIT",
@@ -78,6 +78,7 @@
     "restify": "^8.6.0",
     "restify-errors": "^8.0.2",
     "sequelize": "6.16.1",
+    "socket.io": "^4.4.1",
     "type-fest": "^2.8.0",
     "uuid": "^8.3.2",
     "xlsx": "^0.17.4"

package/dist/cli/schema2ts.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/cli/schema2ts.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const path = require("path");
-const fs = require("fs");
-const json_schema_to_typescript_1 = require("json-schema-to-typescript");
-const _require = require;
-async function main(file, single = false, name = "Params") {
-    const stats = fs.statSync(file);
-    if (stats.isFile()) {
-        const arr = file.split(".");
-        if (arr.pop() !== "js")
-            return;
-        const obj = _require(file);
-        if (!single) {
-            if (!Array.isArray(obj))
-                return;
-            if (typeof obj[1] !== "object")
-                return;
-        }
-        try {
-            const ts = await (0, json_schema_to_typescript_1.compile)(single ? obj : obj[1], name);
-            arr.push("d.ts");
-            fs.writeFileSync(arr.join("."), ts);
-        }
-        catch (e) {
-            console.error(file, e);
-        }
-        return;
-    }
-    const files = fs.readdirSync(file);
-    for await (const x of files) {
-        if (x === "." || x === "..")
-            continue;
-        await main(path.resolve(file, x), single, name);
-    }
-}
-main(process.argv[2], process.argv[3] === "single", process.argv[4]);

package/dist/deps/cia/errors.d.ts

@@ -1,6 +0,0 @@
-declare const _default: () => {
-    [key: string]: (...args: any[]) => Error & {
-        code?: string | undefined;
-    };
-};
-export default _default;

package/dist/deps/cia/errors.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const util = require("util");
-exports.default = () => {
-    const defines = [
-        ["duplicatRegistMessage", "The message has been registed: %s"],
-        ["registWhenReadyAfter", "The message dont registed when mcenter be ready after: %s"],
-        [
-            "submitUnregistedMessage",
-            "The message has not been registed: %s, data: %o, when will submit",
-        ],
-        ["linkUnregistedMessage", "The message has not been registed: %s, when will link"],
-        [
-            "linkUnknowTypes",
-            "The message link type unknown, message name is: %s, type is: %s, when will link",
-        ],
-        [
-            "linkDuplicateType",
-            "The message link type duplicate, message name is: %s, type is: %s, when will link",
-        ],
-        [
-            "linkListernerMustBeFunctionType",
-            "The message link waiter must be a function, message name is: %s, type is: %s, when will link",
-        ],
-        ["setFnNotAllowed", "Set function but unknown type: %s"],
-    ];
-    const fns = {};
-    for (const [code, message] of defines) {
-        fns[code] = (...args) => {
-            const error = Error(util.format(message, ...args));
-            error.code = code;
-            return error;
-        };
-    }
-    return fns;
-};

package/dist/deps/cia/index.d.ts

@@ -1,63 +0,0 @@
-import * as _ from "lodash";
-import * as async from "async";
-import { v4 } from "uuid";
-interface Cnf {
-    cia?: {
-        concurrency?: number;
-        storeKey?: string;
-    };
-}
-interface Deps {
-    _: Pick<typeof _, "pick" | "map" | "isFunction">;
-    async: Pick<typeof async, "eachSeries" | "queue">;
-    uuid: {
-        v4: typeof v4;
-    };
-    logger: {
-        info: (...args: any[]) => void;
-        error: (...args: any[]) => void;
-    };
-    redis: {
-        hset: Function;
-        hdel: Function;
-        hgetall: Function;
-    };
-    graceful: {
-        exit: (fn: () => Promise<void>) => void;
-    };
-    U: {
-        tryCatchLog<Fn extends (...args: any[]) => any>(fn: Fn, errorFn: (...args: any[]) => any): Fn;
-    };
-}
-export interface Stats {
-    pendings: number;
-    doings: number;
-    errors: number;
-    dones: number;
-}
-declare type Type = {
-    type: string;
-    timeout?: number;
-    validator?: Function;
-};
-export declare function Main(cnf: Cnf, deps: Deps): {
-    isExiting: () => boolean;
-    isExited: () => boolean;
-    checkReady: () => boolean;
-    getStats: () => {
-        [name: string]: Stats & {
-            _types: ({
-                type: string;
-            } & Stats)[];
-        };
-    };
-    getUnlinks: () => string[];
-    regist: (name: string, validator: Function | undefined, types: Type[]) => number;
-    link: (name: string, type: string, waiter: Function) => void;
-    submit: (name: string, data: any, callback?: Function | undefined) => void;
-    setFn: (type: "error" | "timeout", fn: (...args: any[]) => any) => void;
-    domainPaths: Set<string>;
-    modelHooks: Set<string>;
-};
-export declare const Deps: string[];
-export {};

package/dist/deps/cia/index.js

@@ -1,308 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Deps = exports.Main = void 0;
-const errors_1 = require("./errors");
-function Main(cnf, deps) {
-    const { _, async, uuid: { v4: uuid }, logger, redis, graceful, U: { tryCatchLog }, } = deps;
-    const { cia } = cnf;
-    const concurrency = Math.max(1, ((cia && cia.concurrency) || 10) | 0);
-    const storeKey = (cia && cia.storeKey) || "cia-store";
-    const errors = (0, errors_1.default)();
-    let doingCount = 0; // 正在执行的消息数量
-    let exited = false; // 是否已经完成退出
-    let exiting = false; // 是否正在退出
-    let readyToExitFn; // 完成退出前准备后执行函数
-    let unlinkdCount = 0; // 未被订阅的数量, 基于 {name}::{type} 判断
-    let isReady = false; // 系统是否已准备妥当
-    const registeds = {};
-    // 默认通知函数
-    const fns = {
-        error: logger.error,
-        timeout: logger.info,
-    };
-    // 记录监听回调函数
-    // { [${name}::${type}]: { [type]: fn } }
-    const waiters = new Map();
-    // 更新等待数量
-    const updatePendings = (registed) => {
-        const { result = {}, types } = registed;
-        const withouts = new Set(Object.keys(result));
-        registed.pendings += 1;
-        types.forEach((x) => {
-            if (!withouts.has(x.type))
-                x.pendings += 1;
-        });
-    };
-    // 更新 doings 统计信息
-    const updateDoings = (item) => {
-        item.pendings -= 1;
-        item.doings += 1;
-    };
-    // 更新 errors 统计信息
-    const updateErrors = (item) => {
-        item.doings -= 1;
-        item.errors += 1;
-    };
-    // 更新 dones 统计信息
-    const updateDones = (item) => {
-        item.doings -= 1;
-        item.dones += 1;
-    };
-    // 消息分发函数，分发到对应的订阅函数上
-    const dispatch = async (item) => {
-        const { id, name, data, result = {}, callback } = item;
-        const registed = registeds[name];
-        const { types } = registed;
-        const withouts = new Set(Object.keys(result));
-        updateDoings(registed);
-        doingCount += 1;
-        let errorCount = 0;
-        await async.eachSeries(types, async (_type) => {
-            const { type, timeout, validator } = _type;
-            // 看看是否有设置要忽略掉某些订阅者
-            // 这个功能主要是留给应用无故中断后系统自动恢复的任务执行
-            if (withouts && withouts.has(type))
-                return;
-            if (exiting)
-                return;
-            const fn = waiters.get(`${name}::${type}`);
-            const startAt = Date.now();
-            let err = null;
-            let ret = null;
-            try {
-                updateDoings(_type);
-                ret = await fn(data);
-                if (validator)
-                    validator(ret);
-                updateDones(_type);
-            }
-            catch (e) {
-                updateErrors(_type);
-                fns.error(e, id, name, type, data);
-                errorCount += 1;
-                err = e;
-            }
-            const consumedMS = Date.now() - startAt;
-            if (timeout && timeout < consumedMS)
-                fns.timeout(consumedMS, id, name, type);
-            result[type] = [err, ret, consumedMS];
-            // 记录执行结果
-            logger.info(`cia.dispatch\t${id}\t${type}`, result[type]);
-        });
-        doingCount -= 1;
-        if (errorCount) {
-            updateErrors(registed);
-        }
-        else {
-            updateDones(registed);
-        }
-        // submit 设置了callback 要记得执行回调函数
-        if (callback)
-            callback(result);
-        // 正在退出，且完成的不等于总共的，则需要储存, 以备下次启动后执行
-        if (exiting) {
-            if (Object.keys(result).length !== types.length) {
-                item.result = result;
-                // 存储以备下次启动恢复执行
-                await redis.hset(storeKey, item.id, JSON.stringify(item));
-            }
-            // 全部处理完毕后，执行退出
-            if (!doingCount) {
-                exited = true;
-                exiting = false;
-                readyToExitFn();
-            }
-        }
-    };
-    const statsFields = Object.freeze(["pendings", "doings", "dones", "errors"]);
-    // 获取统计信息
-    const getStats = () => {
-        const stats = {};
-        for (const name of Object.keys(registeds)) {
-            const { types } = registeds[name];
-            stats[name] = {
-                ..._.pick(registeds[name], statsFields),
-                _types: types.map((x) => _.pick(x, "type", ...statsFields)),
-            };
-        }
-        return stats;
-    };
-    // 内部消息队列, 初始化后立即暂定，等待 regist, link 都准备好了在开始执行
-    // 这样就不会有未成功订阅函数执行遗漏的问题了
-    // 例如: A 函数要监听 1 好消息的 save 类型，结果在完成订阅前，已经有某个区域 submit 了 1 号事件
-    //       如果队列一开始不暂停就会出现A函数遗漏执行
-    const queue = async.queue(dispatch, concurrency);
-    queue.pause();
-    graceful.exit(async () => {
-        exiting = true;
-        await new Promise((resolve) => {
-            // 如果队列已经清空，且没有正在执行的消息，则直接退出
-            if (!queue.length() && !doingCount) {
-                exited = true;
-                exiting = false;
-                resolve();
-            }
-            else {
-                readyToExitFn = resolve;
-            }
-        });
-    });
-    // 恢复上次残留的消息订阅执行
-    const recover = async () => {
-        const items = await redis.hgetall(storeKey);
-        if (!items)
-            return;
-        for await (const id of Object.keys(items)) {
-            const item = items[id];
-            const ok = await redis.hdel(storeKey, id);
-            if (ok !== 1)
-                continue;
-            try {
-                const data = JSON.parse(item);
-                const { name } = data;
-                queue.push(data);
-                updatePendings(registeds[name]);
-                logger.info("cia-recover: %s", item);
-            }
-            catch (e) {
-                logger.error(e);
-            }
-        }
-    };
-    // regist 消息注册，提前注册好需要submit和link的消息
-    // 这么做的目的是可以随时检测是否所有的消息都消费者，消费者类型是否正确
-    // 同时在submit的时候也可以检测发送的数据是否符合规定的格式
-    // name: String 消息名称
-    // validator?: Function 消息体数据格式验证函数
-    // types: [{
-    //    type: 'updateUser', // 类型名称
-    //    timeout?: 100, // 执行超时限定, 单位毫秒，可选 默认为 0, 不限制
-    //    validator?: fn, // 返回值格式验证函数, 可选
-    // }]
-    const regist = (name, validator, types) => {
-        if (isReady)
-            throw errors.registWhenReadyAfter(name);
-        if (registeds[name])
-            throw errors.duplicatRegistMessage(name);
-        const typeNames = new Set(_.map(types, "type"));
-        types.forEach((x) => {
-            Object.assign(x, { pendings: 0, dones: 0, doings: 0, errors: 0 });
-        });
-        const item = {
-            validator,
-            types: types,
-            typeNames,
-            pendings: 0,
-            dones: 0,
-            doings: 0,
-            errors: 0,
-        };
-        unlinkdCount += typeNames.size;
-        registeds[name] = item;
-        return Object.keys(registeds).length;
-    };
-    // start 启动系统执行, 这之前一定要regist 和 link 都准备好
-    const start = async () => {
-        queue.resume();
-        await recover();
-    };
-    // check 消息注册、监听检测
-    // 检查是否存在注册了的消息，但没有人监听消费
-    const checkReady = () => {
-        if (unlinkdCount !== 0)
-            return false;
-        if (!isReady) {
-            isReady = true;
-            start();
-        }
-        return true;
-    };
-    // link 消息订阅
-    const link = (name, type, waiter) => {
-        if (!registeds[name])
-            throw errors.linkUnregistedMessage(name);
-        const { typeNames } = registeds[name];
-        if (!typeNames.has(type))
-            throw errors.linkUnknowTypes(name, type);
-        if (!_.isFunction(waiter))
-            throw errors.linkListernerMustBeFunctionType(name, type);
-        const key = `${name}::${type}`;
-        if (waiters.get(key))
-            throw errors.linkDuplicateType(name, type);
-        waiters.set(key, waiter);
-        unlinkdCount -= 1;
-        checkReady();
-    };
-    // submit 消息发布
-    // name string 消息名称
-    // data any 消息数据
-    // callback function 消息执行完毕回调
-    const submit = (name, data, callback) => {
-        if (!registeds[name]) {
-            // 这里记录error就可以了。throw没有意义，因为submit是异步的
-            // throw error并没有被捕获，还会导致调用方的后续代码不执行
-            logger.error(errors.submitUnregistedMessage(name, data));
-            return;
-        }
-        if (callback && !_.isFunction(callback))
-            callback = undefined;
-        const { validator } = registeds[name];
-        if (validator)
-            validator(data);
-        const id = uuid();
-        queue.push({ id, name, data, callback });
-        updatePendings(registeds[name]);
-        logger.info(`cia.submit\t${id}`, { name, data });
-    };
-    // 设置通知函数，错误通知，超时通知
-    // 在消息分发执行的时候遇到错误会调用错误通知函数
-    // 在消息分发执行的时候遇到超时会调用超时通知函数
-    // type string 类型，error or timeout
-    // fn function 通知函数
-    const setFn = (type, fn) => {
-        if (!fns[type])
-            throw errors.setFnNotAllowed(type);
-        // 这里之所以会用 tryCatchLog 封装函数，是不想让这些函数的执行影响主流程
-        // 这些函数内部抛出的异常不会导致主流程执行中断
-        fns[type] = tryCatchLog(fn, logger.error);
-    };
-    // 获取未被连接的任务消息
-    const getUnlinks = () => {
-        const losts = [];
-        for (const name of Object.keys(registeds)) {
-            for (const { type } of registeds[name].types) {
-                const key = `${name}::${type}`;
-                if (!waiters.has(key))
-                    losts.push(key);
-            }
-        }
-        return losts;
-    };
-    // 进程是否正在退出
-    const isExiting = () => Boolean(exiting);
-    // 进程是否已经退出
-    const isExited = () => Boolean(exited);
-    /**
-     * 领域方法注册到 cia 上的路径集合
-     */
-    const domainPaths = new Set();
-    /**
-     * Model hook 注册到 cia 上的路径集合
-     */
-    const modelHooks = new Set();
-    return {
-        isExiting,
-        isExited,
-        checkReady,
-        getStats,
-        getUnlinks,
-        regist,
-        link,
-        submit,
-        setFn,
-        domainPaths,
-        modelHooks,
-    };
-}
-exports.Main = Main;
-exports.Deps = ["_", "async", "logger", "utils", "redis", "graceful", "uuid"];

package/dist/deps/rest/defines.d.ts

@@ -1,5 +0,0 @@
-import { ModelBase } from "../sequelize";
-export interface Params {
-    [propName: string]: any;
-}
-export declare type TModel = typeof ModelBase;

package/dist/deps/rest/defines.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/deps/typeorm/index.d.ts

@@ -1,14 +0,0 @@
-import * as TypeORM from "typeorm";
-interface Cnf {
-    typeorm: {
-        [propName: string]: Parameters<typeof TypeORM.createConnection>[0];
-    };
-}
-interface Deps {
-    TypeORM: typeof TypeORM;
-}
-export declare function Main(cnf: Cnf, deps: Deps): Promise<{
-    [propName: string]: TypeORM.Connection;
-}>;
-export declare const Deps: string[];
-export {};

package/dist/deps/typeorm/index.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Deps = exports.Main = void 0;
-async function Main(cnf, deps) {
-    // 这里之所以要注入 Sequelize 是为了保证项目自身可以灵活选择自己的 Sequelize 版本, 这样改公共模块就会更加稳定, 避免频繁升级
-    const { typeorm: dbs } = cnf;
-    const { TypeORM } = deps;
-    const links = {};
-    for await (const k of Object.keys(dbs)) {
-        const db = dbs[k];
-        links[k] = await TypeORM.createConnection(db);
-    }
-    return links;
-}
-exports.Main = Main;
-exports.Deps = ["TypeORM"];