@domain.js/main 0.1.0

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

@@ -0,0 +1,20 @@
+export interface Opt {
+    uri: string;
+    key: string;
+    timestamp: number;
+    signMethod: "HmacSHA256";
+    signVersion: "1";
+    method: string;
+}
+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";
+    };
+};
+export declare const Deps: never[];

package/dist/deps/signer/index.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deps = exports.Main = void 0;
+const crypto = require("crypto");
+function Main() {
+    const generator = (opt, secret) => {
+        const string = Object.keys(opt)
+            .map((k) => `${k}=${encodeURIComponent(opt[k])}`)
+            .sort()
+            .join("&");
+        const h = crypto.createHmac("sha256", secret);
+        return h.update(string).digest("base64");
+    };
+    const request = (uri, method, key, secret) => {
+        const opt = {
+            uri,
+            key,
+            timestamp: (Date.now() / 1000) | 0,
+            signMethod: "HmacSHA256",
+            signVersion: "1",
+            method,
+        };
+        const signature = generator(opt, secret);
+        return {
+            "x-auth-signature": signature,
+            "x-auth-key": key,
+            "x-auth-method": method,
+            "x-auth-timestamp": opt.timestamp,
+            "x-auth-sign-method": opt.signMethod,
+            "x-auth-sign-version": opt.signVersion,
+        };
+    };
+    return { generator, request };
+}
+exports.Main = Main;
+exports.Deps = [];

package/dist/dm/dm.d.ts

@@ -0,0 +1,21 @@
+import * as lodash from "lodash";
+interface ModuleInterface {
+    Main?: (...args: any[]) => any;
+    main?: (...args: any[]) => any;
+    Deps?: string[];
+    Before?: (...args: any[]) => any;
+    After?: (...args: any[]) => void;
+}
+declare type ModuleFn = (((...args: any[]) => any) | {}) & ModuleInterface;
+export declare type Merge<T extends {}, D extends {
+    [k in string]: ModuleFn;
+}> = T & {
+    [K in keyof D]: ReturnType<D[K]["Main"] extends (...args: any) => any ? D[K]["Main"] : D[K]["main"] extends (...args: any) => any ? D[K]["main"] : D[K] extends (...args: any) => any ? D[K] : (...args: any) => any>;
+};
+export declare function DM(_: typeof lodash): {
+    exec: <Args extends any[], BeforeFn extends (...args: Args) => any[], MainFn extends (...args: ReturnType<BeforeFn>) => any, AfterFn extends (main: ReturnType<MainFn>, ...args: ReturnType<BeforeFn>) => void>(Main: MainFn, Before: BeforeFn | undefined, After: AfterFn | undefined, _args?: Args) => ReturnType<MainFn>;
+    auto: <Modules extends {
+        [x: string]: ModuleFn;
+    }, Deps extends object, Args_1 extends any[]>(modules: Modules, deps: Deps, args: Args_1) => Merge<Deps, Modules>;
+};
+export {};

package/dist/dm/dm.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DM = void 0;
+function DM(_) {
+    function exec(Main, Before = ((...args) => args), After, _args = []) {
+        const args = Before(..._args);
+        const main = Main(...args);
+        if (typeof After === "function")
+            After(main, ...args);
+        return main;
+    }
+    function auto(modules, deps, args) {
+        // 获取全部即将初始化的模块名称，此时的 modules 是扁平的一级结构
+        const names = new Set(Object.keys(modules));
+        while (names.size) {
+            // 记录此次迭代有多少个模块被排序了，如果某次迭代被排序的模块数量为0，
+            // 那就要抛出异常了，说明依赖指定有问题，永远都不可能排序完毕
+            let count = 0;
+            /** 默认挂载函数 */
+            const plugin = (name) => {
+                const Module = modules[name];
+                const Main = Module.Main || Module.main || Module;
+                if (typeof Main !== "function")
+                    throw Error("Main is not a function");
+                const Before = Module.Before || ((...args) => args);
+                const After = Module.After;
+                if (After && typeof After !== "function")
+                    throw Error("After is not a function");
+                const main = exec(Main, Before, After, args);
+                if (_.has(deps, name))
+                    throw Error(`Name ${name} duplicate`);
+                _.set(deps, name, main);
+                names.delete(name);
+                count += 1;
+            };
+            for (const x of names) {
+                const { Deps } = modules[x];
+                if (!Array.isArray(Deps) || !Deps.length) {
+                    plugin(x);
+                    continue;
+                }
+                if (Deps.every((d) => _.has(deps, d)))
+                    plugin(x);
+            }
+            if (count === 0) {
+                const lacks = [];
+                for (const x of names) {
+                    lacks.push(`${x}: ${_.filter(modules[x].Deps, (d) => !_.has(deps, d)).join(",")}`);
+                }
+                throw Error(`Deps defined conflict, ${lacks.join(";")}`);
+            }
+        }
+        return deps;
+    }
+    return { exec, auto };
+}
+exports.DM = DM;

package/dist/dm/index.d.ts

@@ -0,0 +1,12 @@
+interface ModuleInterface {
+    Main: (...args: any[]) => any;
+    Deps?: string[];
+    Before?: (...args: any[]) => any;
+    After?: (...args: any[]) => void;
+}
+declare type ModuleFn = (((...args: any[]) => any) | {}) & ModuleInterface;
+export declare function exec<Args extends any[], BeforeFn extends (...args: Args) => any[], MainFn extends (...args: ReturnType<BeforeFn>) => any, AfterFn extends (main: ReturnType<MainFn>, ...args: ReturnType<BeforeFn>) => void>(Main: MainFn, Before?: BeforeFn, After?: AfterFn | undefined, _args?: Args): ReturnType<MainFn>;
+export declare function auto<Modules extends {
+    [k in string]: ModuleFn;
+}, Deps extends object, Args extends any[]>(modules: Modules, deps: Deps, args: Args): { [k in keyof Modules]: ReturnType<Modules[k]["Main"]>; };
+export {};

package/dist/dm/index.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auto = exports.exec = void 0;
+const _ = require("lodash");
+function exec(Main, Before = ((...args) => args), After = undefined, _args = []) {
+    const args = Before(..._args);
+    const main = Main(...args);
+    if (typeof After === "function")
+        After(main, ...args);
+    return main;
+}
+exports.exec = exec;
+function auto(modules, deps, args) {
+    // 获取全部即将初始化的模块名称，此时的 modules 是扁平的一级结构
+    const names = new Set(Object.keys(modules));
+    while (names.size) {
+        // 记录此次迭代有多少个模块被排序了，如果某次迭代被排序的模块数量为0，
+        // 那就要抛出异常了，说明依赖指定有问题，永远都不可能排序完毕
+        let count = 0;
+        /** 默认挂载函数 */
+        const plugin = (name) => {
+            const Module = modules[name];
+            const Main = Module.Main;
+            if (typeof Main !== "function")
+                throw Error("Main is not a function");
+            const Before = Module.Before || ((...args) => args);
+            const After = Module.After;
+            if (After && typeof After !== "function")
+                throw Error("After is not a function");
+            const main = exec(Main, Before, After, args);
+            if (_.has(deps, name))
+                throw Error(`Name ${name} duplicate`);
+            _.set(deps, name, main);
+            names.delete(name);
+            count += 1;
+        };
+        for (const x of names) {
+            const { Deps } = modules[x];
+            if (!Array.isArray(Deps) || !Deps.length) {
+                plugin(x);
+                continue;
+            }
+            if (Deps.every((d) => _.has(deps, d)))
+                plugin(x);
+        }
+        if (count === 0) {
+            const lacks = [];
+            for (const x of names) {
+                lacks.push(`${x}: ${_.filter(modules[x].Deps, (d) => !_.has(deps, d)).join(",")}`);
+            }
+            throw Error(`Deps defined conflict, ${lacks.join(";")}`);
+        }
+    }
+    return deps;
+}
+exports.auto = auto;

package/dist/http/index.d.ts

@@ -0,0 +1,12 @@
+import * as restify from "restify";
+import { Router } from "./router";
+import { Cnf, Domain, Profile, HttpCodes } from "./defines";
+interface Deps {
+    routers(r: ReturnType<typeof Router>): void;
+    domain: Domain;
+    httpCodes: HttpCodes;
+    swaggerDocJson?: any;
+    makeProfileHook?: (obj: Profile, req: restify.Request) => any;
+}
+export declare function Main(cnf: Cnf, deps: Deps): () => restify.Server;
+export {};

package/dist/http/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Main = void 0;
+const restify = require("restify");
+const router_1 = require("./router");
+const utils_1 = require("./utils");
+function Main(cnf, deps) {
+    const utils = (0, utils_1.Utils)(cnf);
+    const { routers, domain, httpCodes, swaggerDocJson, makeProfileHook } = deps;
+    const server = restify.createServer();
+    server.use(restify.plugins.queryParser());
+    server.use(restify.plugins.bodyParser({
+        keepExtensions: true,
+        maxFieldsSize: cnf.bodyMaxBytes || 2 * 1024 * 1024, // 参数最大容量 2MB
+    }));
+    const router = (0, router_1.Router)({
+        utils,
+        server,
+        httpCodes,
+        makeProfileHook,
+        domain,
+        apisRoute: cnf.apisRoute,
+        swagger: [cnf.swaggerApiPath, swaggerDocJson],
+    });
+    routers(router);
+    // Http server start
+    return () => {
+        server.listen(cnf.port || 8088, cnf.host || "127.0.0.1", () => {
+            console.log("%s listening at %s", server.name, server.url);
+        });
+        return server;
+    };
+}
+exports.Main = Main;

package/dist/http/router.d.ts

@@ -0,0 +1,23 @@
+import * as restify from "restify";
+import { Utils } from "./utils";
+import { HttpCodes, Domain, Profile } from "./defines";
+interface Deps {
+    domain: Domain;
+    utils: ReturnType<typeof Utils>;
+    server: restify.Server;
+    httpCodes: HttpCodes;
+    makeProfileHook?(obj: Profile, req: restify.Request): any;
+    apisRoute?: string;
+    swagger?: [any, any];
+}
+export declare function Router(deps: Deps): {
+    get: (routePath: string, ctlAct: string, code?: number, isList?: boolean, handler?: Function | undefined, resHandler?: Function | undefined) => void;
+    post: (routePath: string, ctlAct: string, code?: number, isList?: boolean, handler?: Function | undefined, resHandler?: Function | undefined) => void;
+    put: (routePath: string, ctlAct: string, code?: number, isList?: boolean, handler?: Function | undefined, resHandler?: Function | undefined) => void;
+    del: (routePath: string, ctlAct: string, code?: number, isList?: boolean, handler?: Function | undefined, resHandler?: Function | undefined) => void;
+} & {
+    collection: (res: string, _routePath?: string | undefined, controller?: string | undefined) => void;
+    model: (res: string, routePath?: string) => void;
+    resource: (res: string, routePath?: string) => void;
+};
+export {};

package/dist/http/router.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Router = void 0;
+const _ = require("lodash");
+const errors = require("restify-errors");
+const swaggerUi = require("swagger-ui-restify");
+function Router(deps) {
+    const { domain, apisRoute, utils, server, httpCodes = {}, makeProfileHook, swagger = ["", {}], } = deps;
+    const { ucwords, makeParams, makeProfile, outputCSV, jsonSchema2Swagger } = utils;
+    // 改写 HttpErrorToJSON 处理 data
+    const HttpErrorToJSON = errors.HttpError.prototype.toJSON;
+    errors.HttpError.prototype.toJSON = function toJSON() {
+        const json = HttpErrorToJSON.call(this);
+        if (this.body.data)
+            json.data = this.body.data;
+        return json;
+    };
+    const error2httpError = (error) => {
+        const { code, message, data } = error;
+        const e = errors.makeErrFromCode((code && httpCodes[code]) || 500, message);
+        if (code)
+            e.body.code = code;
+        if (data)
+            e.body.data = data;
+        return e;
+    };
+    const [apiSwagger, swaggerDocJson] = swagger;
+    const apis = [];
+    let apisHTML = "<h3>API 目录，点击可以查看参数格式定义</h3>";
+    let swaggerHtml = "";
+    if (apiSwagger) {
+        server.get(`/${apiSwagger}/*.*`, ...swaggerUi.serve);
+        server.get(`/${apiSwagger}`, (req, res) => {
+            res.writeHead(200, {
+                "Content-Length": Buffer.byteLength(swaggerHtml),
+                "Content-Type": "text/html",
+            });
+            res.write(swaggerHtml);
+            res.end();
+        });
+    }
+    /** 判断是否需要提供apis的查询接口 */
+    if (apisRoute) {
+        server.get(`/${apisRoute}`, (req, res, next) => {
+            if (req.query._format === "html") {
+                res.sendRaw(200, apisHTML, {
+                    "Content-Type": "text/html; charset=utf-8",
+                });
+            }
+            else {
+                res.send(apis);
+            }
+            next();
+        });
+        server.get(`/${apisRoute}/_schema`, (req, res, next) => {
+            const { path } = req.query;
+            try {
+                const { all } = req.query;
+                const schema = domain._getSchemaByPath(path);
+                res.send(all === undefined ? schema[1] : schema);
+            }
+            catch (e) {
+                next(error2httpError(e));
+                return;
+            }
+            next();
+        });
+    }
+    const getAPISchemaDoc = (verb, route, methodPath) => {
+        if (!apiSwagger)
+            return;
+        let apiSchema = [];
+        let desc = "";
+        try {
+            apiSchema = domain._getSchemaByPath(methodPath);
+            desc = apiSchema[1] ? apiSchema[1].description : "unknow";
+            apiSchema = jsonSchema2Swagger(apiSchema[1] ? apiSchema[1] : {}, verb, methodPath, swaggerDocJson);
+        }
+        catch (e) {
+            console.log(methodPath, "schema to swagger error.");
+        }
+        swaggerHtml = swaggerUi.generateHTML(swaggerDocJson, {
+            baseURL: `${swaggerDocJson.basePath}${apiSwagger}`,
+            explorer: true,
+        });
+        const apiTag = methodPath.split(".")[0];
+        swaggerDocJson.paths[route] = {
+            [verb]: {
+                "x-swagger-router-controller": methodPath,
+                operationId: methodPath,
+                tags: [apiTag],
+                externalDocs: {
+                    description: "查看接口参数 json schema 定义",
+                    url: `./${apisRoute}/_schema?path=${methodPath}`,
+                },
+                description: desc,
+                parameters: apiSchema || [],
+                responses: {},
+            },
+        };
+    };
+    function register(verb, route, methodPath, code = 200, isList = false, handler, resHandler) {
+        /**
+         * 暂存起来，提供给apis接口来用
+         *  apis接口用来返回当前 services 提供的可用的 api
+         */
+        apis.push(`[${verb.toUpperCase()}] ${route} Domain: ${methodPath}`);
+        apisHTML += `\n<li><a href="./${apisRoute}/_schema?path=${methodPath}">[${verb.toUpperCase()}] ${route} Domain: ${methodPath}</a></li>`;
+        const method = _.get(domain, methodPath);
+        /** 如果都没有则抛出异常 */
+        if (!method || !_.isFunction(method)) {
+            throw Error(`Missing domain method: ${methodPath}`);
+        }
+        getAPISchemaDoc(verb, route, methodPath);
+        server[verb](route, async (req, res, next) => {
+            const profile = makeProfile(req, methodPath, makeProfileHook);
+            const params = makeParams(req);
+            // 额外处理 params
+            if (handler)
+                handler(params);
+            res.header("X-RequestID", profile.requestId);
+            try {
+                let results = await method(profile, params);
+                res.header("X-ConsumedTime", Date.now() - profile.startedAt.valueOf());
+                if (results == null)
+                    results = "Ok";
+                if (resHandler) {
+                    resHandler(results, res);
+                }
+                else if (isList) {
+                    const { _ignoreTotal, _format } = params;
+                    if (_ignoreTotal !== "yes") {
+                        res.header("X-Content-Record-Total", results.count);
+                    }
+                    let ok = false;
+                    if (_format === "csv" || _format === "xlsx") {
+                        // 导出csv
+                        ok = await outputCSV(results.rows, params, res, _format === "xlsx");
+                    }
+                    if (!ok)
+                        res.send(code, results.rows);
+                }
+                else if (!_.isObject(results)) {
+                    if (code === 204) {
+                        res.send(code);
+                    }
+                    else {
+                        res.sendRaw(code, String(results));
+                    }
+                }
+                else {
+                    res.send(code, code !== 204 && results);
+                }
+            }
+            catch (e) {
+                res.header("X-ConsumedTime", Date.now() - profile.startedAt.valueOf());
+                next(error2httpError(e));
+                return;
+            }
+            next();
+        });
+    }
+    function RouterVerbFn(verb) {
+        return (routePath, ctlAct, code = 200, isList = false, handler, resHandler) => {
+            register(verb, routePath, ctlAct, code, isList, handler, resHandler);
+            if (verb === "put") {
+                register("patch", routePath, ctlAct, code, isList, handler, resHandler);
+            }
+        };
+    }
+    const router = {
+        get: RouterVerbFn("get"),
+        post: RouterVerbFn("post"),
+        put: RouterVerbFn("put"),
+        del: RouterVerbFn("del"),
+    };
+    /**
+     * controller 为可选参数，如果不填写则控制器名称直接就是 res ，方法为 list,add
+     * 如果设置了controller 则控制器为 controller，方法为 #{res}s, add{Res}
+     */
+    const collection = (res, _routePath, controller) => {
+        let routePath;
+        if (typeof _routePath !== "string") {
+            if (controller) {
+                routePath = `/${controller}s/:${controller}Id/${res}s`;
+            }
+            else {
+                routePath = `/${res}s`;
+            }
+        }
+        else {
+            routePath = _routePath;
+        }
+        if (controller) {
+            register("get", routePath, `${controller}.${res}s`, 200, true);
+            register("post", routePath, `${controller}.add${ucwords(res)}`, 201);
+        }
+        else {
+            register("get", routePath, `${res}.list`, 200, true);
+            register("post", routePath, `${res}.add`, 201);
+        }
+    };
+    const model = (res, routePath = `/${res}s/:id`) => {
+        register("get", routePath, `${res}.detail`);
+        register("put", routePath, `${res}.modify`);
+        register("patch", routePath, `${res}.modify`);
+        register("del", routePath, `${res}.remove`, 204);
+    };
+    const resource = (res, routePath = `/${res}s`) => {
+        collection(res, routePath);
+        model(res, `${routePath}/:id`);
+    };
+    return Object.assign(router, { collection, model, resource });
+}
+exports.Router = Router;

package/dist/http/utils.d.ts

@@ -0,0 +1,29 @@
+import * as restify from "restify";
+import { Cnf, Profile } from "./defines";
+export declare function Utils(cnf: Cnf): {
+    ucwords(value: string): string;
+    /** 真实的连接请求端ip */
+    remoteIp(req: restify.Request): string;
+    /**
+     * 获取客户端真实ip地址
+     */
+    clientIp(req: restify.Request): string;
+    /**
+     * 获取可信任的真实ip
+     */
+    realIp(req: restify.Request): string;
+    /**
+     * 构造profile参数
+     */
+    makeProfile(req: restify.Request, method: string, customFn?: Function | undefined): Readonly<Profile>;
+    /**
+     * 构造领域方法所需的 params 参数
+     */
+    makeParams(req: restify.Request): any;
+    /**
+     *
+     * 输出csv相关
+     */
+    outputCSV(rows: any[], params: any, res: restify.Response, isXLSX?: boolean): Promise<boolean>;
+    jsonSchema2Swagger(schema: any, verb: string, methodPath: string, swaggerDocJson: any): any[];
+};