@napp/dti-client 4.0.2 → 4.1.4

package/bundler.d.ts

@@ -0,0 +1,23 @@
+import { DtiAction } from "@napp/dti-core";
+import { DtiClientBuilder } from "./builder";
+export interface BundleMeta<RESULT, PARAM> {
+    meta: DtiAction<RESULT, PARAM>;
+    param: PARAM;
+}
+export declare class DtiClientBandler {
+    private bundleMetas;
+    private builder;
+    constructor(bundleMetas: Array<BundleMeta<any, any>>, builder: DtiClientBuilder);
+    validate(): void;
+    private getMethod;
+    private getBase;
+    getParam(): {
+        name: string;
+        param: any;
+    }[];
+    private getHeaders;
+    call(): Promise<any>;
+    private callGet;
+    private callPost;
+    private respHandle;
+}

package/bundler.js

@@ -0,0 +1,147 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtiClientBandler = void 0;
+const dti_core_1 = require("@napp/dti-core");
+const cross_fetch_1 = require("cross-fetch");
+const base64url_1 = __importDefault(require("base64url"));
+class DtiClientBandler {
+    constructor(bundleMetas, builder) {
+        this.bundleMetas = bundleMetas;
+        this.builder = builder;
+    }
+    validate() {
+        for (let it of this.bundleMetas) {
+            it.meta.validate(it.param);
+        }
+    }
+    getMethod() {
+        for (let it of this.bundleMetas) {
+            let m = it.meta.getMode();
+            if (m === dti_core_1.DtiMode.BFrom || m === dti_core_1.DtiMode.BJson) {
+                return 'post';
+            }
+        }
+        return 'get';
+    }
+    getBase() {
+        for (let it of this.bundleMetas) {
+            let base = this.builder.getBaseUrl(it.meta.getFullname());
+            if (base) {
+                return base;
+            }
+        }
+        return '';
+    }
+    getParam() {
+        let param = [];
+        for (let it of this.bundleMetas) {
+            param.push({
+                name: it.meta.getFullname(),
+                param: it.param
+            });
+        }
+        return param;
+    }
+    getHeaders() {
+        let headers = {};
+        for (let it of this.bundleMetas) {
+            let _headers = this.builder.getHeader(it.meta.getRoute().getFullname());
+            if (_headers) {
+                headers = Object.assign(Object.assign({}, headers), _headers);
+            }
+        }
+        headers["Content-Type"] = "application/json";
+        return headers;
+    }
+    call() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.validate();
+            }
+            catch (error) {
+                throw dti_core_1.DtiError.fromCode('validation', error);
+            }
+            let method = this.getMethod();
+            if (method === 'get') {
+                return yield this.callGet();
+            }
+            return yield this.callPost();
+        });
+    }
+    callGet() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let baseUrl = this.getBase();
+                let param = this.getParam();
+                let headers = this.getHeaders();
+                let p = base64url_1.default.encode(JSON.stringify(param));
+                let q = new URLSearchParams({ p }).toString();
+                let resp = yield (0, cross_fetch_1.fetch)(`${baseUrl}/__bundler_get__?${q}`, {
+                    method: 'get', headers
+                });
+                return yield this.respHandle(resp);
+            }
+            catch (error) {
+                throw dti_core_1.DtiError.from(error);
+            }
+        });
+    }
+    callPost() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let baseUrl = this.getBase();
+                let param = this.getParam();
+                let headers = this.getHeaders();
+                let resp = yield (0, cross_fetch_1.fetch)(`${baseUrl}/__bundler_post__`, {
+                    method: 'post', headers, body: JSON.stringify(param)
+                });
+                return yield this.respHandle(resp);
+            }
+            catch (error) {
+                throw dti_core_1.DtiError.from(error);
+            }
+        });
+    }
+    respHandle(resp) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let resu = yield resp.text();
+                if (resp.ok) {
+                    try {
+                        return JSON.parse(resu);
+                    }
+                    catch (error) {
+                        throw dti_core_1.DtiError.fromCode("InvalidJSON", resu);
+                    }
+                }
+                try {
+                    let errObject = JSON.parse(resu);
+                    let error = dti_core_1.DtiError.from(errObject);
+                    if (error instanceof dti_core_1.DtiErrorUnknown) {
+                        throw new dti_core_1.DtiError('' + resp.status, resp.statusText);
+                    }
+                    throw error;
+                }
+                catch (error) {
+                    throw new dti_core_1.DtiErrorUnknown(resu);
+                }
+            }
+            catch (error) {
+                throw dti_core_1.DtiError.from(error);
+            }
+        });
+    }
+}
+exports.DtiClientBandler = DtiClientBandler;

package/caller.d.ts

@@ -1,5 +1,6 @@
 import { DtiAction } from "@napp/dti-core";
 import { DtiClientBuilder } from "./builder";
+import { BundleMeta } from "./bundler";
 export declare class DtiClientCaller<RESULT, PARAM> {
     private meta;
     private builder;
@@ -11,5 +12,6 @@ export declare class DtiClientCaller<RESULT, PARAM> {
     private getQeury;
     private getHeaders;
     private getUrl;
+    bundler(param: PARAM): BundleMeta<RESULT, PARAM>;
     call(param: PARAM): Promise<RESULT>;
 }

package/caller.js

@@ -83,6 +83,9 @@ class DtiClientCaller {
     getUrl() {
         return this.routeClient.buildUrl(this.meta.getPath());
     }
+    bundler(param) {
+        return { meta: this.meta, param };
+    }
     call(param) {
         return __awaiter(this, void 0, void 0, function* () {
             try {

package/client.d.ts

@@ -1,9 +1,11 @@
 import { DtiAction, DtiRoute } from "@napp/dti-core";
 import { DtiClientBuilder } from "./builder";
 import { DtiClientCaller } from "./caller";
+import { BundleMeta } from "./bundler";
 export declare class DtiClient {
     private builder;
     constructor(builder: DtiClientBuilder);
     dti<RESULT, PARAM>(meta: DtiAction<RESULT, PARAM>): DtiClientCaller<RESULT, PARAM>;
     buildUrl(route: DtiRoute, actionPath: string): string;
+    bundle<R1, P1, R2, P2, R3, P3, R4, P4, R5, P5, R6, P6>(m1: BundleMeta<R1, P1>, m2?: BundleMeta<R2, P2>, m3?: BundleMeta<R3, P3>, m4?: BundleMeta<R4, P4>, m5?: BundleMeta<R5, P5>, m6?: BundleMeta<R6, P6>): Promise<[R1, R2, R3, R4, R5, R6]>;
 }

package/client.js

@@ -1,8 +1,18 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DtiClient = void 0;
 const route_1 = require("./route");
 const caller_1 = require("./caller");
+const bundler_1 = require("./bundler");
 class DtiClient {
     constructor(builder) {
         this.builder = builder;
@@ -13,5 +23,26 @@ class DtiClient {
     buildUrl(route, actionPath) {
         return new route_1.DtiClientRoute(route, this.builder).buildUrl(actionPath);
     }
+    bundle(m1, m2, m3, m4, m5, m6) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let bundleMetas = [m1];
+            if (m2) {
+                bundleMetas.push(m2);
+            }
+            if (m3) {
+                bundleMetas.push(m3);
+            }
+            if (m4) {
+                bundleMetas.push(m4);
+            }
+            if (m5) {
+                bundleMetas.push(m5);
+            }
+            if (m6) {
+                bundleMetas.push(m6);
+            }
+            return yield new bundler_1.DtiClientBandler(bundleMetas, this.builder).call();
+        });
+    }
 }
 exports.DtiClient = DtiClient;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@napp/dti-client",
-    "version": "4.0.2",
+    "version": "4.1.4",
     "description": "data transaction interface client library",
     "repository": {
         "type": "git",
@@ -16,7 +16,7 @@
     "author": "Farcek <farcek@gmail.com>",
     "license": "ISC",
     "dependencies": {
-        "@napp/dti-core": "4.0.2",
+        "@napp/dti-core": "4.1.4",
         "base64url": "latest",
         "cross-fetch": "latest"
     }