@domain.js/main 0.1.0 → 0.1.1

package/dist/deps/parallel/index.js

@@ -1,10 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Deps = exports.Main = void 0;
-const async = require("async");
+const utils = require("../../utils");
+/**
+ * Parallel control module
+ * @param cnf Module initialization configuration parameters
+ * @param deps Module initialization dependency
+ * @returns Parallel control function
+ */
 function Main(cnf, deps) {
-    const { parallel: { key: KEY, defaultErrorFn }, } = cnf;
-    const { logger, graceful, utils: { sleep }, redis, } = deps;
+    const { parallel: { key: KEY, defaultErrorFn, maxExpireSeconds = 300, resetExpireIntervalMS = 100 * 1000, }, } = cnf;
+    const { async, logger, graceful, redis } = deps;
+    const { sleep } = utils;
     // 存放当前处于执行中的 key
     const doings = new Set();
     let exiting = false;
@@ -22,26 +29,28 @@ function Main(cnf, deps) {
     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);
+            await redis.expire(key, maxExpireSeconds);
         });
-        logger.info("end parallel delay keys: %o", doings);
     };
     async.forever(async () => {
         try {
-            await sleep(100 * 1000);
+            await sleep(resetExpireIntervalMS);
             await delay();
         }
         catch (e) {
             logger.error(e);
         }
     }, logger.error);
-    /* 将 method 函数处理为有并发控制功能的函数 */
+    /**
+     * Parallel control function
+     * @param method Functions that need to control parallel execution
+     * @param opt Parallel control parameters
+     * @returns Functions with parallel control capability
+     */
     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 error = errorFn(path, minMS);
         const end = async (key, startAt) => {
             const timing = Date.now() - startAt; // 执行总用时毫秒数
             const remainMS = minMS - timing; // 计算和最小耗时的差值毫秒数
@@ -90,4 +99,4 @@ function Main(cnf, deps) {
     return control;
 }
 exports.Main = Main;
-exports.Deps = ["logger", "graceful", "redis", "utils"];
+exports.Deps = ["async", "logger", "graceful", "redis"];

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

@@ -2,5 +2,16 @@ import * as Redis from "ioredis";
 interface Cnf {
     redis: Redis.RedisOptions;
 }
-export declare function Main(cnf: Cnf): Redis.Redis;
+interface Deps {
+    IORedis: typeof Redis;
+}
+/**
+ * @link https://www.npmjs.com/package/ioredis
+ *
+ * Redis module, an instance based on ioredis
+ * @param cnf
+ * @returns An instance of ioredis
+ */
+export declare function Main(cnf: Cnf, deps: Deps): Redis.Redis;
+export declare const Deps: string[];
 export {};

package/dist/deps/redis/index.js

@@ -1,9 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Main = void 0;
-const Redis = require("ioredis");
-function Main(cnf) {
+exports.Deps = exports.Main = void 0;
+/**
+ * @link https://www.npmjs.com/package/ioredis
+ *
+ * Redis module, an instance based on ioredis
+ * @param cnf
+ * @returns An instance of ioredis
+ */
+function Main(cnf, deps) {
     const { redis } = cnf;
-    return new Redis(redis);
+    const { IORedis } = deps;
+    return new IORedis(redis);
 }
 exports.Main = Main;
+exports.Deps = ["IORedis"];

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

@@ -0,0 +1,43 @@
+import axios, { AxiosInstance } from "axios";
+import { Main as Logger } from "../logger";
+import * as utils from "../../utils";
+interface Cnf {
+    /** axios config */
+    axios?: {
+        /** auto record log methods list */
+        loggers?: string[];
+        /** auto retry methods list */
+        retrys?: string[];
+        /** retry max times */
+        retryTimes?: number;
+        /** retry interval millisecond */
+        retryIntervalMS?: number;
+        /** axios.create the first argument */
+        conf?: Parameters<typeof axios.create>[0];
+    };
+}
+interface Deps {
+    axios: {
+        create: typeof axios.create;
+    };
+    logger: ReturnType<typeof Logger>;
+    utils: {
+        sleep: typeof utils.sleep;
+    };
+}
+/**
+ * axios module
+ * @link https://www.npmjs.com/package/axios
+ *
+ * @param cnf module initialize config
+ * @param deps module initalize dependents
+ * @returns returns of axios.create
+ */
+export declare function Main(cnf: Cnf, deps: Deps): AxiosInstance & {
+    /** Original Axios module */
+    origin?: {
+        create: (config?: import("axios").AxiosRequestConfig<any> | undefined) => AxiosInstance;
+    } | undefined;
+};
+export declare const Deps: string[];
+export {};

package/dist/deps/request/index.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deps = exports.Main = void 0;
+/**
+ * axios module
+ * @link https://www.npmjs.com/package/axios
+ *
+ * @param cnf module initialize config
+ * @param deps module initalize dependents
+ * @returns returns of axios.create
+ */
+function Main(cnf, deps) {
+    const axiosError = (e) => (() => {
+        if (!e.response)
+            return ["no-response", e.message];
+        const r = e.response;
+        if (!r.data)
+            return [r.status, r.statusText];
+        const d = r.data;
+        if (typeof d === "string")
+            return [r.status, d];
+        return [d.code || r.status, d.message || r.statusText];
+    })().join("\t");
+    if (!cnf.axios)
+        cnf.axios = {};
+    const { loggers, retrys, retryTimes = 3, retryIntervalMS = 3000, conf } = cnf.axios;
+    const { axios, utils: { sleep }, logger, } = deps;
+    const retryAble = (fn, times, interval) => {
+        const exec = async (args, no) => {
+            try {
+                const res = await fn(...args);
+                return res;
+            }
+            catch (e) {
+                if (e.code === "ETIMEDOUT") {
+                    if (interval)
+                        await sleep(interval);
+                    if (times <= no)
+                        throw e;
+                    return exec(args, no + 1);
+                }
+                throw e;
+            }
+        };
+        return ((...args) => exec(args, 1));
+    };
+    const instance = axios.create(conf);
+    instance.origin = axios;
+    if (loggers) {
+        for (const x of loggers) {
+            if (typeof instance[x] !== "function")
+                continue;
+            const method = logger.logger(instance[x], `axios.${x}`, true, (res) => res.data, axiosError);
+            instance[x] = method;
+        }
+    }
+    if (retrys) {
+        for (const x of retrys) {
+            if (typeof instance[x] !== "function")
+                continue;
+            instance[x] = retryAble(instance[x], retryTimes, retryIntervalMS);
+        }
+    }
+    return instance;
+}
+exports.Main = Main;
+exports.Deps = ["logger", "utils", "axios"];

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

@@ -1,24 +1,37 @@
+import * as _ from "lodash";
 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 Deps = Parameters<typeof Utils>[1] & Parameters<typeof Stats>[1] & {
+    _: typeof _;
+    Sequelize: Pick<typeof Sequelize, "literal" | "and" | "fn" | "Op">;
+};
 declare type UserId = string | number;
 export interface CreatorAndClientIp {
+    /** ID of the resource creator */
     creatorId: UserId;
+    /** IP of the resource creator */
     clientIp: string;
 }
+/**
+ * Standard(CRUD) restful module, including list, add, edit, delete and statistics
+ * @param cnf Configuration information of initialization function
+ * @param deps Dependent object of the initialization function
+ * @param utils Tool function object
+ * @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>;
     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;
+        rows: any[];
     }>;
-    stats: (Model: TModel, params: Params, where: any, conf?: {
+    stats: (Model: TModel, params: Params, where?: any, conf?: {
         dimensions?: Record<string, string> | undefined;
         metrics: Record<string, string>;
         pagination?: {

package/dist/deps/rest/index.js

@@ -5,9 +5,25 @@ 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; } });
+/**
+ * Standard(CRUD) restful module, including list, add, edit, delete and statistics
+ * @param cnf Configuration information of initialization function
+ * @param deps Dependent object of the initialization function
+ * @param utils Tool function object
+ * @returns modify, add, remove, list, stats five methods
+ */
 function Main(cnf, deps, utils) {
     const { errors } = deps;
     const { findAllOpts, pickParams } = utils;
+    /**
+     * Restful modify(U of CRUD) for update a resource
+     * @param Model Model definition of resources
+     * @param model the resources will be updated
+     * @param params parameters for updating
+     * @param isAdmin Is it an administrator
+     * @param _cols Allow columns to be updated
+     * @returns The resource that has been updated
+     */
     const modify = (Model, model, params, isAdmin = false, _cols) => {
         const cols = _cols || Model.editableCols || Model.writableCols || [];
         const attr = pickParams(params, cols, Model, isAdmin);
@@ -17,6 +33,15 @@ function Main(cnf, deps, utils) {
         Object.assign(model, attr);
         return model.save();
     };
+    /**
+     * Restful add(C of CRUD) for create a resource
+     * @param Model Model definition of resources
+     * @param params parameters for updating
+     * @param isAdmin Is it an administrator
+     * @param _cols Allow columns to be set
+     * @param creatorAndClientIp creatorId and clientIp
+     * @returns The resource that has been created
+     */
     const add = async (Model, params, isAdmin = false, _cols, { creatorId, clientIp }) => {
         const cols = _cols || Model.writableCols || [];
         const attr = pickParams(params, cols, Model, isAdmin);
@@ -44,6 +69,12 @@ function Main(cnf, deps, utils) {
         return model.save();
     };
     const TRASH_OPT = Object.freeze({ fields: ["isDeleted", "deletorId"] });
+    /**
+     * Restful remove (D of CRUD) for delete a resource
+     * @param model the resources will be removed
+     * @param deletorId Operator Id
+     * @returns void OR Resources put in the recycle bin
+     */
     const remove = async (model, deletorId) => {
         // 未开启回收站，直接删除
         if (!model.isDeleted)
@@ -56,6 +87,14 @@ function Main(cnf, deps, utils) {
     };
     // count条件所需属性
     const COUNT_OPT = Object.freeze(["where", "include"]);
+    /**
+     * Restful list (R of CRUD) for list resource
+     * @param Model Model definition of resources
+     * @param params parameters for updating
+     * @param allowAttrs Allow columns to be returned
+     * @param toJSON Whether to directly return JSON formatted objects
+     * @returns findAll resource result, object propoties has count, rows
+     */
     const list = async (Model, params, allowAttrs, toJSON) => {
         const opt = findAllOpts(Model, params);
         const { _ignoreTotal } = params;
@@ -65,7 +104,7 @@ function Main(cnf, deps, utils) {
             count = await Model.count(_.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();
@@ -76,4 +115,4 @@ function Main(cnf, deps, utils) {
     return { modify, add, remove, list, stats: (0, stats_1.Stats)(cnf, deps, utils) };
 }
 exports.Main = Main;
-exports.Deps = ["errors"];
+exports.Deps = ["errors", "_", "moment", "mysql", "Sequelize"];

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

@@ -1,6 +1,13 @@
+import * as _ from "lodash";
+import * as Sequelize from "sequelize";
 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<{
+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<{
     count: number;
     rows: any;
 }>;
+export {};

package/dist/deps/rest/stats.js

@@ -1,14 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Stats = void 0;
-const _ = require("lodash");
-const Sequelize = require("sequelize");
 function Stats(cnf, deps, utils) {
     const defaultPagination = {
         maxResults: 10,
         maxStartIndex: 10000,
         maxResultsLimit: 5000,
     };
+    const { _, Sequelize } = deps;
     // 获取统计的条目数
     const statsCount = async (Model, opts, dims) => {
         if (!dims)
@@ -100,6 +99,14 @@ function Stats(cnf, deps, utils) {
         const pagination = ((_a = Model.stats) === null || _a === void 0 ? void 0 : _a.pagination) || defaultPagination;
         return utils.pageParams(pagination, params);
     };
+    /**
+     * Restful stats method
+     * @param Model Model definition of resources
+     * @param params parameters for updating
+     * @param where Initial where condition
+     * @param conf Model stats conf
+     * @returns Stats result object has two propoties, count and rows
+     */
     const statistics = async (Model, params, where, conf) => {
         if (!conf)
             throw Error("Model.stats undefined");

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

@@ -1,3 +1,7 @@
+import * as _ from "lodash";
+import * as mysql from "mysql2";
+import * as Sequelize from "sequelize";
+import * as moment from "moment";
 import { ModelExtraAtts, TModel, Params } from "./defines";
 interface Cnf {
     rest: {
@@ -5,6 +9,10 @@ interface Cnf {
     };
 }
 interface Deps {
+    _: typeof _;
+    mysql: Pick<typeof mysql, "escape">;
+    moment: typeof moment extends (...args: infer A) => infer B ? (...args: A) => B : never;
+    Sequelize: Pick<typeof Sequelize, "where" | "fn" | "col" | "literal" | "Op">;
     errors: {
         notAllowed: (...args: any[]) => Error;
         resourceDuplicateAdd: (...args: any[]) => Error;

package/dist/deps/rest/utils.js

@@ -3,11 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Utils = void 0;
 const _ = require("lodash");
 const mysql = require("mysql2");
-const Sequelize = require("sequelize");
-const moment = require("moment");
 function Utils(cnf, deps) {
     const { rest: { relativeMaxRangeDays: RELATIVE_MAX_RANGE = 100 }, } = cnf;
-    const { errors } = deps;
+    const { errors, moment, Sequelize } = deps;
     /**
      * 相对多少天的时间
      * @param Number days 相对多少天

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

@@ -1,11 +1,26 @@
-import Ajv, { Schema } from "ajv";
+import * as ajv from "ajv";
+import addFormats from "ajv-formats";
 interface Cnf {
-    schema?: ConstructorParameters<typeof Ajv>[0];
+    schema?: ConstructorParameters<typeof ajv.default>[0];
 }
-export declare function Main(cnf: Cnf): Readonly<{
+interface Deps {
+    ajv: {
+        default: typeof ajv.default;
+    };
+    ajvFormats: typeof addFormats;
+}
+declare type Schema = ajv.Schema;
+/**
+ * JSON schema validation module, based on Ajv: https://www.npmjs.com/package/ajv
+ * @param cnf Ajv initialization parameters
+ * @returns auto, validate, complie, ajv
+ */
+export declare function Main(cnf: Cnf, deps: Deps): Readonly<{
     auto: <F extends (...args: any[]) => any>(fn: F, schema: Schema[], errorFn: Function, extra: any) => (...args: Parameters<F>) => ReturnType<F>;
     validate: (schema: Schema, data: any) => boolean;
-    compile: (x: Schema) => import("ajv").ValidateFunction<unknown>;
-    ajv: Ajv;
+    compile: (schema: Schema) => ajv.ValidateFunction<unknown>;
+    /** intance of Ajv */
+    ajv: ajv.default;
 }>;
+export declare const Deps: string[];
 export {};

package/dist/deps/schema/index.js

@@ -1,19 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Main = void 0;
+exports.Deps = exports.Main = void 0;
 const util = require("util");
-const ajv_1 = require("ajv");
-const ajv_formats_1 = require("ajv-formats");
-function Main(cnf) {
-    const ajv = new ajv_1.default(cnf.schema || {});
-    (0, ajv_formats_1.default)(ajv);
-    const compile = (x) => ajv.compile(x);
+/**
+ * JSON schema validation module, based on Ajv: https://www.npmjs.com/package/ajv
+ * @param cnf Ajv initialization parameters
+ * @returns auto, validate, complie, ajv
+ */
+function Main(cnf, deps) {
+    const { ajv: { default: Ajv }, ajvFormats, } = deps;
+    const ajv = new Ajv(cnf.schema || {});
+    ajvFormats(ajv);
     /**
-     * 将函数处理为自动校验参数合法性
+     * Ajv complie function
+     * @param schema Definition of data format, Ajv specification
+     * @returns Verification function
+     */
+    const compile = (schema) => ajv.compile(schema);
+    /**
+     * Automatically process functions as functions with parameter validate
+     * @param fn Function to be processed
+     * @param schema Format definition of function parameters, Ajv specification
+     * @param errorFn Error handling function
+     * @param extra Additional information passed to the error function
+     * @returns Processed function
      */
     function auto(fn, schema, errorFn, extra) {
         if (!Array.isArray(schema)) {
-            throw Error(`方法参数定义必须是一个数组 ${util.format(schema)}`);
+            throw Error(`Method arguments must be an array: ${util.format(schema)}`);
         }
         const validators = schema.map((x) => ajv.compile(x));
         return (...args) => {
@@ -27,13 +41,23 @@ function Main(cnf) {
         };
     }
     /**
-     * 检测数据是否符合 schema 设定
+     * Verification functoin
+     * @param schema Definition of data format, Ajv specification
+     * @param data Data to be verified
+     * @returns ture or throw ajv.errors
      */
     const validate = (schema, data) => {
         if (ajv.validate(schema, data))
             return true;
         throw ajv.errors;
     };
-    return Object.freeze({ auto, validate, compile, ajv });
+    return Object.freeze({
+        auto,
+        validate,
+        compile,
+        /** intance of Ajv */
+        ajv,
+    });
 }
 exports.Main = Main;
+exports.Deps = ["ajv", "ajvFormats"];

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

@@ -4,8 +4,13 @@ interface Cnf {
         [propName: string]: Sequelize.Options;
     };
 }
-export declare function Main(cnf: Cnf): {
+interface Deps {
+    Sequelize: {
+        Sequelize: typeof Sequelize.Sequelize;
+    };
+}
+export declare function Main(cnf: Cnf, deps: Deps): {
     [propName: string]: Sequelize.Sequelize;
 };
-export declare const Deps: never[];
+export declare const Deps: string[];
 export {};

package/dist/deps/sequelize/index.js

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

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

@@ -1,20 +1,45 @@
+/** Objects to be encrypted */
 export interface Opt {
+    /** The URI does not contain the root path part */
     uri: string;
+    /** Key for signature calculation */
     key: string;
+    /** Second timestamp */
     timestamp: number;
+    /** Signature algorithm, fixed as hmacsha256 */
     signMethod: "HmacSHA256";
+    /** Signature version, fixed as 1 */
     signVersion: "1";
+    /** Method name of the request interface, internal domain method name, not HTTP verb */
     method: string;
 }
+/**
+ * API interface encryption signature algorithm module, based on sha256
+ * @returns generator And request Methods
+ */
 export declare function Main(): {
-    generator: (opt: Opt, secret: string) => string;
-    request: (uri: string, method: string, key: string, secret: string) => {
-        "x-auth-signature": string;
-        "x-auth-key": string;
-        "x-auth-method": string;
-        "x-auth-timestamp": number;
-        "x-auth-sign-method": "HmacSHA256";
-        "x-auth-sign-version": "1";
+    /**
+     * Core encryption algorithm, the result is returned as Base64 string
+     * @param opt Objects to be encrypted
+     * @param secret Calculate the private key of the signature
+     * @returns The result of the signature is in the format of Base64 string
+     */
+    generator(opt: Opt, secret: string): string;
+    /**
+     * Get all the signature encryption information required for a request
+     * @param uri The URI does not contain the root path part
+     * @param method Method name of the request interface, internal domain method name not HTTP verb
+     * @param key Key for signature calculation
+     * @param secret Calculate the private key of the signature
+     * @returns
+     */
+    request(uri: string, method: string, key: string, secret: string): {
+        readonly "x-auth-signature": string;
+        readonly "x-auth-key": string;
+        readonly "x-auth-method": string;
+        readonly "x-auth-timestamp": number;
+        readonly "x-auth-sign-method": "HmacSHA256";
+        readonly "x-auth-sign-version": "1";
     };
 };
 export declare const Deps: never[];