@domain.js/main 0.1.0

package/dist/deps/graceful/index.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deps = exports.Main = void 0;
+const process = require("process");
+function Graceful(info) {
+    let exiting = false; // 是否正在退出
+    const callbacks = [];
+    const counter = ((count = 0) => {
+        const decr = () => {
+            count -= 1;
+        };
+        const incr = () => {
+            count += 1;
+        };
+        const get = () => count;
+        return { incr, decr, get };
+    })(0);
+    const exitHandle = async () => {
+        info("process exiting start");
+        if (exiting) {
+            info("process exiting..., wait please");
+            return;
+        }
+        exiting = true;
+        // 执行事件回调函数
+        for (const cb of callbacks) {
+            info("process exiting, callback running");
+            counter.incr();
+            try {
+                const ret = cb();
+                if (ret && ret.then && ret.catch) {
+                    ret
+                        .then(() => {
+                        counter.decr();
+                    })
+                        .catch(() => {
+                        counter.decr();
+                    });
+                }
+                else {
+                    counter.decr();
+                }
+            }
+            catch (e) {
+                info("process exiting, callback running faid", e);
+                counter.decr();
+            }
+        }
+        // 每秒一次去检测是否所有函数执行都已完毕，可以退出
+        const timer = setInterval(() => {
+            info(`process exit check count: ${counter.get()}`);
+            if (counter.get() > 0)
+                return;
+            info("process exit check success, process exited");
+            clearInterval(timer);
+            process.exit(0);
+        }, 1000);
+    };
+    process.on("SIGTERM", exitHandle);
+    process.on("SIGINT", exitHandle);
+    /**
+     * addListen function be called when process exit
+     * @param listenner
+     */
+    const exit = (listenner) => {
+        callbacks.push(listenner);
+    };
+    function runner(fn) {
+        return (...args) => {
+            // 当前状态正在退出，阻止执行函数
+            if (exiting)
+                throw Error("process exiting...");
+            counter.incr();
+            try {
+                const res = fn(...args);
+                counter.decr();
+                return res;
+            }
+            catch (e) {
+                counter.decr();
+                throw e;
+            }
+        };
+    }
+    function runnerAsync(fn) {
+        return async (...args) => {
+            // 当前状态正在退出，阻止执行函数
+            if (exiting)
+                throw Error("process exiting");
+            counter.incr();
+            try {
+                const res = await fn(...args);
+                counter.decr();
+                return res;
+            }
+            catch (e) {
+                counter.decr();
+                throw e;
+            }
+        };
+    }
+    const enabled = () => Boolean(!exiting);
+    return {
+        runner,
+        runnerAsync,
+        enabled,
+        exit,
+    };
+}
+function Main(cnf, deps) {
+    const { logger } = deps;
+    return Graceful(logger.info);
+}
+exports.Main = Main;
+exports.Deps = ["logger"];

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

@@ -0,0 +1,17 @@
+import { Redis } from "ioredis";
+interface Cnf {
+    hash: {
+        key: string;
+    };
+}
+interface Deps {
+    redis: Pick<Redis, "hget" | "hset" | "hdel" | "hincrby">;
+}
+export declare function Main(cnf: Cnf, deps: Deps): {
+    get: (key: string) => Promise<number>;
+    set: (key: string, value: string) => Promise<number>;
+    del: (key: string) => Promise<number>;
+    incr: (key: string, step?: number) => Promise<number>;
+};
+export declare const Deps: string[];
+export {};

package/dist/deps/hash/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deps = exports.Main = void 0;
+function Main(cnf, deps) {
+    const { hash: { key: REDIS_KEY }, } = cnf;
+    const { redis } = deps;
+    const get = async (key) => {
+        const num = await redis.hget(REDIS_KEY, key);
+        return Number(num) | 0;
+    };
+    const set = (key, value) => redis.hset(REDIS_KEY, key, value);
+    const del = (key) => redis.hdel(REDIS_KEY, key);
+    const incr = (key, step = 1) => redis.hincrby(REDIS_KEY, key, step);
+    return { get, set, del, incr };
+}
+exports.Main = Main;
+exports.Deps = ["redis"];

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

@@ -0,0 +1,14 @@
+interface Cnf {
+    logger: {
+        clientId: string;
+        errorLogPath: string;
+        infoLogPath: string;
+        ignoreErrors?: [string | number];
+    };
+}
+export declare function Main(cnf: Cnf): {
+    error: (e: any, extra?: any) => void;
+    info: (message: string, extra?: any) => void;
+    logger: <T extends (...args: any[]) => any>(fn: T, name: string, isAsync?: boolean, transform?: (x: ReturnType<T>) => any, errorHandler?: (e: any) => string, argsHandler?: (arg: Parameters<T>) => string) => T;
+};
+export {};

package/dist/deps/logger/index.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Main = void 0;
+const fs = require("fs");
+const path = require("path");
+const _ = require("lodash");
+const uuid_1 = require("uuid");
+const date = (offset = 0) => new Date(Date.now() + (offset | 0)).toISOString();
+function Main(cnf) {
+    const { logger: { errorLogPath, infoLogPath, ignoreErrors, clientId }, } = cnf;
+    const makeDir = _.memoize((dir) => {
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir);
+    });
+    const ignores = new Set(ignoreErrors);
+    const error = (e, extra) => {
+        if (!e) {
+            console.trace("Logger.error but error is null or undefined");
+            return;
+        }
+        const time = date();
+        const today = time.split("T")[0];
+        const code = e.code || "unknown";
+        // 忽略某些错误
+        if (ignores.has(code))
+            return;
+        const dir = path.resolve(errorLogPath, today);
+        makeDir(dir);
+        const file = path.resolve(dir, `${code}.err`);
+        const content = [time, clientId, e.message];
+        if (e.data)
+            content.push(JSON.stringify(e.data));
+        if (extra != null)
+            content.push(JSON.stringify(extra));
+        if (e.stack)
+            content.push(JSON.stringify(e.stack));
+        try {
+            fs.appendFileSync(file, `${content.join("\t")}\n`);
+        }
+        catch (err) {
+            console.error("Logger.error appendFileSync faid: %o", err);
+        }
+    };
+    const info = (message, extra) => {
+        const time = date();
+        const today = time.split("T")[0];
+        const dir = path.resolve(infoLogPath, today);
+        makeDir(dir);
+        const file = path.resolve(dir, "info.log");
+        const content = [time, clientId, message];
+        if (extra != null)
+            content.push(JSON.stringify(extra));
+        try {
+            fs.appendFileSync(file, `${content.join("\t")}\n`);
+        }
+        catch (e) {
+            console.error("Logger.info appendFileSync faid: %o", e);
+        }
+    };
+    const logger = (fn, name, isAsync = false, transform = (x) => x, errorHandler = (e) => (e instanceof Error ? e.message : ""), argsHandler = JSON.stringify) => {
+        if (isAsync) {
+            const handler = {
+                async apply(fn, me, args) {
+                    const callId = (0, uuid_1.v4)();
+                    try {
+                        info(`Begin: ${name}\t${callId}\t${argsHandler(args)}`);
+                        const startedAt = Date.now();
+                        const res = await Reflect.apply(fn, me, args);
+                        info(`Completed: ${name}\t${callId}\t${Date.now() - startedAt}ms\t${JSON.stringify(transform(res))}`);
+                        return res;
+                    }
+                    catch (e) {
+                        info(`Error: ${name}\t${callId}\t${errorHandler(e)}`, e instanceof Error && e.stack);
+                        throw e;
+                    }
+                },
+            };
+            return new Proxy(fn, handler);
+        }
+        const handler = {
+            apply(fn, me, args) {
+                const callId = (0, uuid_1.v4)();
+                try {
+                    info(`Begin: ${name}\t${callId}\t${argsHandler(args)}`);
+                    const startedAt = Date.now();
+                    const res = Reflect.apply(fn, me, args);
+                    info(`Completed: ${name}\t${callId}\t${Date.now() - startedAt}ms\t${JSON.stringify(transform(res))}`);
+                    return res;
+                }
+                catch (e) {
+                    info(`Error: ${name}\t${callId}\t${errorHandler(e)}`, e instanceof Error && e.stack);
+                    throw e;
+                }
+            },
+        };
+        return new Proxy(fn, handler);
+    };
+    return { error, info, logger };
+}
+exports.Main = Main;

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

@@ -0,0 +1,34 @@
+import { Redis } from "ioredis";
+import { Main as Logger } from "../logger";
+import { Main as Graceful } from "../graceful";
+import * as utils from "../../utils";
+interface Cnf {
+    parallel: {
+        key: string;
+        defaultErrorFn(path: string, minMS?: number): void;
+    };
+}
+interface Deps {
+    logger: {
+        info: ReturnType<typeof Logger>["info"];
+        error: ReturnType<typeof Logger>["error"];
+    };
+    graceful: {
+        exit: ReturnType<typeof Graceful>["exit"];
+    };
+    utils: {
+        sleep: typeof utils.sleep;
+    };
+    redis: Pick<Redis, "get" | "set" | "del" | "expire" | "exists">;
+}
+export interface Option {
+    path: string;
+    keyFn?(...args: any[]): string;
+    minMS?: number;
+    errorFn?: Function;
+    needWaitMS?: number;
+    neverReturn?: boolean;
+}
+export declare function Main(cnf: Cnf, deps: Deps): <F extends (...args: any[]) => any>(method: F, opt: Option) => (...args: Parameters<F>) => Promise<ReturnType<F>>;
+export declare const Deps: string[];
+export {};

package/dist/deps/parallel/index.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deps = exports.Main = void 0;
+const async = require("async");
+function Main(cnf, deps) {
+    const { parallel: { key: KEY, defaultErrorFn }, } = cnf;
+    const { logger, graceful, utils: { sleep }, redis, } = deps;
+    // 存放当前处于执行中的 key
+    const doings = new Set();
+    let exiting = false;
+    // 退出时候做的处理
+    const onExit = async () => {
+        exiting = true;
+        logger.info("graceful.onExit parallel start", [...doings]);
+        await async.eachLimit([...doings], 10, async (key) => {
+            doings.delete(key);
+            await redis.del(key);
+            logger.info(`graceful.onExit parallel del: ${key}`);
+        });
+        logger.info("graceful.onExit parallel end");
+    };
+    const delay = async () => {
+        if (!doings.size)
+            return;
+        logger.info("start parallel delay keys: %o", doings);
+        await async.eachLimit([...doings], 10, async (key) => {
+            // 延长 300 秒
+            await redis.expire(key, 300);
+        });
+        logger.info("end parallel delay keys: %o", doings);
+    };
+    async.forever(async () => {
+        try {
+            await sleep(100 * 1000);
+            await delay();
+        }
+        catch (e) {
+            logger.error(e);
+        }
+    }, logger.error);
+    /* 将 method 函数处理为有并发控制功能的函数 */
+    function control(method, opt) {
+        const { path, keyFn = () => opt.path, minMS = 0, errorFn = defaultErrorFn, needWaitMS = 0, neverReturn = false, } = opt;
+        const error = (errorFn || defaultErrorFn)(path, minMS);
+        const end = async (key, startAt) => {
+            const timing = Date.now() - startAt; // 执行总用时毫秒数
+            const remainMS = minMS - timing; // 计算和最小耗时的差值毫秒数
+            if (remainMS > 0) {
+                await redis.expire(key, (remainMS / 1000) | 0);
+            }
+            else {
+                await redis.del(key);
+            }
+            doings.delete(key);
+        };
+        const paralleled = async (...args) => {
+            if (exiting)
+                throw Error("process exiting");
+            const key = `${KEY}::${keyFn(path, ...args)}`;
+            const ok = await redis.set(key, Date.now(), "EX", 300, "NX");
+            if (exiting) {
+                await redis.del(key);
+                throw Error("process exiting");
+            }
+            if (!ok) {
+                // 不需要等待，则直接抛出异常
+                if (!needWaitMS)
+                    throw error;
+                // 需要等待
+                await async.whilst(async () => Boolean(await redis.exists(key)), async () => sleep(needWaitMS));
+                return paralleled(...args);
+            }
+            const startAt = Date.now(); // 执行开始毫秒数
+            doings.add(key);
+            try {
+                const res = await method(...args);
+                if (!neverReturn)
+                    await end(key, startAt);
+                return res;
+            }
+            catch (e) {
+                await end(key, startAt);
+                throw e;
+            }
+        };
+        return paralleled;
+    }
+    // 进程退出时候的处理
+    graceful.exit(onExit);
+    return control;
+}
+exports.Main = Main;
+exports.Deps = ["logger", "graceful", "redis", "utils"];

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

@@ -0,0 +1,6 @@
+import * as Redis from "ioredis";
+interface Cnf {
+    redis: Redis.RedisOptions;
+}
+export declare function Main(cnf: Cnf): Redis.Redis;
+export {};

package/dist/deps/redis/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Main = void 0;
+const Redis = require("ioredis");
+function Main(cnf) {
+    const { redis } = cnf;
+    return new Redis(redis);
+}
+exports.Main = Main;

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

@@ -0,0 +1,5 @@
+import { Utils } from "./utils";
+declare type Cnf = Parameters<typeof Utils>[0];
+declare type Deps = Parameters<typeof Utils>[1];
+export declare function Before(cnf: Cnf, deps: Deps): [Cnf, Deps, ReturnType<typeof Utils>];
+export {};

package/dist/deps/rest/Before.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Before = void 0;
+const utils_1 = require("./utils");
+function Before(cnf, deps) {
+    const utils = (0, utils_1.Utils)(cnf, deps);
+    return [cnf, deps, utils];
+}
+exports.Before = Before;

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

@@ -0,0 +1,50 @@
+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

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

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

@@ -0,0 +1,34 @@
+import * as Sequelize from "sequelize";
+import { TModel, Params } from "./defines";
+import { Stats } from "./stats";
+import { Utils } from "./utils";
+export { Before } from "./Before";
+declare type Cnf = Parameters<typeof Utils>[0] & Parameters<typeof Stats>[0];
+declare type Deps = Parameters<typeof Utils>[1] & Parameters<typeof Stats>[1];
+declare type UserId = string | number;
+export interface CreatorAndClientIp {
+    creatorId: UserId;
+    clientIp: string;
+}
+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>;
+    remove: (model: Sequelize.Model, deletorId: UserId) => Promise<void | Sequelize.Model<any, any>>;
+    list: (Model: TModel, params: Params, allowAttrs?: string[] | undefined, toJSON?: boolean | undefined) => Promise<{
+        count: number;
+        rows: any;
+    }>;
+    stats: (Model: TModel, params: Params, 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;
+    }>;
+};
+export declare const Deps: string[];

package/dist/deps/rest/index.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deps = exports.Main = exports.Before = void 0;
+const _ = require("lodash");
+const stats_1 = require("./stats");
+var Before_1 = require("./Before");
+Object.defineProperty(exports, "Before", { enumerable: true, get: function () { return Before_1.Before; } });
+function Main(cnf, deps, utils) {
+    const { errors } = deps;
+    const { findAllOpts, pickParams } = utils;
+    const modify = (Model, model, params, isAdmin = false, _cols) => {
+        const cols = _cols || Model.editableCols || Model.writableCols || [];
+        const attr = pickParams(params, cols, Model, isAdmin);
+        // 避免id 被篡改，强制删除id属性
+        if (attr.id)
+            delete attr.id;
+        Object.assign(model, attr);
+        return model.save();
+    };
+    const add = async (Model, params, isAdmin = false, _cols, { creatorId, clientIp }) => {
+        const cols = _cols || Model.writableCols || [];
+        const attr = pickParams(params, cols, Model, isAdmin);
+        if (Model.rawAttributes.creatorId)
+            attr.creatorId = creatorId;
+        if (Model.rawAttributes.clientIp)
+            attr.clientIp = clientIp;
+        // 如果没有设置唯一属性且开启回收站, 则直接添加
+        if (!(Model.unique && Model.rawAttributes.isDeleted))
+            return Model.create(attr);
+        // 如果设置了唯一属性，且开启了回收站功能
+        // 则判断是否需要执行恢复操作
+        const where = _.pick(attr, Model.unique);
+        // 根据条件查找资源
+        const model = await Model.findOne({ where });
+        // 资源不存在
+        if (!model)
+            return Model.create(attr);
+        // 资源存在但是并非已删除的，抛出资源重复添加的error
+        if (model.isDeleted === "no")
+            throw errors.resourceDuplicateAdd(where);
+        // 资源存在，恢复
+        model.isDeleted = "no";
+        Object.assign(model, attr);
+        return model.save();
+    };
+    const TRASH_OPT = Object.freeze({ fields: ["isDeleted", "deletorId"] });
+    const remove = async (model, deletorId) => {
+        // 未开启回收站，直接删除
+        if (!model.isDeleted)
+            return model.destroy();
+        // 这里不做字段是否存在的判断，无所谓
+        model.deletorId = deletorId;
+        model.isDeleted = "yes";
+        // 丢进垃圾桶
+        return model.save(TRASH_OPT);
+    };
+    // count条件所需属性
+    const COUNT_OPT = Object.freeze(["where", "include"]);
+    const list = async (Model, params, allowAttrs, toJSON) => {
+        const opt = findAllOpts(Model, params);
+        const { _ignoreTotal } = params;
+        // 提高查询速度
+        let count = 0;
+        if (_ignoreTotal !== "yes")
+            count = await Model.count(_.pick(opt, COUNT_OPT));
+        if (Array.isArray(allowAttrs) && allowAttrs.length)
+            opt.attributes = allowAttrs;
+        const rows = await Model.findAll(opt);
+        if (toJSON) {
+            for (let i = 0; i < rows.length; i += 1) {
+                rows[i] = rows[i].toJSON();
+            }
+        }
+        return { count, rows };
+    };
+    return { modify, add, remove, list, stats: (0, stats_1.Stats)(cnf, deps, utils) };
+}
+exports.Main = Main;
+exports.Deps = ["errors"];

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

@@ -0,0 +1,6 @@
+import { Params, ModelExtraAtts, TModel } from "./defines";
+import { Utils } from "./utils";
+export declare function Stats(cnf: {}, deps: {}, utils: ReturnType<typeof Utils>): (Model: TModel, params: Params, where: any, conf?: ModelExtraAtts["stats"]) => Promise<{
+    count: number;
+    rows: any;
+}>;