@domain.js/main 0.1.0

package/.eslintrc.js

@@ -0,0 +1,67 @@
+module.exports = {
+  parser: "@typescript-eslint/parser",
+  plugins: ["@typescript-eslint"],
+  extends: ["airbnb", "eslint:recommended", "plugin:@typescript-eslint/recommended"],
+  ignorePatterns: [".eslintrc.js"],
+  root: true,
+  env: {
+    es6: true,
+    node: true,
+    jest: true,
+  },
+  settings: {
+    react: {
+      version: "999.999.999",
+    },
+  },
+  rules: {
+    "nonblock-statement-body-position": "off",
+    "operator-linebreak": ["error", "after"],
+    "prefer-destructuring": ["error", { object: true, array: true }],
+    indent: ["error", 2],
+    "no-use-before-define": ["error", { functions: true, classes: true, variables: true }],
+    "no-param-reassign": 0,
+    "no-continue": 0,
+    "no-console": 0,
+    "no-debugger": 1,
+    "no-var": 1,
+    semi: ["error", "always"],
+    "no-trailing-spaces": "error",
+    "eol-last": 1,
+    "no-underscore-dangle": 0,
+    "no-empty": "error",
+    "no-loop-func": "error",
+    "no-bitwise": "off", // "error",
+    quotes: ["error", "double"],
+    "comma-dangle": ["error", "only-multiline"],
+    "arrow-parens": ["error", "always"],
+    "object-curly-newline": 0,
+    "function-paren-newline": 0,
+    "implicit-arrow-linebreak": 0,
+    curly: 0,
+    "no-mixed-operators": "error",
+    "no-restricted-syntax": 0,
+    "no-lone-blocks": "error",
+    "lines-between-class-members": "off",
+    yoda: "error",
+    "no-plusplus": 0,
+    "import/export": 0,
+    "no-cond-assign": "error",
+    "no-shadow": 0,
+    camelcase: 0,
+    "prefer-destructuring": 0,
+    "import/prefer-default-export": "off",
+    "newline-per-chained-call": 0,
+    "@typescript-eslint/interface-name-prefix": "off",
+    "@typescript-eslint/explicit-function-return-type": "off",
+    "@typescript-eslint/explicit-module-boundary-types": "off",
+    "@typescript-eslint/no-explicit-any": "off",
+    "@typescript-eslint/no-namespace": 0,
+    "@typescript-eslint/ban-types": 0,
+    "import/export": 0,
+    "import/no-unresolved": 0,
+    "import/extensions": 0,
+    "@typescript-eslint/no-var-requires": 0,
+    "@typescript-eslint/no-this-alias": 0,
+  },
+};

package/.husky/pre-commit

@@ -0,0 +1,7 @@
+#!/bin/sh
+if [ ! -f "$(dirname "$0")/_/husky.sh" ]; then
+  npx husky install
+fi
+. "$(dirname "$0")/_/husky.sh"
+
+npm run lint-staged && npm run build 

package/.test/test.ts

@@ -0,0 +1,13 @@
+interface Err extends Error {
+  code?: number | string;
+  data?: any;
+  [propName: string]: any;
+}
+
+const e: Err = {
+  name: "hello",
+  message: "error message",
+  config: new Date(),
+};
+
+const e1: Error = e;

package/.test/test2.js

@@ -0,0 +1,45 @@
+let times = 0;
+const obj = {
+  fn1() {
+    console.log("Apply fn1, times: %d", times += 1);
+  }
+}
+
+let count = 0;
+const handler = {
+  get(target, key) {
+    console.log("Proxy new function times: %d", count += 1);
+    return (...args) => {
+      Reflect.apply(target[key], target, args);
+    };
+  },
+};
+
+const proxyObj = new Proxy(obj, handler);
+
+proxyObj.fn1();
+proxyObj.fn1();
+proxyObj.fn1();
+proxyObj.fn1();
+proxyObj.fn1();
+
+let t2 = 0;
+const obj2 = {
+  fn2(...args) {
+    console.log("fn2 apply times: %d, args: %o", t2 += 1, args);
+  }
+};
+
+const handler2 = {
+  apply(target, me, args) {
+    console.log("proxy apply me: %o, args: %o", me, args);
+    Reflect.apply(target, me, args);
+  }
+};
+
+obj2.fn2 = new Proxy(obj2.fn2, handler2);
+obj2.fn2(1, 2, 3);
+obj2.fn2();
+obj2.fn2();
+obj2.fn2();
+obj2.fn2();

package/.travis.yml

@@ -0,0 +1,8 @@
+language: node_js
+node_js:
+  - "12"
+  - "14"
+  - "16"
+
+after_success:
+  - codecov

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "typescript.tsdk": "node_modules/typescript/lib"
+}

package/README.md

@@ -0,0 +1,6 @@
+# @domain.js/main DDD 领域驱动开发框架
+
+[![Build status](https://travis-ci.com/domain-js/main.svg?branch=master)](https://travis-ci.com/domain-js/main)
+[![codecov](https://codecov.io/gh/domain-js/main/branch/master/graph/badge.svg)](https://codecov.io/gh/domain-js/main)
+
+集成了常见的功能模块，采用依赖注入的模式组织项目代码

package/dist/cli/index.d.ts

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

package/dist/cli/index.js

@@ -0,0 +1,221 @@
+#! /usr/bin/env ts-node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const path = require("path");
+const readline = require("readline");
+const child_process_1 = require("child_process");
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true,
+    prompt: "> ",
+    removeHistoryDuplicates: true,
+});
+rl.setPrompt("> ");
+const _require = require;
+const showMessage = (msg, exit) => {
+    rl.write(`${msg}\n`);
+    if (exit != null)
+        process.exit(exit);
+    rl.setPrompt("> ");
+};
+const file2Module = (file) => file.replace(/(-\w)/g, (m) => m[1].toUpperCase());
+const filePath2Var = (_path) => file2Module(_path.replace(/[/.]+/g, "-"));
+const codeStyleFormat = (targetFile) => new Promise((resolve, reject) => {
+    (0, child_process_1.exec)(`prettier -w ${targetFile} && eslint --fix ${targetFile}`, (err) => {
+        if (err)
+            reject(err);
+        else
+            resolve();
+    });
+});
+const makeDefineFile = async (modules, targetFile, isTS) => {
+    const content = ["// domain-cli 自动生成"];
+    const _exports = [];
+    for (let i = 0; i < modules.length; i += 1) {
+        const name = modules[i];
+        const variable = filePath2Var(name);
+        if (isTS) {
+            content.push(`import * as ${variable} from "./${name}"`);
+        }
+        else {
+            content.push(`const ${variable} = require("./${name}")`);
+        }
+        _exports.push(`"${file2Module(name)}": ${variable},`);
+    }
+    // 处理导出
+    content.push("\n");
+    if (isTS) {
+        content.push("export = {");
+    }
+    else {
+        content.push("module.exports = {");
+    }
+    for (const x of _exports)
+        content.push(x);
+    content.push("};");
+    fs.writeFileSync(targetFile, content.join("\n"));
+    await codeStyleFormat(targetFile);
+    console.log(`Completed: ${targetFile}`);
+};
+const checkHookExport = (_dir) => {
+    for (const hook of ["Before", "After"]) {
+        const TSFile = path.resolve(_dir, `${hook}.ts`);
+        const JSFile = path.resolve(_dir, `${hook}.js`);
+        const Main = _require(_dir);
+        if (fs.existsSync(JSFile)) {
+            const Hook = _require(JSFile);
+            if (Main[hook] !== Hook)
+                throw Error(`${hook} 定义和 export 不一致 ${_dir}`);
+        }
+        if (fs.existsSync(TSFile)) {
+            const { [hook]: Hook } = _require(TSFile);
+            if (Main[hook] !== Hook)
+                throw Error(`${hook} 定义和 export 不一致 ${_dir}`);
+        }
+    }
+};
+const loadDeps = async (rootDir = process.cwd(), ext = "js") => {
+    const isTS = ext === "ts";
+    const modules = [];
+    const dir = path.resolve(rootDir, "src/deps/");
+    for (const x of fs.readdirSync(dir)) {
+        // 忽略隐藏目录
+        if (x[0] === ".")
+            continue;
+        const _dir = path.resolve(dir, x);
+        const stat = fs.statSync(_dir);
+        // 非目录忽略，模块必须是目录
+        if (!stat.isDirectory())
+            continue;
+        checkHookExport(_dir);
+        modules.push(x);
+    }
+    // 按字典排序，后续有变动的时候不容易冲突
+    const targetFile = path.resolve(rootDir, `src/deps/defines.${ext}`);
+    await makeDefineFile(modules.sort(), targetFile, isTS);
+};
+const checkService = (_dir) => {
+    const TSFile = path.resolve(_dir, "index.ts");
+    const JSFile = path.resolve(_dir, "index.js");
+    if (!fs.existsSync(TSFile) && !fs.existsSync(JSFile)) {
+        throw Error("目录下缺少index.ts 或 index.js 文件");
+    }
+};
+const loadServices = async (rootDir = process.cwd(), ext = "js") => {
+    const isTS = ext === "ts";
+    const modules = [];
+    const dir = path.resolve(rootDir, "src/services/");
+    for (const x of fs.readdirSync(dir)) {
+        // 忽略隐藏目录, 忽略私有目录
+        if (x[0] === "." || x[0] === "_")
+            continue;
+        const _dir = path.resolve(dir, x);
+        const stat = fs.statSync(_dir);
+        // 非目录忽略，模块必须是目录
+        if (!stat.isDirectory())
+            continue;
+        checkService(_dir);
+        modules.push(x);
+    }
+    // 按字典排序，后续有变动的时候不容易冲突
+    const targetFile = path.resolve(rootDir, `src/services/defines.${ext}`);
+    await makeDefineFile(modules.sort(), targetFile, isTS);
+};
+const deepLoadDir = (root, parent, files = []) => {
+    const paths = {};
+    const dir = path.resolve(root, parent);
+    for (const x of fs.readdirSync(dir)) {
+        // 忽略隐藏目录
+        if (x[0] === ".")
+            continue;
+        const file = path.resolve(dir, x);
+        const stat = fs.statSync(file);
+        const { name, ext } = path.parse(x);
+        const relativeFilePath = `./${path.join(parent, name)}`;
+        const moduleName = file2Module(name);
+        // 如果是文件则记录
+        if (stat.isFile()) {
+            if (ext === ".ts") {
+                const JSFile = path.resolve(dir, `${name}.js`);
+                // 对应的js文件存在，则ts文件忽略
+                if (fs.existsSync(JSFile))
+                    continue;
+                // 对应的js文件不存在，抛出异常提示用户要先编译
+                throw Error(`请先编译ts文件: ${file}`);
+            }
+            files.push(relativeFilePath);
+            paths[moduleName] = relativeFilePath;
+            continue;
+        }
+        if (stat.isDirectory()) {
+            paths[moduleName] = deepLoadDir(root, relativeFilePath, files);
+        }
+    }
+    return paths;
+};
+const deepLoadModule = async (rootDir, targetFile) => {
+    const files = [];
+    const paths = deepLoadDir(rootDir, "./", files);
+    const { ext } = path.parse(targetFile);
+    // 按字典排序，后续有变动的时候不容易冲突
+    files.sort();
+    const relative = path.relative(path.dirname(targetFile), rootDir);
+    const isTS = ext === ".ts";
+    const content = ["// domain-cli 自动生成"];
+    for (let i = 0; i < files.length; i += 1) {
+        const name = files[i];
+        const _path = `./${path.join(relative, name)}`;
+        const variable = filePath2Var(name);
+        if (isTS) {
+            content.push(`import * as ${variable} from "${_path}"`);
+        }
+        else {
+            content.push(`const ${variable} = require("${_path}")`);
+        }
+    }
+    // 处理导出
+    content.push("\n");
+    let _exports = JSON.stringify(paths, null, 2);
+    for (let i = 0; i < files.length; i += 1) {
+        _exports = _exports.replace(`"${files[i]}"`, filePath2Var(files[i]));
+    }
+    if (isTS) {
+        content.push(`export = ${_exports}`);
+    }
+    else {
+        content.push(`module.exports = ${_exports}`);
+    }
+    fs.writeFileSync(targetFile, content.join("\n"));
+    await codeStyleFormat(targetFile);
+    console.log(`Completed: ${targetFile}`);
+};
+const actions = { loadDeps, loadServices, deepLoadModule };
+const main = async (command) => {
+    const action = actions[command];
+    if (!action) {
+        const msg = `${action} 不存在该指令，只支持 ${Object.keys(actions)}`;
+        return showMessage(msg, 0);
+    }
+    try {
+        await action(...process.argv.slice(3));
+    }
+    catch (e) {
+        showMessage(e instanceof Error ? e.message : e, 1);
+    }
+    return process.exit(0);
+};
+main(process.argv[2]);
+process.on("uncaughtException", (error) => {
+    console.error("[%s]: uncaughtException", new Date());
+    console.error(error);
+});
+process.on("unhandledRejection", (reason, p) => {
+    console.error("[%s]: unhandledRejection", new Date());
+    console.error(reason, p);
+});
+process.on("rejectionHandled", (error) => {
+    console.error("[%s]: rejectionHandled", new Date());
+    console.error(error);
+});

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

@@ -0,0 +1,4 @@
+export declare function Main(): Readonly<{
+    encrypt: (message: string, key: string) => string;
+    decrypt: (message: string, key: string) => string;
+}>;

package/dist/deps/aes/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Main = void 0;
+const cryptojs = require("crypto-js/core");
+const AES = require("crypto-js/aes");
+function Main() {
+    // aes-256-cbc encrypt
+    const encrypt = (message, key) => AES.encrypt(message, key).toString();
+    // aes-256-cbc decrypt
+    const decrypt = (message, key) => AES.decrypt(message, key).toString(cryptojs.enc.Utf8);
+    return Object.freeze({
+        encrypt,
+        decrypt,
+    });
+}
+exports.Main = Main;

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

@@ -0,0 +1,22 @@
+import { AxiosInstance } from "axios";
+import { Main as Logger } from "../logger";
+import * as utils from "../../utils";
+declare type VERBS = "post" | "get" | "put" | "delete";
+interface Cnf {
+    axios: {
+        loggers?: VERBS[];
+        retrys?: VERBS[];
+        retryTimes?: number;
+        retryIntervalMS?: number;
+        conf?: {};
+    };
+}
+interface Deps {
+    logger: ReturnType<typeof Logger>;
+    utils: typeof utils;
+}
+export declare function Main(cnf: Cnf, deps: Deps): AxiosInstance & {
+    origin?: import("axios").AxiosStatic | undefined;
+};
+export declare const Deps: string[];
+export {};

package/dist/deps/axios/index.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deps = exports.Main = void 0;
+const axios_1 = require("axios");
+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 || d];
+    })().join("\t");
+    if (!cnf.axios)
+        cnf.axios = {};
+    const { loggers, retrys, retryTimes = 3, retryIntervalMS = 3000, conf } = cnf.axios;
+    const { 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_1.default.create(conf);
+    instance.origin = axios_1.default;
+    if (loggers) {
+        for (const x of loggers) {
+            const method = logger.logger(instance[x], `axios.${x}`, true, (res) => res.data, axiosError);
+            instance[x] = method;
+        }
+    }
+    if (retrys) {
+        for (const x of retrys) {
+            instance[x] = retryAble(instance[x], retryTimes, retryIntervalMS);
+        }
+    }
+    return instance;
+}
+exports.Main = Main;
+exports.Deps = ["logger", "utils"];

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

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

package/dist/deps/cache/After.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.After = void 0;
+const After = (lru, cnf, deps, pubsub) => {
+    const { cache = {} } = cnf;
+    const { isMulti = false, delSignalChannel = "LRU_DEL_SIGNAL_CHANNEL" } = cache;
+    // 如果不是多节点分部署部署，则不需要处理
+    // 开启多节点分布式部署后，要通过redis广播cache的del事件，以此来保持cache的有效性
+    if (!isMulti || !pubsub)
+        return;
+    const { logger } = deps;
+    const { pub, sub } = pubsub;
+    sub.subscribe(delSignalChannel, (err, count) => {
+        logger.info("cache.redis.subscribe", { chanels: delSignalChannel, count });
+        if (err)
+            return logger.error(err);
+        return logger.info(`cache.redis.subscribe succeed, channel count: ${count}`);
+    });
+    const del = lru.del.bind(lru);
+    lru.del = (key) => {
+        pub.publish(delSignalChannel, key);
+    };
+    sub.on("message", async (channel, key) => {
+        if (channel === delSignalChannel)
+            del(key);
+    });
+};
+exports.After = After;

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

@@ -0,0 +1,4 @@
+import { CnfDef, DepsDef, PubSubDef } from "./Define";
+declare type returns = [CnfDef, DepsDef, PubSubDef?];
+export declare const Before: (cnf: CnfDef, deps: DepsDef) => returns;
+export {};

package/dist/deps/cache/Before.js

@@ -0,0 +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];
+    // 如果不是多节点分部署部署，则不需要处理
+    // 开启多节点分布式部署后，要通过redis广播cache的del事件，依次来保持cache的有效性
+    const pub = new Redis(redis);
+    const sub = new Redis(redis);
+    return [cnf, deps, { pub, sub }];
+};
+exports.Before = Before;

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

@@ -0,0 +1,28 @@
+import * as LRU from "lru-cache";
+import * as Redis from "ioredis";
+import { SetRequired } from "type-fest";
+export interface CnfDef {
+    cache?: {
+        isMulti?: boolean;
+        delSignalChannel?: string;
+    } & LRU.Options<string, string>;
+    redis?: any;
+}
+export interface DepsDef {
+    logger: {
+        info(message: string, extra?: any): void;
+        error(error: Error, extra?: any): void;
+    };
+}
+export interface PubSubDef {
+    pub: SetRequired<Partial<Redis.Redis>, "publish">;
+    sub: SetRequired<Partial<Redis.Redis>, "on" | "subscribe">;
+}
+export interface Cache extends LRU<string, string> {
+    caching: <T extends (...args: any[]) => Promise<any>>(func: T, life: number, getKey: (...args: Parameters<T>) => string, hit?: (hited: boolean) => void) => T;
+    hitCount: () => {
+        hits: number;
+        misseds: number;
+    };
+    needToBroad: boolean;
+}

package/dist/deps/cache/Define.js

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

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

@@ -0,0 +1,5 @@
+import { Cache, CnfDef, DepsDef, PubSubDef } from "./Define";
+export { Before } from "./Before";
+export { After } from "./After";
+export declare function Main(cnf: CnfDef, deps: DepsDef, pubsub?: PubSubDef): Cache;
+export declare const Deps: string[];

package/dist/deps/cache/index.js

@@ -0,0 +1,50 @@
+"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");
+Object.defineProperty(exports, "After", { enumerable: true, get: function () { return After_1.After; } });
+function Main(cnf, deps, pubsub) {
+    let hits = 0; // 击中次数
+    let misseds = 0; // 未击中次数
+    const lru = new LRU(cnf.cache);
+    const isFunction = (arg) => typeof arg === "function";
+    function caching(func, life, getKey, hit) {
+        if (!isFunction(func))
+            throw Error("The first argument must be a function");
+        if (!Number.isInteger(life) || life < 1)
+            throw Error("The second argument must be a number and great then 0");
+        if (!isFunction(getKey))
+            throw Error("The third argument must be a function");
+        if (hit && !isFunction(hit))
+            throw Error("The fourth argument must be a function");
+        const wrapped = async (...args) => {
+            const key = getKey(...args);
+            if (lru.has(key)) {
+                hits += 1;
+                if (hit)
+                    hit(true);
+                return lru.get(key);
+            }
+            if (hit)
+                hit(false);
+            misseds += 1;
+            const res = await func(...args);
+            lru.set(key, res, life);
+            return res;
+        };
+        return wrapped;
+    }
+    const hitCount = () => ({ hits, misseds });
+    const needToBroad = Boolean(pubsub);
+    const cache = Object.assign(lru, {
+        caching,
+        hitCount,
+        needToBroad,
+    });
+    return cache;
+}
+exports.Main = Main;
+exports.Deps = ["logger"];

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

@@ -0,0 +1,11 @@
+interface Deps {
+    errors: {
+        notAllowed(...args: any[]): Error;
+    };
+}
+export declare function Main(cnf: {}, deps: Deps): {
+    equal: (v1: any, v2: any) => boolean;
+    privacy: (fns: [Function, ...any[]][], error?: Error) => Promise<void>;
+};
+export declare const Deps: string[];
+export {};

package/dist/deps/checker/index.js

@@ -0,0 +1,25 @@
+"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 equal = (v1, v2) => v1 === v2;
+    /** 判断判断，一次执行数组里的函数 遇到成功的立刻停止，否则抛出信息 */
+    const PRIVACY_DEFAULT_ERROR = errors.notAllowed("权限不足");
+    const privacy = async (fns, error = PRIVACY_DEFAULT_ERROR) => {
+        const passed = (await async.someSeries(fns, async ([fn, ...args]) => {
+            const ret = await fn(...args);
+            return ret;
+        }));
+        if (!passed)
+            throw error;
+    };
+    return {
+        equal,
+        privacy,
+    };
+}
+exports.Main = Main;
+exports.Deps = ["errors"];