@domain.js/main 0.1.1 → 0.1.6

package/.husky/pre-commit

@@ -4,4 +4,4 @@ if [ ! -f "$(dirname "$0")/_/husky.sh" ]; then
 fi
 . "$(dirname "$0")/_/husky.sh"
 
-ts-node src/cli/index.ts loadDeps ./ ts && npm run lint-staged && npm run build 
+ts-node src/cli/index.ts loadDeps ./src/deps/ ts && npm run lint-staged && npm run build 

package/dist/cli/index.d.ts

@@ -1,2 +1,2 @@
-#! /usr/bin/env ts-node
+#! /usr/bin/env node
 export {};

package/dist/cli/index.js

@@ -1,4 +1,4 @@
-#! /usr/bin/env ts-node
+#! /usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs = require("fs");
@@ -79,7 +79,7 @@ const checkHookExport = (_dir) => {
 const loadDeps = async (rootDir = process.cwd(), ext = "js") => {
     const isTS = ext === "ts";
     const modules = [];
-    const dir = path.resolve(rootDir, "src/deps/");
+    const dir = path.resolve(rootDir, "./");
     for (const x of fs.readdirSync(dir)) {
         // 忽略隐藏目录
         if (x[0] === ".")
@@ -93,7 +93,7 @@ const loadDeps = async (rootDir = process.cwd(), ext = "js") => {
         modules.push(x);
     }
     // 按字典排序，后续有变动的时候不容易冲突
-    const targetFile = path.resolve(rootDir, `src/deps/defines.${ext}`);
+    const targetFile = path.resolve(rootDir, `./defines.${ext}`);
     await makeDefineFile(modules.sort(), targetFile, isTS);
 };
 const checkService = (_dir) => {
@@ -106,7 +106,7 @@ const checkService = (_dir) => {
 const loadServices = async (rootDir = process.cwd(), ext = "js") => {
     const isTS = ext === "ts";
     const modules = [];
-    const dir = path.resolve(rootDir, "src/services/");
+    const dir = path.resolve(rootDir, "domain/services/");
     for (const x of fs.readdirSync(dir)) {
         // 忽略隐藏目录, 忽略私有目录
         if (x[0] === "." || x[0] === "_")
@@ -120,7 +120,7 @@ const loadServices = async (rootDir = process.cwd(), ext = "js") => {
         modules.push(x);
     }
     // 按字典排序，后续有变动的时候不容易冲突
-    const targetFile = path.resolve(rootDir, `src/services/defines.${ext}`);
+    const targetFile = path.resolve(rootDir, `domain/services/defines.${ext}`);
     await makeDefineFile(modules.sort(), targetFile, isTS);
 };
 const deepLoadDir = (root, parent, files = []) => {

package/dist/cli/schema2ts.d.ts

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

package/dist/cli/schema2ts.js

@@ -0,0 +1,37 @@
+"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/index.d.ts

@@ -56,6 +56,8 @@ export declare function Main(cnf: Cnf, deps: Deps): {
     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

@@ -282,7 +282,27 @@ function Main(cnf, deps) {
     const isExiting = () => Boolean(exiting);
     // 进程是否已经退出
     const isExited = () => Boolean(exited);
-    return { isExiting, isExited, checkReady, getStats, getUnlinks, regist, link, submit, setFn };
+    /**
+     * 领域方法注册到 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/cron/index.js

@@ -93,4 +93,4 @@ function Main(cnf, deps) {
     return { regist, start, getStats };
 }
 exports.Main = Main;
-exports.Deps = ["cia", "humanInterval", "cronParser"];
+exports.Deps = ["myCia", "humanInterval", "cronParser"];

package/dist/deps/defines.d.ts

@@ -1,12 +1,12 @@
 import * as aes from "./aes";
 import * as cache from "./cache";
 import * as checker from "./checker";
-import * as cia from "./cia";
 import * as counter from "./counter";
 import * as cron from "./cron";
 import * as graceful from "./graceful";
 import * as hash from "./hash";
 import * as logger from "./logger";
+import * as myCia from "./myCia";
 import * as parallel from "./parallel";
 import * as redis from "./redis";
 import * as request from "./request";
@@ -18,12 +18,12 @@ declare const _default: {
     aes: typeof aes;
     cache: typeof cache;
     checker: typeof checker;
-    cia: typeof cia;
     counter: typeof counter;
     cron: typeof cron;
     graceful: typeof graceful;
     hash: typeof hash;
     logger: typeof logger;
+    myCia: typeof myCia;
     parallel: typeof parallel;
     redis: typeof redis;
     request: typeof request;

package/dist/deps/defines.js

@@ -3,12 +3,12 @@
 const aes = require("./aes");
 const cache = require("./cache");
 const checker = require("./checker");
-const cia = require("./cia");
 const counter = require("./counter");
 const cron = require("./cron");
 const graceful = require("./graceful");
 const hash = require("./hash");
 const logger = require("./logger");
+const myCia = require("./myCia");
 const parallel = require("./parallel");
 const redis = require("./redis");
 const request = require("./request");
@@ -20,12 +20,12 @@ module.exports = {
     aes,
     cache,
     checker,
-    cia,
     counter,
     cron,
     graceful,
     hash,
     logger,
+    myCia,
     parallel,
     redis,
     request,

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

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

package/dist/deps/myCia/errors.js

@@ -0,0 +1,36 @@
+"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/myCia/index.d.ts

@@ -0,0 +1,63 @@
+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/myCia/index.js

@@ -0,0 +1,308 @@
+"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/signer/index.d.ts

@@ -5,7 +5,7 @@ export interface Opt {
     /** Key for signature calculation */
     key: string;
     /** Second timestamp */
-    timestamp: number;
+    timestamp: number | string;
     /** Signature algorithm, fixed as hmacsha256 */
     signMethod: "HmacSHA256";
     /** Signature version, fixed as 1 */
@@ -37,7 +37,7 @@ export declare function Main(): {
         readonly "x-auth-signature": string;
         readonly "x-auth-key": string;
         readonly "x-auth-method": string;
-        readonly "x-auth-timestamp": number;
+        readonly "x-auth-timestamp": string;
         readonly "x-auth-sign-method": "HmacSHA256";
         readonly "x-auth-sign-version": "1";
     };

package/dist/deps/signer/index.js

@@ -37,7 +37,7 @@ function Main() {
             const opt = {
                 uri,
                 key,
-                timestamp: (Date.now() / 1000) | 0,
+                timestamp: `${(Date.now() / 1000) | 0}`,
                 signMethod: "HmacSHA256",
                 signVersion: "1",
                 method,

package/dist/dm/index.d.ts

@@ -1,6 +1,6 @@
 interface ModuleInterface {
     Main: (...args: any[]) => any;
-    Deps?: string[];
+    Deps?: string[] | ReadonlyArray<string>;
     Before?: (...args: any[]) => any;
     After?: (...args: any[]) => void;
 }

package/dist/http/defines.d.ts

@@ -4,7 +4,6 @@ export interface Cnf {
     host?: string;
     bodyMaxBytes?: number;
     apisRoute?: string;
-    swaggerApiPath?: string;
     [propName: string]: any;
 }
 interface Sign {
@@ -31,12 +30,12 @@ export interface Profile {
 export interface HttpCodes {
     [propName: string]: number;
 }
-interface _Domain {
-    [propName: string]: (profile: Profile, params: any) => any | _Domain;
+export interface Domain {
+    [propName: string]: (profile: Profile, params: any) => any | Domain;
+}
+export interface GetSchemaByPath {
+    (methodPath: string): [any, any];
 }
-export declare type Domain = _Domain & {
-    _getSchemaByPath(methodPath: string): [any, any];
-};
 export interface Err {
     message: string;
     code?: number | string;