@domain.js/main 0.1.13 → 0.2.0

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/defaults.d.ts

@@ -1,18 +1,18 @@
-import _ from "lodash";
-import * as uuid from "uuid";
 import * as ajv from "ajv";
 import * as ajvFormats from "ajv-formats";
 import * as async from "async";
 import * as axios from "axios";
 import * as cronParser from "cron-parser";
 import humanInterval from "human-interval";
-import * as IORedis from "ioredis";
+import IORedis from "ioredis";
+import _ from "lodash";
 import LRU from "lru-cache";
+import moment from "moment";
 import * as mysql from "mysql2";
 import * as Sequelize from "sequelize";
-import moment from "moment";
-import * as utils from "./utils";
+import * as uuid from "uuid";
 import { errors } from "./basic-errors";
+import * as utils from "./utils";
 /** npm packages injection */
 export interface Defaults {
     /**

package/dist/defaults.js

@@ -23,21 +23,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaults = void 0;
-const lodash_1 = __importDefault(require("lodash"));
-const uuid = __importStar(require("uuid"));
 const ajv = __importStar(require("ajv"));
 const ajvFormats = __importStar(require("ajv-formats"));
 const async = __importStar(require("async"));
 const axios = __importStar(require("axios"));
 const cronParser = __importStar(require("cron-parser"));
 const human_interval_1 = __importDefault(require("human-interval"));
-const IORedis = __importStar(require("ioredis"));
+const ioredis_1 = __importDefault(require("ioredis"));
+const lodash_1 = __importDefault(require("lodash"));
 const lru_cache_1 = __importDefault(require("lru-cache"));
+const moment_1 = __importDefault(require("moment"));
 const mysql = __importStar(require("mysql2"));
 const Sequelize = __importStar(require("sequelize"));
-const moment_1 = __importDefault(require("moment"));
-const utils = __importStar(require("./utils"));
+const uuid = __importStar(require("uuid"));
 const basic_errors_1 = require("./basic-errors");
+const utils = __importStar(require("./utils"));
 exports.defaults = {
     _: lodash_1.default,
     uuid,
@@ -47,7 +47,7 @@ exports.defaults = {
     axios,
     cronParser,
     humanInterval: human_interval_1.default,
-    IORedis,
+    IORedis: ioredis_1.default,
     LRU: lru_cache_1.default,
     mysql,
     Sequelize,

package/dist/deps/graceful/index.js

@@ -1,30 +1,15 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __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.Deps = exports.Main = void 0;
-const process = __importStar(require("process"));
+const process_1 = __importDefault(require("process"));
 function Graceful(info) {
     let exiting = false; // 是否正在退出
     const callbacks = [];
-    const counter = ((count = 0) => {
+    const counter = ((init = 0) => {
+        let count = init;
         const decr = () => {
             count -= 1;
         };
@@ -72,11 +57,11 @@ function Graceful(info) {
                 return;
             info("process exit check success, process exited");
             clearInterval(timer);
-            process.exit(0);
+            process_1.default.exit(0);
         }, 1000);
     };
-    process.on("SIGTERM", exitHandle);
-    process.on("SIGINT", exitHandle);
+    process_1.default.on("SIGTERM", exitHandle);
+    process_1.default.on("SIGINT", exitHandle);
     /**
      * addListen function be called when process exit
      * @param listenner

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

@@ -4,6 +4,7 @@ export interface Cnf {
     host?: string;
     bodyMaxBytes?: number;
     apisRoute?: string;
+    socket?: boolean;
     [propName: string]: any;
 }
 interface Sign {
@@ -28,6 +29,9 @@ export interface Profile {
     uuid?: string;
     token?: string;
     sign?: Sign;
+    isSocket?: boolean;
+    /** socket 的时候汇报自己的位置 */
+    position?: string;
 }
 export interface HttpCodes {
     [propName: string]: number;
@@ -35,9 +39,7 @@ 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;

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,3 @@
+import { Server } from "socket.io";
+import { Domain } from "./defines";
+export declare function BridgeSocket(io: Server, domain: Domain): void;

package/dist/http/socket.js

@@ -0,0 +1,134 @@
+"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"];
+    if (!subscribe)
+        throw Error("要启用 socket 服务，必须要要有 message.subscribe 方法，用来处理 socket 订阅");
+    if (!unsubscribe)
+        throw Error("要启用 socket 服务，必须要要有 message.unsubscribe 方法，用来处理 socket 退订");
+    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", "请先登录");
+                const session = await domain["auth.session"](client.profile, {});
+                // 创建消息监听函数
+                if (!client.listener)
+                    client.listener = client.emit.bind(client);
+                // 向领域注册改用户的监听函数
+                domain["message.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.use(async ([name, params, responseId], next) => {
+            if (name === "init")
+                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 参数
      */