@napp/dti-server 3.0.8 → 4.0.2

package/action.d.ts

@@ -0,0 +1,15 @@
+import { DtiAction } from "@napp/dti-core";
+import { IContext, IMiddleware } from "./common";
+export interface ODtiServerAction<RESULT, PARAM> {
+    action: (param: PARAM, ctx: IContext) => Promise<RESULT>;
+    before?: Array<IMiddleware>;
+}
+export declare class DtiServerAction<RESULT, PARAM> {
+    meta: DtiAction<RESULT, PARAM>;
+    private opt;
+    private constructor();
+    action(param: PARAM, ctx: IContext): Promise<RESULT>;
+    before(): Array<IMiddleware>;
+    validation(param: PARAM): void;
+    static factory<RESULT, PARAM>(meta: DtiAction<RESULT, PARAM>, opt: ODtiServerAction<RESULT, PARAM>): DtiServerAction<RESULT, PARAM>;
+}

package/action.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtiServerAction = void 0;
+class DtiServerAction {
+    constructor(meta, opt) {
+        this.meta = meta;
+        this.opt = opt;
+    }
+    action(param, ctx) {
+        return this.opt.action(param, ctx);
+    }
+    before() {
+        return this.opt.before || [];
+    }
+    validation(param) {
+        this.meta.validate(param);
+    }
+    static factory(meta, opt) {
+        return new DtiServerAction(meta, opt);
+    }
+}
+exports.DtiServerAction = DtiServerAction;

package/common.d.ts

@@ -0,0 +1,21 @@
+import { DtiAction, DtiRoute } from "@napp/dti-core";
+export interface IContext {
+    req: any;
+    res: any;
+}
+export interface IMiddleware {
+    (req: any, res: any, next: any): void;
+}
+export interface IExpressRoute {
+    get(path: string, handlers: IMiddleware[]): void;
+    post(path: string, handlers: IMiddleware[]): void;
+    use(path: string, route: IExpressRoute): void;
+}
+export interface Logger {
+    (level: string, message: string): void;
+}
+export interface OSetupParam {
+    factoryExpressRouter(dtiRouter: DtiRoute): any;
+    factoryBodyparseJson(action: DtiAction<any, any>): IMiddleware;
+    factoryBodyparseUrlencode(action: DtiAction<any, any>): IMiddleware;
+}

package/common.js

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

package/index.d.ts

@@ -1,2 +1,5 @@
-export * from './response';
-export * from './adapter';
+export * from './action';
+export * from './common';
+export * from './response';
+export * from './route';
+export * from './server';

package/index.js

@@ -1,14 +1,21 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./response"), exports);
-__exportStar(require("./adapter"), exports);
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./action"), exports);
+__exportStar(require("./common"), exports);
+__exportStar(require("./response"), exports);
+__exportStar(require("./route"), exports);
+__exportStar(require("./server"), exports);

package/package.json

@@ -1,17 +1,22 @@
 {
     "name": "@napp/dti-server",
-    "version": "3.0.8",
+    "version": "4.0.2",
     "description": "data transaction interface server library",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/napp-core/dti.git"
+    },
     "types": "index.d.ts",
     "main": "index.js",
     "keywords": [
         "napp",
         "Rest API",
-        "API framework"
+        "Rest API framework"
     ],
     "author": "Farcek <farcek@gmail.com>",
     "license": "ISC",
     "dependencies": {
-        "@napp/dti-core": "3.0.8"
+        "@napp/dti-core": "4.0.2",
+        "base64url": "latest"
     }
 }

package/response.d.ts

@@ -1,4 +1,4 @@
-export declare class DtiResponse {
-    handle?: ((res: any) => void) | undefined;
-    constructor(handle?: ((res: any) => void) | undefined);
-}
+export declare class DtiResponse {
+    handle?: ((res: any) => void) | undefined;
+    constructor(handle?: ((res: any) => void) | undefined);
+}

package/response.js

@@ -1,10 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DtiResponse = void 0;
-var DtiResponse = /** @class */ (function () {
-    function DtiResponse(handle) {
-        this.handle = handle;
-    }
-    return DtiResponse;
-}());
-exports.DtiResponse = DtiResponse;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtiResponse = void 0;
+class DtiResponse {
+    constructor(handle) {
+        this.handle = handle;
+    }
+}
+exports.DtiResponse = DtiResponse;

package/route.d.ts

@@ -0,0 +1,14 @@
+import { DtiRoute } from "@napp/dti-core";
+import { OSetupParam } from "./common";
+import { DtiServer } from "./server";
+export declare class DtiServerRoute {
+    private meta;
+    private server;
+    constructor(meta: DtiRoute, server: DtiServer);
+    private param;
+    private callAction;
+    private setupAction;
+    private setupActions;
+    private setupRaws;
+    setup(setuper: OSetupParam): any;
+}

package/route.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtiServerRoute = void 0;
+const dti_core_1 = require("@napp/dti-core");
+const response_1 = require("./response");
+const base64url_1 = __importDefault(require("base64url"));
+class DtiServerRoute {
+    constructor(meta, server) {
+        this.meta = meta;
+        this.server = server;
+    }
+    param(action, req) {
+        let mode = action.meta.getMode();
+        if (mode === dti_core_1.DtiMode.QString) {
+            return req.query;
+        }
+        else if (mode === dti_core_1.DtiMode.QJson) {
+            try {
+                let p = req.query.p;
+                if (p) {
+                    let json = base64url_1.default.decode(p);
+                    return JSON.parse(json);
+                }
+            }
+            catch (error) {
+            }
+            return {};
+        }
+        else if (mode === dti_core_1.DtiMode.BJson || mode === dti_core_1.DtiMode.BFrom) {
+            return req.body;
+        }
+        throw new Error('not supported mode');
+    }
+    callAction(sa, req, res, next) {
+        try {
+            let param = this.param(sa, req);
+            sa.validation(param);
+            return sa.action(param, { req, res })
+                .then(rsu => {
+                if (rsu instanceof response_1.DtiResponse) {
+                    if (rsu.handle) {
+                        return rsu.handle(res);
+                    }
+                    return res.end();
+                }
+                return res.json(rsu);
+            })
+                .catch(err => next(err));
+        }
+        catch (error) {
+            return next(error);
+        }
+    }
+    setupAction(expressRoute, action, setuper) {
+        let befores = action.before();
+        let mode = action.meta.getMode();
+        let path = action.meta.getPath();
+        let endpoint = (req, res, next) => {
+            this.callAction(action, req, res, next);
+        };
+        if (mode === dti_core_1.DtiMode.QString || mode === dti_core_1.DtiMode.QJson) {
+            expressRoute.get(path, [...befores, endpoint]);
+        }
+        else if (mode === dti_core_1.DtiMode.BJson) {
+            expressRoute.post(path, [setuper.factoryBodyparseJson(action.meta), ...befores, endpoint]);
+        }
+        else if (mode === dti_core_1.DtiMode.BFrom) {
+            expressRoute.post(path, [setuper.factoryBodyparseUrlencode(action.meta), ...befores, endpoint]);
+        }
+        else {
+            throw new Error("not support methid. logic error");
+        }
+    }
+    setupActions(expressRoute, setuper) {
+        let actions = this.meta.getActions();
+        for (let a of actions) {
+            let name = a.getFullname();
+            let action = this.server.getActionByName(name);
+            if (action) {
+                this.setupAction(expressRoute, action, setuper);
+            }
+            else {
+                console.warn(`not registered server action. action(${name})`);
+            }
+        }
+    }
+    setupRaws(expressRoute, setuper) {
+        let name = this.meta.getFullname();
+        let handles = this.server.getRawByName(name);
+        if (Array.isArray(handles)) {
+            for (let handle of handles) {
+                handle(expressRoute);
+            }
+        }
+    }
+    setup(setuper) {
+        let pRoute = setuper.factoryExpressRouter(this.meta);
+        this.setupActions(pRoute, setuper);
+        this.setupRaws(pRoute, setuper);
+        for (let dtiRoute of this.meta.getChildroutes()) {
+            let lRoute = new DtiServerRoute(dtiRoute, this.server).setup(setuper);
+            pRoute.use(dtiRoute.getLocalPath(), lRoute);
+        }
+        return pRoute;
+    }
+}
+exports.DtiServerRoute = DtiServerRoute;

package/server.d.ts

@@ -0,0 +1,17 @@
+import { DtiRoute } from "@napp/dti-core";
+import { DtiServerAction } from "./action";
+import { OSetupParam } from "./common";
+export interface IRawActionBuilder {
+    (expressRoute: any): void;
+}
+export declare class DtiServer {
+    private root;
+    constructor(root: DtiRoute);
+    private _actions;
+    private _raws;
+    register(...actions: DtiServerAction<any, any>[]): this;
+    rawRegister(route: DtiRoute, ...handlers: IRawActionBuilder[]): void;
+    getActionByName(name: string): DtiServerAction<any, any> | undefined;
+    getRawByName(name: string): IRawActionBuilder[] | undefined;
+    static setup(server: DtiServer, setuper: OSetupParam): any;
+}

package/server.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtiServer = void 0;
+const dti_core_1 = require("@napp/dti-core");
+const route_1 = require("./route");
+class DtiServer {
+    constructor(root) {
+        this.root = root;
+        this._actions = new Map();
+        this._raws = new Map();
+    }
+    register(...actions) {
+        for (let action of actions) {
+            let name = action.meta.getFullname();
+            if (this._actions.has(name)) {
+                throw new Error(`already registed(${name})`);
+            }
+            this._actions.set(name, action);
+        }
+        return this;
+    }
+    rawRegister(route, ...handlers) {
+        let name = route.getFullname();
+        if (this._raws.has(name)) {
+            let olds = this._raws.get(name) || [];
+            this._raws.set(name, [...olds, ...handlers]);
+        }
+        else {
+            this._raws.set(name, [...handlers]);
+        }
+    }
+    getActionByName(name) {
+        return this._actions.get(name);
+    }
+    getRawByName(name) {
+        return this._raws.get(name);
+    }
+    static setup(server, setuper) {
+        let route = setuper.factoryExpressRouter(server.root);
+        route.use(server.root.getLocalPath(), new route_1.DtiServerRoute(server.root, server).setup(setuper));
+        route.use((err, req, res, next) => {
+            res.status(500).json(dti_core_1.DtiError.from(err).toPlanObject());
+        });
+        return route;
+    }
+}
+exports.DtiServer = DtiServer;

package/adapter.d.ts

@@ -1,49 +0,0 @@
-import { Dti } from "@napp/dti-core";
-interface IAction<RES, PQ, PB> {
-    (param: {
-        q: PQ;
-        b: PB;
-    }, ctx: {
-        req: any;
-        res: any;
-    }): Promise<RES>;
-}
-interface IMiddleware {
-    (req: any, res: any, next: any): void;
-}
-interface QParser<T> {
-    (req: any): T;
-}
-export interface Logger {
-    (level: string, message: string): void;
-}
-export declare class ServerInstance<RES, PQ, PB> {
-    private meta;
-    beforeFuncs?: Array<IMiddleware>;
-    actionFunc?: IAction<RES, PQ, PB>;
-    constructor(meta: Dti<RES, PQ, PB>);
-    get name(): string;
-    get method(): "get" | "post";
-    get path(): string;
-    get queryMode(): string;
-    get bodyMode(): string;
-    check(q: PQ, b: PB): void;
-    before(funcs: Array<IMiddleware>): this;
-    handle(action: IAction<RES, PQ, PB>): this;
-}
-export declare class ServerAdapter {
-    actions: ServerInstance<any, any, any>[];
-    private logger;
-    constructor(logger: Logger);
-    register<RES, PQ, PB>(...act: ServerInstance<RES, PQ, PB>[]): this;
-    private bodyParser?;
-    installBodyParser(parser: (bodyMode: string) => IMiddleware): this;
-    private queryParser?;
-    installQueryParser(parser: (queryMode: string) => QParser<any>): this;
-    static dti<RES, PQ, PB>(meta: Dti<RES, PQ, PB>): ServerInstance<RES, PQ, PB>;
-    private qParam;
-    private callAction;
-    private getBodyParser;
-    setup<R>(route: R): R;
-}
-export {};

package/adapter.js

@@ -1,173 +0,0 @@
-"use strict";
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServerAdapter = exports.ServerInstance = void 0;
-var response_1 = require("./response");
-var ServerInstance = /** @class */ (function () {
-    function ServerInstance(meta) {
-        this.meta = meta;
-    }
-    Object.defineProperty(ServerInstance.prototype, "name", {
-        get: function () {
-            return this.meta.name;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ServerInstance.prototype, "method", {
-        get: function () {
-            return this.meta.method;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ServerInstance.prototype, "path", {
-        get: function () {
-            return this.meta.path;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ServerInstance.prototype, "queryMode", {
-        get: function () {
-            return this.meta.queryMode;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ServerInstance.prototype, "bodyMode", {
-        get: function () {
-            return this.meta.bodyMode;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ServerInstance.prototype.check = function (q, b) {
-        this.meta.checkQ(q);
-        this.meta.checkB(b);
-    };
-    ServerInstance.prototype.before = function (funcs) {
-        this.beforeFuncs = funcs;
-        return this;
-    };
-    ServerInstance.prototype.handle = function (action) {
-        this.actionFunc = action;
-        return this;
-    };
-    return ServerInstance;
-}());
-exports.ServerInstance = ServerInstance;
-var ServerAdapter = /** @class */ (function () {
-    function ServerAdapter(logger) {
-        this.actions = [];
-        this.logger = logger;
-    }
-    ServerAdapter.prototype.register = function () {
-        var _a;
-        var act = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            act[_i] = arguments[_i];
-        }
-        (_a = this.actions).push.apply(_a, act);
-        return this;
-    };
-    ServerAdapter.prototype.installBodyParser = function (parser) {
-        this.bodyParser = parser;
-        return this;
-    };
-    ServerAdapter.prototype.installQueryParser = function (parser) {
-        this.queryParser = parser;
-        return this;
-    };
-    ServerAdapter.dti = function (meta) {
-        return new ServerInstance(meta);
-    };
-    ServerAdapter.prototype.qParam = function (it, req) {
-        if (this.queryParser) {
-            var parser = this.queryParser(it.queryMode);
-            if (parser) {
-                var q = parser(req);
-                return q;
-            }
-        }
-        return req.query;
-    };
-    ServerAdapter.prototype.callAction = function (it, req, res, next) {
-        try {
-            if (it.actionFunc) {
-                var q = this.qParam(it, req);
-                var b = req.body;
-                it.check(q || {}, b || {});
-                return it.actionFunc({ q: q, b: b }, { req: req, res: res })
-                    .then(function (rsu) {
-                    if (rsu instanceof response_1.DtiResponse) {
-                        if (rsu.handle) {
-                            return rsu.handle(res);
-                        }
-                        return res.end();
-                    }
-                    return res.json(rsu);
-                })
-                    .catch(function (err) { return next(err); });
-            }
-            throw new Error('not found action handle');
-        }
-        catch (error) {
-            return next(error);
-        }
-    };
-    ServerAdapter.prototype.getBodyParser = function (it) {
-        if (this.bodyParser) {
-            var p = this.bodyParser(it.bodyMode);
-            if (p) {
-                return [p];
-            }
-        }
-        return [];
-    };
-    ServerAdapter.prototype.setup = function (route) {
-        var _this = this;
-        var _route = route;
-        var _loop_1 = function (it) {
-            var befores = it.beforeFuncs || [];
-            if (it.method === 'get') {
-                _route.get(it.path, __spreadArray(__spreadArray([], befores, true), [function (req, res, next) {
-                        _this.callAction(it, req, res, next);
-                    }], false));
-            }
-            else if (it.method === 'post') {
-                var bodyparser = this_1.getBodyParser(it);
-                if (bodyparser.length === 0) {
-                    this_1.logger('warn', "not found body parser. name=\"".concat(it.name, "\"; bodyMode=\"").concat(it.bodyMode, "\""));
-                }
-                _route.post(it.path, __spreadArray(__spreadArray(__spreadArray([], bodyparser, true), befores, true), [function (req, res, next) {
-                        _this.callAction(it, req, res, next);
-                    }], false));
-            }
-            else {
-                this_1.logger('warn', "not supored method. \"".concat(it.method, "\""));
-            }
-            this_1.logger('info', "[".concat(it.method, "] ").concat(it.path));
-        };
-        var this_1 = this;
-        for (var _i = 0, _a = this.actions; _i < _a.length; _i++) {
-            var it = _a[_i];
-            _loop_1(it);
-        }
-        // for (let it of this.routes) {
-        //     let { name } = it(_route);
-        //     this.logger('info', `register native route "${name}"`)
-        // }
-        return route;
-    };
-    return ServerAdapter;
-}());
-exports.ServerAdapter = ServerAdapter;