@domain.js/main 0.1.0 → 0.1.1

package/.husky/pre-commit

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

package/dist/Errors/index.d.ts

@@ -0,0 +1,16 @@
+export interface MyError {
+    message: string;
+    code?: string | number;
+    data?: any;
+}
+export interface ErrorFn {
+    (...args: any): MyError;
+}
+declare type RemoveReadonlyArray<T extends readonly any[]> = T extends readonly (infer A)[] ? A extends readonly [infer key, any] ? key : never : never;
+/**
+ * Convert error configuration to errors function
+ * @param defines error configuration
+ * @returns errors function
+ */
+export declare function Errors<T extends ReadonlyArray<readonly [string, string]>>(defines: T): Record<RemoveReadonlyArray<T>, ErrorFn>;
+export {};

package/dist/Errors/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Errors = void 0;
+/**
+ * Convert error configuration to errors function
+ * @param defines error configuration
+ * @returns errors function
+ */
+function Errors(defines) {
+    const errors = {};
+    for (const [code, msg] of defines) {
+        errors[code] = (...args) => {
+            if (Array.isArray(args) && args.length === 1) {
+                const [first] = args;
+                // 只有一个参数且，参数已经是一个封装后的
+                if (first && first.code)
+                    return first;
+            }
+            return Object.assign(new Error(msg), {
+                code,
+                data: args,
+            });
+        };
+    }
+    return errors;
+}
+exports.Errors = Errors;

package/dist/basic-errors.d.ts

@@ -0,0 +1 @@
+export declare const errors: Readonly<Record<"notFound" | "notAllowed" | "noAuth", import("./Errors").ErrorFn>>;

package/dist/basic-errors.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errors = void 0;
+const Errors_1 = require("./Errors");
+const defines = [
+    ["notFound", "Resource not found"],
+    ["notAllowed", "No access"],
+    ["noAuth", "Not authentication"],
+];
+exports.errors = Object.freeze((0, Errors_1.Errors)(defines));

package/dist/cfg/index.d.ts

@@ -0,0 +1,6 @@
+import { Schema } from "ajv";
+interface Cnf {
+    [propName: string]: string | undefined;
+}
+export declare function Main(object: Cnf, schema: Schema): (key: string) => string | undefined;
+export {};

package/dist/cfg/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Main = void 0;
+const _ = require("lodash");
+const ajv_1 = require("ajv");
+const ajv_formats_1 = require("ajv-formats");
+function Main(object, schema) {
+    if (typeof schema !== "object")
+        throw Error("object type isnt an object");
+    const FIELDS = new Set(Object.keys(schema.properties));
+    const ajv = new ajv_1.default({ allowUnionTypes: true, coerceTypes: true, useDefaults: true });
+    (0, ajv_formats_1.default)(ajv);
+    const validate = ajv.compile(schema);
+    const obj = _.pick(object, [...FIELDS]);
+    if (!validate(obj)) {
+        console.log("Config object data validate failed", obj);
+        console.log(JSON.stringify(validate.errors, null, 2));
+        throw Error("Config object data has error");
+    }
+    return (key) => {
+        if (!FIELDS.has(key))
+            throw Error(`Key: ${key} 未提前在 schema 中定义, 请先定义`);
+        return obj[key];
+    };
+}
+exports.Main = Main;

package/dist/defaults.d.ts

@@ -0,0 +1,102 @@
+import * as _ 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 = require("human-interval");
+import * as IORedis from "ioredis";
+import * as LRU from "lru-cache";
+import * as mysql from "mysql2";
+import * as Sequelize from "sequelize";
+import * as moment from "moment";
+import * as utils from "./utils";
+import { errors } from "./basic-errors";
+/** npm packages injection */
+export interface Defaults {
+    /**
+     * The Lodash library exported as Node.js modules.
+     * @link https://www.npmjs.com/package/lodash
+     */
+    _: typeof _;
+    /**
+     * For the creation of RFC4122 UUIDs
+     * @link https://www.npmjs.com/package/uuid
+     */
+    uuid: typeof uuid;
+    /**
+     * Ajv JSON schema validator
+     * @link https://www.npmjs.com/package/ajv
+     */
+    ajv: typeof ajv;
+    /**
+     * JSON Schema formats for Ajv
+     * @link https://www.npmjs.com/package/ajv-formats
+     */
+    ajvFormats: typeof ajvFormats;
+    /**
+     * Async is a utility module which provides straight-forward
+     * powerful functions for working with asynchronous JavaScript.
+     * @link https://www.npmjs.com/package/async
+     */
+    async: typeof async;
+    /**
+     * Promise based HTTP client for the browser and node.js
+     * @Link https://www.npmjs.com/package/axios
+     */
+    axios: typeof axios;
+    /**
+     * Node.js library for parsing and manipulating crontab instructions.
+     * It includes support for timezones and DST transitions.
+     * @link https://www.npmjs.com/package/cron-parser
+     */
+    cronParser: typeof cronParser;
+    /**
+     * Human-readable interval parser for Javascript.
+     * @link https://www.npmjs.com/package/human-interval
+     */
+    humanInterval: typeof humanInterval;
+    /**
+     * A robust, performance-focused and full-featured Redis client for Node.js.
+     * @link https://www.npmjs.com/package/ioredis
+     */
+    IORedis: typeof IORedis;
+    /**
+     * A cache object that deletes the least-recently-used items.
+     * https://www.npmjs.com/package/lru-cache
+     */
+    LRU: typeof LRU;
+    /**
+     * MySQL client for Node.js with focus on performance.
+     * Supports prepared statements, non-utf8 encodings,
+     * binary log protocol, compression, ssl much more
+     * @link https://www.npmjs.com/package/mysql2
+     */
+    mysql: typeof mysql;
+    /**
+     * Sequelize is a promise-based Node.js ORM tool for Postgres, MySQL, MariaDB,
+     *  SQLite and Microsoft SQL Server.
+     * It features solid transaction support, relations,
+     *  eager and lazy loading, read replication and more.
+     * @link https://www.npmjs.com/package/sequelize
+     */
+    Sequelize: typeof Sequelize;
+    /**
+     * A JavaScript date library for parsing, validating, manipulating, and formatting dates.
+     */
+    moment: typeof moment;
+    /**
+     * utils tools function
+     */
+    utils: typeof utils;
+    /**
+     * alias utils tools function
+     */
+    U: typeof utils;
+    /**
+     * basic errors
+     */
+    errors: typeof errors;
+}
+export declare const defaults: Defaults;

package/dist/defaults.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaults = void 0;
+const _ = require("lodash");
+const uuid = require("uuid");
+const ajv = require("ajv");
+const ajvFormats = require("ajv-formats");
+const async = require("async");
+const axios = require("axios");
+const cronParser = require("cron-parser");
+const humanInterval = require("human-interval");
+const IORedis = require("ioredis");
+const LRU = require("lru-cache");
+const mysql = require("mysql2");
+const Sequelize = require("sequelize");
+const moment = require("moment");
+const utils = require("./utils");
+const basic_errors_1 = require("./basic-errors");
+exports.defaults = {
+    _,
+    uuid,
+    ajv,
+    ajvFormats,
+    async,
+    axios,
+    cronParser,
+    humanInterval,
+    IORedis,
+    LRU,
+    mysql,
+    Sequelize,
+    moment,
+    utils,
+    U: utils,
+    errors: basic_errors_1.errors,
+};

package/dist/deps/cache/After.d.ts

@@ -1,3 +1,2 @@
-import { SetRequired } from "type-fest";
 import { CnfDef, DepsDef, PubSubDef, Cache } from "./Define";
-export declare const After: (lru: SetRequired<Partial<Cache>, "del">, cnf: CnfDef, deps: DepsDef, pubsub?: PubSubDef | undefined) => void;
+export declare const After: (lru: Pick<Cache, "del">, cnf: CnfDef, deps: Pick<DepsDef, "logger">, pubsub?: PubSubDef | undefined) => void;

package/dist/deps/cache/Before.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Before = void 0;
-const Redis = require("ioredis");
 const Before = (cnf, deps) => {
     const { cache = {}, redis } = cnf;
     const { isMulti = false } = cache;
     if (!isMulti)
         return [cnf, deps];
+    const { IORedis } = deps;
     // 如果不是多节点分部署部署，则不需要处理
     // 开启多节点分布式部署后，要通过redis广播cache的del事件，依次来保持cache的有效性
-    const pub = new Redis(redis);
-    const sub = new Redis(redis);
+    const pub = new IORedis(redis);
+    const sub = new IORedis(redis);
     return [cnf, deps, { pub, sub }];
 };
 exports.Before = Before;

package/dist/deps/cache/Define.d.ts

@@ -9,6 +9,8 @@ export interface CnfDef {
     redis?: any;
 }
 export interface DepsDef {
+    LRU: typeof LRU;
+    IORedis: typeof Redis;
     logger: {
         info(message: string, extra?: any): void;
         error(error: Error, extra?: any): void;

package/dist/deps/cache/index.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Deps = exports.Main = exports.After = exports.Before = void 0;
-const LRU = require("lru-cache");
 var Before_1 = require("./Before");
 Object.defineProperty(exports, "Before", { enumerable: true, get: function () { return Before_1.Before; } });
 var After_1 = require("./After");
@@ -9,6 +8,7 @@ Object.defineProperty(exports, "After", { enumerable: true, get: function () { r
 function Main(cnf, deps, pubsub) {
     let hits = 0; // 击中次数
     let misseds = 0; // 未击中次数
+    const { LRU } = deps;
     const lru = new LRU(cnf.cache);
     const isFunction = (arg) => typeof arg === "function";
     function caching(func, life, getKey, hit) {
@@ -47,4 +47,4 @@ function Main(cnf, deps, pubsub) {
     return cache;
 }
 exports.Main = Main;
-exports.Deps = ["logger"];
+exports.Deps = ["logger", "LRU", "IORedis"];

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

@@ -1,4 +1,8 @@
+import { someSeries } from "async";
 interface Deps {
+    async: {
+        someSeries: typeof someSeries;
+    };
     errors: {
         notAllowed(...args: any[]): Error;
     };

package/dist/deps/checker/index.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Deps = exports.Main = void 0;
-const async = require("async");
 function Main(cnf, deps) {
-    const { errors } = deps;
+    const { async, errors } = deps;
     /** 检测两个值是否相等 */
     const equal = (v1, v2) => v1 === v2;
     /** 判断判断，一次执行数组里的函数 遇到成功的立刻停止，否则抛出信息 */
@@ -22,4 +21,4 @@ function Main(cnf, deps) {
     };
 }
 exports.Main = Main;
-exports.Deps = ["errors"];
+exports.Deps = ["errors", "async"];

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

@@ -1,3 +1,6 @@
+import * as _ from "lodash";
+import * as async from "async";
+import { v4 } from "uuid";
 interface Cnf {
     cia?: {
         concurrency?: number;
@@ -5,6 +8,11 @@ interface Cnf {
     };
 }
 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;

package/dist/deps/cia/index.js

@@ -1,12 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Deps = exports.Main = void 0;
-const _ = require("lodash");
-const async = require("async");
-const uuid_1 = require("uuid");
 const errors_1 = require("./errors");
 function Main(cnf, deps) {
-    const { logger, redis, graceful, U: { tryCatchLog }, } = 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";
@@ -252,7 +249,7 @@ function Main(cnf, deps) {
         const { validator } = registeds[name];
         if (validator)
             validator(data);
-        const id = (0, uuid_1.v4)();
+        const id = uuid();
         queue.push({ id, name, data, callback });
         updatePendings(registeds[name]);
         logger.info(`cia.submit\t${id}`, { name, data });
@@ -288,4 +285,4 @@ function Main(cnf, deps) {
     return { isExiting, isExited, checkReady, getStats, getUnlinks, regist, link, submit, setFn };
 }
 exports.Main = Main;
-exports.Deps = ["logger", "utils", "redis", "graceful"];
+exports.Deps = ["_", "async", "logger", "utils", "redis", "graceful", "uuid"];

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

@@ -1,3 +1,5 @@
+import * as cronParser from "cron-parser";
+import human = require("human-interval");
 interface Cnf {
     cron?: {
         tz?: string;
@@ -12,6 +14,8 @@ interface callbackArg {
     cronJob: [Error | null, any, number];
 }
 interface Deps {
+    cronParser: typeof cronParser;
+    humanInterval: typeof human;
     cia: {
         regist: (name: string, validator: any, waiters: waiter[]) => void;
         submit: (name: string, times: number, callback: (arg: callbackArg) => void) => void;

package/dist/deps/cron/index.js

@@ -1,12 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Deps = exports.Main = void 0;
-const parser = require("cron-parser");
-const human = require("human-interval");
 function Main(cnf, deps) {
     const { cron = {} } = cnf;
     const ciaTaskType = "cronJob";
-    const { cia } = deps;
+    const { cia, humanInterval: human, cronParser: parser } = deps;
     const { tz = "Asia/Shanghai" } = cron;
     // 注册信息
     const registed = {};
@@ -95,4 +93,4 @@ function Main(cnf, deps) {
     return { regist, start, getStats };
 }
 exports.Main = Main;
-exports.Deps = ["cia"];
+exports.Deps = ["cia", "humanInterval", "cronParser"];

package/dist/deps/defines.d.ts

@@ -1,5 +1,4 @@
 import * as aes from "./aes";
-import * as axios from "./axios";
 import * as cache from "./cache";
 import * as checker from "./checker";
 import * as cia from "./cia";
@@ -10,13 +9,13 @@ import * as hash from "./hash";
 import * as logger from "./logger";
 import * as parallel from "./parallel";
 import * as redis from "./redis";
+import * as request from "./request";
 import * as rest from "./rest";
 import * as schema from "./schema";
 import * as sequelize from "./sequelize";
 import * as signer from "./signer";
 declare const _default: {
     aes: typeof aes;
-    axios: typeof axios;
     cache: typeof cache;
     checker: typeof checker;
     cia: typeof cia;
@@ -27,6 +26,7 @@ declare const _default: {
     logger: typeof logger;
     parallel: typeof parallel;
     redis: typeof redis;
+    request: typeof request;
     rest: typeof rest;
     schema: typeof schema;
     sequelize: typeof sequelize;

package/dist/deps/defines.js

@@ -1,7 +1,6 @@
 "use strict";
 // domain-cli 自动生成
 const aes = require("./aes");
-const axios = require("./axios");
 const cache = require("./cache");
 const checker = require("./checker");
 const cia = require("./cia");
@@ -12,13 +11,13 @@ const hash = require("./hash");
 const logger = require("./logger");
 const parallel = require("./parallel");
 const redis = require("./redis");
+const request = require("./request");
 const rest = require("./rest");
 const schema = require("./schema");
 const sequelize = require("./sequelize");
 const signer = require("./signer");
 module.exports = {
     aes,
-    axios,
     cache,
     checker,
     cia,
@@ -29,6 +28,7 @@ module.exports = {
     logger,
     parallel,
     redis,
+    request,
     rest,
     schema,
     sequelize,

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

@@ -0,0 +1 @@
+export declare const errors: Readonly<Record<"notFound" | "notAllowed" | "noAuth", import("../../errors").ErrorFn>>;

package/dist/deps/errors/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errors = void 0;
+const errors_1 = require("../../errors");
+const defines = [
+    ["notFound", "Resource not found"],
+    ["notAllowed", "No access"],
+    ["noAuth", "Not authentication"],
+];
+exports.errors = Object.freeze((0, errors_1.Errors)(defines));

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

@@ -1,3 +1,5 @@
+import * as _ from "lodash";
+import { v4 } from "uuid";
 interface Cnf {
     logger: {
         clientId: string;
@@ -6,9 +8,18 @@ interface Cnf {
         ignoreErrors?: [string | number];
     };
 }
-export declare function Main(cnf: Cnf): {
+interface Deps {
+    _: {
+        memoize: typeof _.memoize;
+    };
+    uuid: {
+        v4: typeof v4;
+    };
+}
+export declare function Main(cnf: Cnf, deps: Deps): {
     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 declare const Deps: string[];
 export {};

package/dist/deps/logger/index.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Main = void 0;
+exports.Deps = 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) {
+function Main(cnf, deps) {
     const { logger: { errorLogPath, infoLogPath, ignoreErrors, clientId }, } = cnf;
+    const { _, uuid: { v4: uuid }, } = deps;
     const makeDir = _.memoize((dir) => {
         if (!fs.existsSync(dir))
             fs.mkdirSync(dir);
@@ -61,7 +60,7 @@ function Main(cnf) {
         if (isAsync) {
             const handler = {
                 async apply(fn, me, args) {
-                    const callId = (0, uuid_1.v4)();
+                    const callId = uuid();
                     try {
                         info(`Begin: ${name}\t${callId}\t${argsHandler(args)}`);
                         const startedAt = Date.now();
@@ -79,7 +78,7 @@ function Main(cnf) {
         }
         const handler = {
             apply(fn, me, args) {
-                const callId = (0, uuid_1.v4)();
+                const callId = uuid();
                 try {
                     info(`Begin: ${name}\t${callId}\t${argsHandler(args)}`);
                     const startedAt = Date.now();
@@ -98,3 +97,4 @@ function Main(cnf) {
     return { error, info, logger };
 }
 exports.Main = Main;
+exports.Deps = ["_", "uuid"];

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

@@ -1,25 +1,37 @@
+import { eachLimit, forever, whilst } from "async";
 import { Redis } from "ioredis";
 import { Main as Logger } from "../logger";
 import { Main as Graceful } from "../graceful";
-import * as utils from "../../utils";
 interface Cnf {
     parallel: {
+        /** Record the redis key prefix of the concurrency control lock */
         key: string;
+        /** Default error handler function */
         defaultErrorFn(path: string, minMS?: number): void;
+        /** How long does the reset lock expire (millisecond), default is 100 * 1000 (100 seconds) */
+        resetExpireIntervalMS?: number;
+        /** Maximum validity period of lock in redis storage (seconds), default is 300 */
+        maxExpireSeconds?: number;
     };
 }
 interface Deps {
+    /** logger mudule */
     logger: {
         info: ReturnType<typeof Logger>["info"];
         error: ReturnType<typeof Logger>["error"];
     };
+    /** gracefule module */
     graceful: {
         exit: ReturnType<typeof Graceful>["exit"];
     };
-    utils: {
-        sleep: typeof utils.sleep;
-    };
+    /** redis instance */
     redis: Pick<Redis, "get" | "set" | "del" | "expire" | "exists">;
+    /** async package */
+    async: {
+        eachLimit: typeof eachLimit;
+        whilst: typeof whilst;
+        forever: typeof forever;
+    };
 }
 export interface Option {
     path: string;
@@ -29,6 +41,12 @@ export interface Option {
     needWaitMS?: number;
     neverReturn?: boolean;
 }
+/**
+ * Parallel control module
+ * @param cnf Module initialization configuration parameters
+ * @param deps Module initialization dependency
+ * @returns Parallel control function
+ */
 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 {};