@domain.js/main 0.1.14 → 0.2.1

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/deps/rest/index.d.ts

@@ -1,6 +1,6 @@
 import _ from "lodash";
 import * as Sequelize from "sequelize";
-import { TModel, Params } from "./defines";
+import { ModelBase, ModelStatic } from "../sequelize";
 import { Stats } from "./stats";
 import { Utils } from "./utils";
 export { Before } from "./Before";
@@ -24,14 +24,14 @@ export interface CreatorAndClientIp {
  * @returns modify, add, remove, list, stats five methods
  */
 export declare function Main(cnf: Cnf, deps: Deps, utils: ReturnType<typeof Utils>): {
-    modify: (Model: TModel, model: Sequelize.Model<any, any>, params: Params, isAdmin?: boolean, _cols?: string[] | undefined) => Promise<Sequelize.Model<any, any>>;
-    add: (Model: TModel, params: Params, isAdmin: boolean | undefined, _cols: string[] | undefined, { creatorId, clientIp }: CreatorAndClientIp) => Promise<any>;
+    modify: <T extends ModelBase<any, any>>(Model: ModelStatic<T>, model: T, params: Record<string, any>, isAdmin?: boolean, _cols?: string[] | undefined) => Promise<T>;
+    add: <T_1 extends ModelBase<any, any>>(Model: ModelStatic<T_1>, params: Record<string, any>, isAdmin: boolean | undefined, _cols: string[] | undefined, { creatorId, clientIp }: CreatorAndClientIp) => Promise<T_1>;
     remove: (model: Sequelize.Model, deletorId: UserId) => Promise<void | Sequelize.Model<any, any>>;
-    list: (Model: TModel, params: Params, allowAttrs?: string[] | undefined, toJSON?: boolean | undefined) => Promise<{
+    list: <T_2 extends ModelBase<any, any>>(Model: ModelStatic<T_2>, params: Record<string, any>, allowAttrs?: string[] | undefined, toJSON?: boolean | undefined) => Promise<{
         count: number;
-        rows: any[];
+        rows: T_2[];
     }>;
-    stats: (Model: TModel, params: Params, where?: any, conf?: {
+    stats: <T_3 extends ModelBase<any, any>>(Model: ModelStatic<T_3>, params: Record<string, any>, where?: any, conf?: {
         dimensions?: Record<string, string> | undefined;
         metrics: Record<string, string>;
         pagination?: {
@@ -41,7 +41,7 @@ export declare function Main(cnf: Cnf, deps: Deps, utils: ReturnType<typeof Util
         } | undefined;
     } | undefined) => Promise<{
         count: number;
-        rows: any;
+        rows: Record<string, string | number>[];
     }>;
 };
 export declare const Deps: string[];

package/dist/deps/rest/index.js

@@ -116,7 +116,7 @@ function Main(cnf, deps, utils) {
             count = await Model.count(lodash_1.default.pick(opt, COUNT_OPT));
         if (Array.isArray(allowAttrs) && allowAttrs.length)
             opt.attributes = allowAttrs;
-        const rows = (await Model.findAll(opt));
+        const rows = await Model.findAll(opt);
         if (toJSON) {
             for (let i = 0; i < rows.length; i += 1) {
                 rows[i] = rows[i].toJSON();

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

@@ -1,13 +1,21 @@
 import _ from "lodash";
 import * as Sequelize from "sequelize";
-import { Params, ModelExtraAtts, TModel } from "./defines";
+import { ModelBase, ModelStatic } from "../sequelize";
 import { Utils } from "./utils";
 interface Deps {
     _: typeof _;
     Sequelize: Pick<typeof Sequelize, "literal" | "and" | "fn">;
 }
-export declare function Stats(cnf: {}, deps: Deps, utils: ReturnType<typeof Utils>): (Model: TModel, params: Params, where?: any, conf?: ModelExtraAtts["stats"]) => Promise<{
+export declare function Stats(cnf: {}, deps: Deps, utils: ReturnType<typeof Utils>): <T extends ModelBase<any, any>>(Model: ModelStatic<T>, params: Record<string, any>, where?: any, conf?: {
+    dimensions?: Record<string, string> | undefined;
+    metrics: Record<string, string>;
+    pagination?: {
+        maxResults: number;
+        maxStartIndex: number;
+        maxResultsLimit: number;
+    } | undefined;
+} | undefined) => Promise<{
     count: number;
-    rows: any;
+    rows: Record<string, string | number>[];
 }>;
 export {};

package/dist/deps/rest/stats.js

@@ -149,7 +149,7 @@ function Stats(cnf, deps, utils) {
         let count = 0;
         if (_ignoreTotal !== "yes")
             count = await statsCount(Model, opt, dims);
-        const rows = await Model.findAll(opt);
+        const rows = (await Model.findAll(opt));
         for (const x of rows) {
             for (const met of metrics) {
                 x[met] = x[met] ? Number(x[met]) : 0;

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

@@ -1,8 +1,8 @@
 import type { LoDashStatic } from "lodash";
+import moment from "moment";
 import * as mysql from "mysql2";
 import * as Sequelize from "sequelize";
-import moment from "moment";
-import { ModelExtraAtts, TModel, Params } from "./defines";
+import { ModelBase, ModelStatic } from "../sequelize";
 interface Cnf {
     rest: {
         relativeMaxRangeDays?: number;
@@ -19,11 +19,15 @@ interface Deps {
     };
 }
 export declare function Utils(cnf: Cnf, deps: Deps): Readonly<{
-    pickParams: (params: any, cols: string[], Model: TModel, isAdmin: boolean) => {
+    pickParams: <T extends ModelBase<any, any>>(params: any, cols: string[], Model: ModelStatic<T>, isAdmin: boolean) => {
         [propName: string]: any;
     };
-    findAllOpts: (Model: TModel, params: Params) => any;
-    pageParams: (pagination: ModelExtraAtts["pagination"], params: Params) => {
+    findAllOpts: <T_1 extends ModelBase<any, any>>(Model: ModelStatic<T_1>, params: Record<string, any>) => any;
+    pageParams: (pagination: {
+        maxResults: number;
+        maxStartIndex: number;
+        maxResultsLimit: number;
+    } | undefined, params: Record<string, any>) => {
         offset: number;
         limit: number;
     };

package/dist/deps/rest/utils.js

@@ -199,6 +199,7 @@ function Utils(cnf, deps) {
     };
     const RELATIVE_RANGE_ERROR = errors.notAllowed(`相对时间跨度最多 ${RELATIVE_MAX_RANGE} 天`);
     // findOptFilter 的处理
+    // eslint-disable-next-line complexity
     const findOptFilter = (params, name, where, Op, col = name) => {
         let value;
         if (!params)
@@ -391,10 +392,12 @@ function Utils(cnf, deps) {
                 const searchOptResII = searchOpt(x.model, params._searchs, params.q, x.as);
                 if (searchOptResII)
                     searchOrs.push(searchOptResII);
-                x.where = includeWhere;
                 // 以及关联资源允许返回的字段
-                if (x.model.allowIncludeCols)
-                    x.attributes = x.model.allowIncludeCols;
+                let attributes;
+                if (x.model.allowIncludeCols && x.model.allowIncludeCols.length)
+                    attributes = x.model.allowIncludeCols;
+                // 将过滤条件和查询的字段附加上去
+                Object.assign(x, { where: includeWhere, attributes });
             });
         }
         const ret = {

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

@@ -1,16 +1,85 @@
-import * as Sequelize from "sequelize";
+import { Model, Options, Sequelize } from "sequelize";
 interface Cnf {
     sequelize: {
-        [propName: string]: Sequelize.Options;
+        [propName: string]: Options;
     };
 }
 interface Deps {
     Sequelize: {
-        Sequelize: typeof Sequelize.Sequelize;
+        Sequelize: typeof Sequelize;
     };
 }
+declare type NonConstructorKeys<T> = {
+    [P in keyof T]: T[P] extends new () => any ? never : P;
+}[keyof T];
+declare type NonConstructor<T> = Pick<T, NonConstructorKeys<T>>;
+export declare type ModelStatic<M extends ModelBase> = NonConstructor<typeof ModelBase> & (new () => M);
 export declare function Main(cnf: Cnf, deps: Deps): {
-    [propName: string]: Sequelize.Sequelize;
+    [propName: string]: Sequelize;
 };
 export declare const Deps: string[];
+/**
+ * Model 基类
+ */
+export declare class ModelBase<Attrs extends {} = any, Attrs4Create extends {} = Attrs> extends Model<Attrs, Attrs4Create> {
+    /**
+     * 基于主键获取某条数据的Mode实例，自动维护内存级 cache
+     * @param pk 主键
+     */
+    static getByPk<M extends ModelBase>(this: ModelStatic<M>, pk: string | number): Promise<M | null>;
+    /**
+     * 基于主键获取某些数据的Mode实例列表，维持参数的顺序，自动维护内存级 cache
+     * @param pks 主键数组
+     */
+    static getByPks<M extends ModelBase>(this: ModelStatic<M>, pks: string[] | number[]): Promise<M[]>;
+    /** 允许过滤的字段, 对于某些隐私、敏感信息，应该禁止基于其过滤, 使用者反复尝试可以暴力破解敏感信息 */
+    static filterAttrs?: string[];
+    /** 新增资源的时候可以写入的列名称集合 */
+    static writableCols?: string[];
+    /** 编辑资源的时候可以写入的列名称集合 */
+    static editableCols?: string[];
+    /** 关联资源的时候允许被关联展示的列名称集合 */
+    static allowIncludeCols?: string[];
+    /** 编辑过程中，仅管理可以更改的列名称集合 */
+    static onlyAdminCols?: string[];
+    /** 列表查询时候分页控制参数 */
+    static pagination?: {
+        maxResults: number;
+        maxStartIndex: number;
+        maxResultsLimit: number;
+    };
+    /** 列表查询时候排序控制参数 */
+    static sort?: {
+        default: string;
+        allow: string[];
+        defaultDirection?: "DESC" | "ASC";
+    };
+    /** 关联资源设定, 除非要关联过滤，否则不要设置资源之间的关联关系 */
+    static includes?: {
+        [k: string]: {
+            as: string;
+            required: boolean;
+            model: typeof ModelBase;
+        };
+    };
+    /** 模糊搜索相关设定 */
+    static searchCols?: {
+        [k: string]: {
+            op: "=" | "LIKE";
+            match: string[];
+        };
+    };
+    /** 统计相关设定 */
+    static stats?: {
+        dimensions?: Record<string, string>;
+        metrics: Record<string, string>;
+        pagination?: {
+            maxResults: number;
+            maxStartIndex: number;
+            maxResultsLimit: number;
+        };
+    };
+    /** 联合唯一列名称集合，用来自动恢复软删除的资源 */
+    static unique?: string[];
+}
 export {};

package/dist/deps/sequelize/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Deps = exports.Main = void 0;
+exports.ModelBase = exports.Deps = exports.Main = void 0;
+const sequelize_1 = require("sequelize");
 function Main(cnf, deps) {
     // 这里之所以要注入 Sequelize 是为了保证项目自身可以灵活选择自己的 Sequelize 版本, 这样改公共模块就会更加稳定, 避免频繁升级
     const { sequelize: dbs } = cnf;
@@ -14,3 +15,49 @@ function Main(cnf, deps) {
 }
 exports.Main = Main;
 exports.Deps = ["Sequelize"];
+/**
+ * Model 基类
+ */
+class ModelBase extends sequelize_1.Model {
+    /**
+     * 基于主键获取某条数据的Mode实例，自动维护内存级 cache
+     * @param pk 主键
+     */
+    static getByPk(pk) {
+        return this.findByPk(pk);
+    }
+    /**
+     * 基于主键获取某些数据的Mode实例列表，维持参数的顺序，自动维护内存级 cache
+     * @param pks 主键数组
+     */
+    static async getByPks(pks) {
+        if (!Array.isArray(pks) || !pks.length)
+            return [];
+        //静态方法调用同一个类中的其他静态方法，可使用 this 关键字
+        // eslint-disable-next-line no-undef
+        const list = [];
+        for await (const x of pks) {
+            const item = await this.getByPk(x);
+            if (item)
+                list.push(item);
+        }
+        return list;
+    }
+}
+exports.ModelBase = ModelBase;
+/** 新增资源的时候可以写入的列名称集合 */
+ModelBase.writableCols = [];
+/** 编辑资源的时候可以写入的列名称集合 */
+ModelBase.editableCols = [];
+/** 列表查询时候分页控制参数 */
+ModelBase.pagination = {
+    maxResults: 10,
+    maxStartIndex: 50000,
+    maxResultsLimit: 5000,
+};
+/** 列表查询时候排序控制参数 */
+ModelBase.sort = {
+    default: "id",
+    defaultDirection: "DESC",
+    allow: ["id"],
+};

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;
@@ -27,7 +20,12 @@ export interface Profile {
     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 +33,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,13 @@
+import { Server, Socket } from "socket.io";
+import { DefaultEventsMap } from "socket.io/dist/typed-events";
+import { Domain, Profile } from "./defines";
+export declare type Listener = Client["emit"] & {
+    roomId?: string;
+};
+declare type Client = Socket<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any> & {
+    profile?: ReturnType<typeof makeProfile>;
+    listener?: Listener;
+};
+declare const makeProfile: (client: Client, token: string, params: any, extra: Profile["extra"]) => Profile;
+export declare function BridgeSocket(io: Server, domain: Domain): void;
+export {};

package/dist/http/socket.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BridgeSocket = void 0;
+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, token, params, extra) => {
+    const obj = {
+        token,
+        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,
+        /** 客户端发布号 */
+        revision: params.revision,
+        /** 用户uuid 可以长期跨app */
+        uuid: params.uuid,
+        /** 额外信息，自由扩展 */
+        extra,
+    };
+    return obj;
+};
+function BridgeSocket(io, domain) {
+    const subscribe = domain["message.subscribe"];
+    const unsubscribe = domain["message.unsubscribe"];
+    const entrance = 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) => {
+        console.log("[%s] connection: client.id: %s", new Date(), client.id);
+        client.on("init", async (token, params, extra) => {
+            console.log("[%s] socket.init: client.id: %s", new Date(), client.id);
+            if (!token) {
+                client.emit("initError", "Token lost");
+                return;
+            }
+            try {
+                Object.assign(client, { profile: makeProfile(client, token, params, extra) });
+                if (!client.profile)
+                    throw new MyError("noAuth", "请先登录");
+                // 创建消息监听函数
+                if (!client.listener)
+                    client.listener = client.emit.bind(client);
+                // 向领域注册改用户的监听函数
+                const session = subscribe(client.profile, client.listener);
+                client.emit("inited", session);
+            }
+            catch (e) {
+                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.listener)
+                    return;
+                const res = await entrance({ roomId, ...client.profile }, client.listener);
+                client.profile.roomId = roomId;
+                client.listener.roomId = roomId;
+                client.emit("entranced", res);
+            }
+            catch (e) {
+                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.listener)
+                return;
+            // 这里要取消对领域消息的监听
+            unsubscribe(client.profile, client.listener);
+        });
+    });
+}
+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();
@@ -103,7 +106,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 +114,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 +127,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 +159,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/package.json

@@ -1,19 +1,19 @@
 {
   "name": "@domain.js/main",
-  "version": "0.1.14",
+  "version": "0.2.1",
   "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",
@@ -77,7 +77,8 @@
     "mysql2": "^2.3.3",
     "restify": "^8.6.0",
     "restify-errors": "^8.0.2",
-    "sequelize": "6.12.1",
+    "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,50 +0,0 @@
-import * as Sequelize from "sequelize";
-export interface Params {
-    [propName: string]: any;
-}
-export declare type TModel = typeof Sequelize.Model & {
-    filterAttrs?: string[];
-    writableCols?: string[];
-    editableCols?: string[];
-    allowIncludeCols?: string[];
-    onlyAdminCols?: string[];
-    pagination?: {
-        maxResults: number;
-        maxStartIndex: number;
-        maxResultsLimit: number;
-    };
-    sort?: {
-        default: string;
-        allow: string[];
-        defaultDirection?: "DESC" | "ASC";
-    };
-    includes?: {
-        [k: string]: {
-            as: string;
-            required: boolean;
-            model: TModel;
-        };
-    };
-    searchCols?: {
-        [k: string]: {
-            op: "=" | "LIKE";
-            match: string[];
-        };
-    };
-    stats?: {
-        dimensions?: Record<string, string>;
-        metrics: Record<string, string>;
-        pagination?: {
-            maxResults: number;
-            maxStartIndex: number;
-            maxResultsLimit: number;
-        };
-    };
-    unique?: string[];
-};
-export declare type ModelExtraAtts = Omit<TModel, keyof typeof Sequelize.Model>;
-export interface Include {
-    as: string;
-    required: boolean;
-    model: TModel;
-}

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"];