@napp/dti-server 4.4.4 → 4.4.5

package/esm/action.d.ts

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

package/esm/action.js

@@ -0,0 +1,15 @@
+export class DtiServerAction {
+    constructor(meta, opt) {
+        this.meta = meta;
+        this.opt = opt;
+    }
+    action(param, ctx) {
+        return this.opt.action(param, ctx);
+    }
+    validation(param) {
+        this.meta.validate(param);
+    }
+    static factory(meta, opt) {
+        return new DtiServerAction(meta, opt);
+    }
+}

package/esm/bundler.d.ts

@@ -0,0 +1,14 @@
+import { IContext, OSetupParam } from "./common";
+import { DtiServer } from "./server";
+interface IMeteParam {
+    name: string;
+    param: any;
+}
+export declare class BundlerServer {
+    private server;
+    private base62;
+    constructor(server: DtiServer);
+    action(meta: Array<IMeteParam>, ctx: IContext): Promise<any[]>;
+    setup(expressRoute: any, setuper: OSetupParam): void;
+}
+export {};

package/esm/bundler.js

@@ -0,0 +1,56 @@
+import { Base62 } from "@napp/dti-core";
+export class BundlerServer {
+    constructor(server) {
+        this.server = server;
+        this.base62 = new Base62();
+    }
+    async action(meta, ctx) {
+        let actions = [];
+        for (let it of meta) {
+            let action = this.server.getActionByName(it.name);
+            if (action) {
+                action.validation(it.param);
+                // console.log('call', it.name, it.param, await action?.action(it.param, ctx))
+                actions.push(async () => await action?.action(it.param, ctx));
+            }
+            else {
+                throw new Error('not defined action. name=' + it.name);
+            }
+        }
+        return await Promise.all(actions.map(it => it()));
+    }
+    setup(expressRoute, setuper) {
+        if (setuper.factoryBodyparseJson) {
+            expressRoute.post('/__bundler_post__', setuper.factoryBodyparseJson(), async (req, res, next) => {
+                try {
+                    let meta = req.body || [];
+                    let result = await this.action(meta, { req, res });
+                    res.json(result);
+                }
+                catch (error) {
+                    next(error);
+                }
+            });
+            expressRoute.get('/__bundler_get__', async (req, res, next) => {
+                try {
+                    let p = req.query?.p;
+                    if (p) {
+                        let json = this.base62.decode(p);
+                        let meta = JSON.parse(json);
+                        let result = await this.action(meta, { req, res });
+                        res.json(result);
+                    }
+                    else {
+                        res.json([]);
+                    }
+                }
+                catch (error) {
+                    next(error);
+                }
+            });
+        }
+        else {
+            throw new Error('not defined server.factoryBodyparseJson');
+        }
+    }
+}

package/esm/common.d.ts

@@ -0,0 +1,22 @@
+import { DtiRoute } from "@napp/dti-core";
+export interface IContext {
+    req: any;
+    res: any;
+}
+export interface IMiddleware {
+    (req: any, res: any, next: any): void;
+}
+export interface IErrorHandle {
+    (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 OSetupParam {
+    factoryExpressRouter(dtiRouter: DtiRoute): any;
+    factoryBodyparseJson?: () => IMiddleware;
+    factoryBodyparseUrlencode?: () => IMiddleware;
+    errorHandle?: IErrorHandle;
+}

package/esm/common.js

@@ -0,0 +1 @@
+export {};

package/esm/index.d.ts

@@ -0,0 +1,4 @@
+export * from './action';
+export * from './common';
+export * from './route';
+export * from './server';

package/esm/index.js

@@ -0,0 +1,4 @@
+export * from './action';
+export * from './common';
+export * from './route';
+export * from './server';

package/esm/route.d.ts

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

package/esm/route.js

@@ -0,0 +1,107 @@
+import { DtiMode, Base62, DtiRawResponse } from "@napp/dti-core";
+export class DtiServerRoute {
+    constructor(meta, server) {
+        this.meta = meta;
+        this.server = server;
+        this.base62 = new Base62();
+    }
+    param(action, req) {
+        let mode = action.meta.getMode();
+        if (mode === DtiMode.QString) {
+            return req.query;
+        }
+        else if (mode === DtiMode.QJson) {
+            try {
+                let p = req.query?.p;
+                if (p) {
+                    let json = this.base62.decode(p);
+                    return JSON.parse(json);
+                }
+            }
+            catch (error) {
+            }
+            return {};
+        }
+        else if (mode === DtiMode.BJson || mode === 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 (DtiRawResponse.is(rsu) === false) {
+                    return res.json(rsu);
+                }
+            })
+                .catch(err => next(err));
+        }
+        catch (error) {
+            return next(error);
+        }
+    }
+    setupAction(expressRoute, action, setuper) {
+        let mode = action.meta.getMode();
+        let path = action.meta.getPath();
+        let endpoint = (req, res, next) => {
+            this.callAction(action, req, res, next);
+        };
+        if (mode === DtiMode.QString || mode === DtiMode.QJson) {
+            expressRoute.get(path, endpoint);
+        }
+        else if (mode === DtiMode.BJson) {
+            if (setuper.factoryBodyparseJson) {
+                expressRoute.post(path, [setuper.factoryBodyparseJson(), endpoint]);
+            }
+            else {
+                throw new Error('not define server.factoryBodyparseJson');
+            }
+        }
+        else if (mode === DtiMode.BFrom) {
+            if (setuper.factoryBodyparseUrlencode) {
+                expressRoute.post(path, [setuper.factoryBodyparseUrlencode(), endpoint]);
+            }
+            else {
+                throw new Error('not define server.factoryBodyparseUrlencode');
+            }
+        }
+        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;
+    }
+}

package/esm/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[]): this;
+    getActionByName(name: string): DtiServerAction<any, any> | undefined;
+    getRawByName(name: string): IRawActionBuilder[] | undefined;
+    static setup(server: DtiServer, setuper: OSetupParam): any;
+}

package/esm/server.js

@@ -0,0 +1,45 @@
+import { DtiServerRoute } from "./route";
+import { BundlerServer } from "./bundler";
+export 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]);
+        }
+        return this;
+    }
+    getActionByName(name) {
+        return this._actions.get(name);
+    }
+    getRawByName(name) {
+        return this._raws.get(name);
+    }
+    static setup(server, setuper) {
+        let route = setuper.factoryExpressRouter(server.root);
+        new BundlerServer(server).setup(route, setuper);
+        route.use(server.root.getLocalPath(), new DtiServerRoute(server.root, server).setup(setuper));
+        if (setuper.errorHandle) {
+            route.use(setuper.errorHandle);
+        }
+        return route;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@napp/dti-server",
-    "version": "4.4.4",
+    "version": "4.4.5",
     "description": "data transaction interface server library",
     "repository": {
         "type": "git",
@@ -8,6 +8,14 @@
     },
     "types": "index.d.ts",
     "main": "index.js",
+    "module": "esm/index.js",
+    "exports": {
+        ".": {
+            "require": "./index.js",
+            "import": "./esm/index.js",
+            "types": "./index.d.ts"
+        }
+    },
     "keywords": [
         "napp",
         "Rest API",
@@ -19,6 +27,6 @@
         "@napp/exception": "^9.1.4"
     },
     "dependencies": {
-        "@napp/dti-core": "4.4.4"
+        "@napp/dti-core": "4.4.5"
     }
 }