@napp/dti-client 4.4.4 → 4.5.2

package/builder.d.ts

@@ -10,5 +10,10 @@ export declare class DtiClientBuilder {
     getBaseUrl(name: string): string | undefined;
     header(route: DtiRoute, builder: ODtiClientHeaderBuilder): this;
     getHeader(name: string): ODtiClientHeaderBuilder | undefined;
+    private signatureSecretResolver;
+    signatureSecret(resolver: {
+        (): Promise<string>;
+    } | undefined): this;
+    getSignatureResolver(): (() => Promise<string>) | undefined;
     build(): DtiClient;
 }

package/builder.js

@@ -4,10 +4,8 @@ exports.DtiClientBuilder = void 0;
 const tree_1 = require("./tree");
 const client_1 = require("./client");
 class DtiClientBuilder {
-    constructor() {
-        this._baseUrls = new tree_1.TreeNamer("root");
-        this._headers = new tree_1.TreeNamer("root");
-    }
+    _baseUrls = new tree_1.TreeNamer("root");
+    _headers = new tree_1.TreeNamer("root");
     baseUrl(route, url) {
         this._baseUrls.set(route.getFullname(), url);
         return this;
@@ -30,6 +28,14 @@ class DtiClientBuilder {
         }
         return undefined;
     }
+    signatureSecretResolver = undefined;
+    signatureSecret(resolver) {
+        this.signatureSecretResolver = resolver;
+        return this;
+    }
+    getSignatureResolver() {
+        return this.signatureSecretResolver;
+    }
     build() {
         return new client_1.DtiClient(this);
     }

package/bundler.js

@@ -1,13 +1,4 @@
 "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.DtiClientBandler = void 0;
 const dti_core_1 = require("@napp/dti-core");
@@ -15,10 +6,12 @@ const exception_1 = require("@napp/exception");
 const cross_fetch_1 = require("cross-fetch");
 const errorhandle_1 = require("./errorhandle");
 class DtiClientBandler {
+    bundleMetas;
+    builder;
+    base62 = new dti_core_1.Base62();
     constructor(bundleMetas, builder) {
         this.bundleMetas = bundleMetas;
         this.builder = builder;
-        this.base62 = new dti_core_1.Base62();
     }
     validate() {
         for (let it of this.bundleMetas) {
@@ -58,55 +51,49 @@ class DtiClientBandler {
         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 = { ...headers, ..._headers };
             }
         }
         headers["Content-Type"] = "application/json";
         return headers;
     }
-    call() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.validate();
-            let method = this.getMethod();
-            if (method === 'get') {
-                return yield this.callGet();
-            }
-            return yield this.callPost();
-        });
+    async call() {
+        this.validate();
+        let method = this.getMethod();
+        if (method === 'get') {
+            return await this.callGet();
+        }
+        return await 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 = this.base62.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 (0, errorhandle_1.responseHandle)(resp);
-            }
-            catch (error) {
-                throw exception_1.Exception.from(error);
-            }
-        });
+    async callGet() {
+        try {
+            let baseUrl = this.getBase();
+            let param = this.getParam();
+            let headers = this.getHeaders();
+            let p = this.base62.encode(JSON.stringify(param));
+            let q = new URLSearchParams({ p }).toString();
+            let resp = await (0, cross_fetch_1.fetch)(`${baseUrl}/__bundler_get__?${q}`, {
+                method: 'get', headers
+            });
+            return await (0, errorhandle_1.responseHandle)(resp);
+        }
+        catch (error) {
+            throw exception_1.Exception.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 (0, errorhandle_1.responseHandle)(resp);
-            }
-            catch (error) {
-                throw exception_1.Exception.from(error);
-            }
-        });
+    async callPost() {
+        try {
+            let baseUrl = this.getBase();
+            let param = this.getParam();
+            let headers = this.getHeaders();
+            let resp = await (0, cross_fetch_1.fetch)(`${baseUrl}/__bundler_post__`, {
+                method: 'post', headers, body: JSON.stringify(param)
+            });
+            return await (0, errorhandle_1.responseHandle)(resp);
+        }
+        catch (error) {
+            throw exception_1.Exception.from(error);
+        }
     }
 }
 exports.DtiClientBandler = DtiClientBandler;

package/caller.d.ts

@@ -12,6 +12,7 @@ export declare class DtiClientCaller<RESULT, PARAM> {
     private getBody;
     private getQeury;
     private getHeaders;
+    private signature;
     private getUrl;
     bundler(param: PARAM): BundleMeta<RESULT, PARAM>;
     call(param: PARAM): Promise<RESULT>;

package/caller.js

@@ -1,24 +1,34 @@
 "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.DtiClientCaller = void 0;
 const dti_core_1 = require("@napp/dti-core");
 const cross_fetch_1 = require("cross-fetch");
 const route_1 = require("./route");
 const errorhandle_1 = require("./errorhandle");
+function getRandomInt(min, max) {
+    const minCeiled = Math.ceil(min);
+    const maxFloored = Math.floor(max);
+    // The maximum is exclusive and the minimum is inclusive
+    return Math.floor(Math.random() * (maxFloored - minCeiled) + minCeiled);
+}
+async function hmacSignBase64(secret, data) {
+    const enc = new TextEncoder();
+    const key = await crypto.subtle.importKey("raw", enc.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    const sigBuf = await crypto.subtle.sign("HMAC", key, enc.encode(data));
+    const sigBytes = new Uint8Array(sigBuf);
+    // base64 encode
+    let bin = "";
+    sigBytes.forEach(b => (bin += String.fromCharCode(b)));
+    return btoa(bin);
+}
 class DtiClientCaller {
+    meta;
+    builder;
+    base62 = new dti_core_1.Base62();
+    routeClient;
     constructor(meta, builder) {
         this.meta = meta;
         this.builder = builder;
-        this.base62 = new dti_core_1.Base62();
         this.routeClient = new route_1.DtiClientRoute(meta.getRoute(), builder);
     }
     validate(param) {
@@ -70,7 +80,7 @@ class DtiClientCaller {
         let confHeaderBuilder = this.builder.getHeader(this.meta.getRoute().getFullname());
         if (confHeaderBuilder) {
             let confHeaders = confHeaderBuilder(this.meta);
-            headers = Object.assign(Object.assign({}, headers), confHeaders);
+            headers = { ...headers, ...confHeaders };
         }
         if (m === dti_core_1.DtiMode.BFrom) {
             headers["Content-Type"] = "application/x-www-form-urlencoded";
@@ -80,29 +90,57 @@ class DtiClientCaller {
         }
         return headers;
     }
+    async signature(data) {
+        const nonce = '' + getRandomInt(10000, 99999);
+        const timestamp = '' + Math.round(Date.now() / 1000);
+        const secretResolver = this.builder.getSignatureResolver();
+        if (secretResolver) {
+            const secret = await secretResolver();
+            if (secret) {
+                const signature = await hmacSignBase64(secret, `${timestamp}.${nonce}.${data}`);
+                return {
+                    nonce, timestamp, signature
+                };
+            }
+        }
+        return {
+            nonce, timestamp,
+            signature: ''
+        };
+    }
     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* () {
-            let resp = yield this.callRaw(param);
-            return yield (0, errorhandle_1.responseHandle)(resp);
-        });
+    async call(param) {
+        let resp = await this.callRaw(param);
+        return await (0, errorhandle_1.responseHandle)(resp);
     }
-    callRaw(param) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.validate(param);
-            let url = this.getUrl();
-            let query = this.getQeury(param);
-            let method = this.getMethod();
-            let headers = this.getHeaders(param);
-            let body = this.getBody(param);
-            return yield (0, cross_fetch_1.fetch)(url + (query ? `?${query}` : ''), {
-                method, headers, body
-            });
+    async callRaw(param) {
+        this.validate(param);
+        let url = this.getUrl();
+        let query = this.getQeury(param);
+        let method = this.getMethod();
+        let headers = this.getHeaders(param);
+        let body = this.getBody(param);
+        const signData = this.meta.sign(param);
+        if (signData) {
+            const { nonce, signature, timestamp } = await this.signature(signData);
+            if (signature) {
+                // console.log('method', method)
+                // console.log('------------method', method, this.meta.getFullname())
+                // console.log('timestamp', timestamp)
+                // console.log('nonce', nonce)
+                // console.log('signature', signature)
+                headers["X-DTI-Timestamp"] = timestamp;
+                headers["X-DTI-Nonce"] = nonce;
+                headers["X-DTI-Signature"] = signature;
+            }
+        }
+        return await (0, cross_fetch_1.fetch)(url + (query ? `?${query}` : ''), {
+            method, headers, body
         });
     }
 }

package/client.js

@@ -1,19 +1,11 @@
 "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 {
+    builder;
     constructor(builder) {
         this.builder = builder;
     }
@@ -23,26 +15,24 @@ 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();
-        });
+    async bundle(m1, m2, m3, m4, m5, m6) {
+        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 await new bundler_1.DtiClientBandler(bundleMetas, this.builder).call();
     }
 }
 exports.DtiClient = DtiClient;

package/errorhandle.js

@@ -1,65 +1,54 @@
 "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.responseHandle = void 0;
 const exception_1 = require("@napp/exception");
-function responseHandle(resp, parser) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            let rsu = yield resp.text();
-            if (resp.ok) {
-                if (rsu) {
-                    try {
-                        let value = JSON.parse(rsu);
-                        return value;
-                    }
-                    catch (error) {
-                        throw new exception_1.Exception(rsu, {
-                            kind: 'serviceunavailable',
-                        });
-                    }
-                }
-                return void 0;
-            }
+async function responseHandle(resp, parser) {
+    try {
+        let rsu = await resp.text();
+        if (resp.ok) {
             if (rsu) {
-                let err;
                 try {
-                    let errObject = JSON.parse(rsu);
-                    if (parser) {
-                        let e1 = parser(errObject);
-                        if (e1) {
-                            err = e1;
-                        }
-                        else {
-                            err = exception_1.Exception.from(errObject);
-                        }
-                    }
-                    else {
-                        err = exception_1.Exception.from(errObject);
-                    }
+                    let value = JSON.parse(rsu);
+                    return value;
                 }
                 catch (error) {
-                    err = new exception_1.Exception(rsu, {
+                    throw new exception_1.Exception(rsu, {
                         kind: 'serviceunavailable',
                     });
                 }
-                throw err;
             }
-            throw new exception_1.Exception(`status=${resp.status}. ${resp.statusText}`, {
-                kind: 'serviceunavailable',
-            });
+            return void 0;
         }
-        catch (error) {
-            throw exception_1.Exception.from(error);
+        if (rsu) {
+            let err;
+            try {
+                let errObject = JSON.parse(rsu);
+                if (parser) {
+                    let e1 = parser(errObject);
+                    if (e1) {
+                        err = e1;
+                    }
+                    else {
+                        err = exception_1.Exception.from(errObject);
+                    }
+                }
+                else {
+                    err = exception_1.Exception.from(errObject);
+                }
+            }
+            catch (error) {
+                err = new exception_1.Exception(rsu, {
+                    kind: 'serviceunavailable',
+                });
+            }
+            throw err;
         }
-    });
+        throw new exception_1.Exception(`status=${resp.status}. ${resp.statusText}`, {
+            kind: 'serviceunavailable',
+        });
+    }
+    catch (error) {
+        throw exception_1.Exception.from(error);
+    }
 }
 exports.responseHandle = responseHandle;

package/esm/builder.d.ts

@@ -0,0 +1,19 @@
+import { DtiAction, DtiRoute } from "@napp/dti-core";
+import { DtiClient } from "./client";
+export interface ODtiClientHeaderBuilder {
+    (action: DtiAction<any, any>): Record<string, string>;
+}
+export declare class DtiClientBuilder {
+    private _baseUrls;
+    private _headers;
+    baseUrl(route: DtiRoute, url: string): this;
+    getBaseUrl(name: string): string | undefined;
+    header(route: DtiRoute, builder: ODtiClientHeaderBuilder): this;
+    getHeader(name: string): ODtiClientHeaderBuilder | undefined;
+    private signatureSecretResolver;
+    signatureSecret(resolver: {
+        (): Promise<string>;
+    } | undefined): this;
+    getSignatureResolver(): (() => Promise<string>) | undefined;
+    build(): DtiClient;
+}

package/esm/builder.js

@@ -0,0 +1,39 @@
+import { TreeNamer } from "./tree";
+import { DtiClient } from "./client";
+export class DtiClientBuilder {
+    _baseUrls = new TreeNamer("root");
+    _headers = new TreeNamer("root");
+    baseUrl(route, url) {
+        this._baseUrls.set(route.getFullname(), url);
+        return this;
+    }
+    getBaseUrl(name) {
+        let note = this._baseUrls.findParent(name);
+        if (note) {
+            return note.getValue();
+        }
+        return undefined;
+    }
+    header(route, builder) {
+        this._headers.set(route.getFullname(), builder);
+        return this;
+    }
+    getHeader(name) {
+        let note = this._headers.findParent(name);
+        if (note) {
+            return note.getValue();
+        }
+        return undefined;
+    }
+    signatureSecretResolver = undefined;
+    signatureSecret(resolver) {
+        this.signatureSecretResolver = resolver;
+        return this;
+    }
+    getSignatureResolver() {
+        return this.signatureSecretResolver;
+    }
+    build() {
+        return new DtiClient(this);
+    }
+}

package/esm/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;
+    private base62;
+    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;
+}

package/esm/bundler.js

@@ -0,0 +1,95 @@
+import { DtiMode, Base62 } from "@napp/dti-core";
+import { Exception } from "@napp/exception";
+import { fetch } from "cross-fetch";
+import { responseHandle } from "./errorhandle";
+export class DtiClientBandler {
+    bundleMetas;
+    builder;
+    base62 = new Base62();
+    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 === DtiMode.BFrom || m === 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 = { ...headers, ..._headers };
+            }
+        }
+        headers["Content-Type"] = "application/json";
+        return headers;
+    }
+    async call() {
+        this.validate();
+        let method = this.getMethod();
+        if (method === 'get') {
+            return await this.callGet();
+        }
+        return await this.callPost();
+    }
+    async callGet() {
+        try {
+            let baseUrl = this.getBase();
+            let param = this.getParam();
+            let headers = this.getHeaders();
+            let p = this.base62.encode(JSON.stringify(param));
+            let q = new URLSearchParams({ p }).toString();
+            let resp = await fetch(`${baseUrl}/__bundler_get__?${q}`, {
+                method: 'get', headers
+            });
+            return await responseHandle(resp);
+        }
+        catch (error) {
+            throw Exception.from(error);
+        }
+    }
+    async callPost() {
+        try {
+            let baseUrl = this.getBase();
+            let param = this.getParam();
+            let headers = this.getHeaders();
+            let resp = await fetch(`${baseUrl}/__bundler_post__`, {
+                method: 'post', headers, body: JSON.stringify(param)
+            });
+            return await responseHandle(resp);
+        }
+        catch (error) {
+            throw Exception.from(error);
+        }
+    }
+}

package/esm/caller.d.ts

@@ -0,0 +1,20 @@
+import { DtiAction } from "@napp/dti-core";
+import { DtiClientBuilder } from "./builder";
+import { BundleMeta } from "./bundler";
+export declare class DtiClientCaller<RESULT, PARAM> {
+    private meta;
+    private builder;
+    private base62;
+    private routeClient;
+    constructor(meta: DtiAction<RESULT, PARAM>, builder: DtiClientBuilder);
+    validate(param: PARAM): void;
+    private getMethod;
+    private getBody;
+    private getQeury;
+    private getHeaders;
+    private signature;
+    private getUrl;
+    bundler(param: PARAM): BundleMeta<RESULT, PARAM>;
+    call(param: PARAM): Promise<RESULT>;
+    callRaw(param: PARAM): Promise<Response>;
+}

package/esm/caller.js

@@ -0,0 +1,143 @@
+import { DtiMode, Base62 } from "@napp/dti-core";
+import { fetch } from "cross-fetch";
+import { DtiClientRoute } from "./route";
+import { responseHandle } from "./errorhandle";
+function getRandomInt(min, max) {
+    const minCeiled = Math.ceil(min);
+    const maxFloored = Math.floor(max);
+    // The maximum is exclusive and the minimum is inclusive
+    return Math.floor(Math.random() * (maxFloored - minCeiled) + minCeiled);
+}
+async function hmacSignBase64(secret, data) {
+    const enc = new TextEncoder();
+    const key = await crypto.subtle.importKey("raw", enc.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    const sigBuf = await crypto.subtle.sign("HMAC", key, enc.encode(data));
+    const sigBytes = new Uint8Array(sigBuf);
+    // base64 encode
+    let bin = "";
+    sigBytes.forEach(b => (bin += String.fromCharCode(b)));
+    return btoa(bin);
+}
+export class DtiClientCaller {
+    meta;
+    builder;
+    base62 = new Base62();
+    routeClient;
+    constructor(meta, builder) {
+        this.meta = meta;
+        this.builder = builder;
+        this.routeClient = new DtiClientRoute(meta.getRoute(), builder);
+    }
+    validate(param) {
+        this.meta.validate(param);
+    }
+    getMethod() {
+        let m = this.meta.getMode();
+        if (m === DtiMode.QString || m === DtiMode.QJson) {
+            return 'get';
+        }
+        return 'post';
+    }
+    getBody(param) {
+        let m = this.meta.getMode();
+        if (m === DtiMode.BJson) {
+            if (param) {
+                return JSON.stringify(param);
+            }
+        }
+        if (m === DtiMode.BFrom) {
+            // const formData = new FormData();
+            // Object.keys(param as any).forEach(key => formData.append(key, (param as any)[key]));
+            if (param) {
+                return new URLSearchParams(param).toString();
+            }
+        }
+        return undefined;
+    }
+    getQeury(param) {
+        let m = this.meta.getMode();
+        if (m === DtiMode.QJson) {
+            if (param) {
+                let p = this.base62.encode(JSON.stringify(param));
+                return new URLSearchParams({ p }).toString();
+            }
+        }
+        else if (m === DtiMode.QString) {
+            if (param) {
+                let json = JSON.stringify(param);
+                let obj = JSON.parse(json);
+                return new URLSearchParams(obj).toString();
+            }
+        }
+        return undefined;
+    }
+    getHeaders(param) {
+        let m = this.meta.getMode();
+        let headers = {};
+        let confHeaderBuilder = this.builder.getHeader(this.meta.getRoute().getFullname());
+        if (confHeaderBuilder) {
+            let confHeaders = confHeaderBuilder(this.meta);
+            headers = { ...headers, ...confHeaders };
+        }
+        if (m === DtiMode.BFrom) {
+            headers["Content-Type"] = "application/x-www-form-urlencoded";
+        }
+        else {
+            headers["Content-Type"] = "application/json";
+        }
+        return headers;
+    }
+    async signature(data) {
+        const nonce = '' + getRandomInt(10000, 99999);
+        const timestamp = '' + Math.round(Date.now() / 1000);
+        const secretResolver = this.builder.getSignatureResolver();
+        if (secretResolver) {
+            const secret = await secretResolver();
+            if (secret) {
+                const signature = await hmacSignBase64(secret, `${timestamp}.${nonce}.${data}`);
+                return {
+                    nonce, timestamp, signature
+                };
+            }
+        }
+        return {
+            nonce, timestamp,
+            signature: ''
+        };
+    }
+    getUrl() {
+        return this.routeClient.buildUrl(this.meta.getPath());
+    }
+    bundler(param) {
+        return { meta: this.meta, param };
+    }
+    async call(param) {
+        let resp = await this.callRaw(param);
+        return await responseHandle(resp);
+    }
+    async callRaw(param) {
+        this.validate(param);
+        let url = this.getUrl();
+        let query = this.getQeury(param);
+        let method = this.getMethod();
+        let headers = this.getHeaders(param);
+        let body = this.getBody(param);
+        const signData = this.meta.sign(param);
+        if (signData) {
+            const { nonce, signature, timestamp } = await this.signature(signData);
+            if (signature) {
+                // console.log('method', method)
+                // console.log('------------method', method, this.meta.getFullname())
+                // console.log('timestamp', timestamp)
+                // console.log('nonce', nonce)
+                // console.log('signature', signature)
+                headers["X-DTI-Timestamp"] = timestamp;
+                headers["X-DTI-Nonce"] = nonce;
+                headers["X-DTI-Signature"] = signature;
+            }
+        }
+        return await fetch(url + (query ? `?${query}` : ''), {
+            method, headers, body
+        });
+    }
+}

package/esm/client.d.ts

@@ -0,0 +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/esm/client.js

@@ -0,0 +1,34 @@
+import { DtiClientRoute } from "./route";
+import { DtiClientCaller } from "./caller";
+import { DtiClientBandler } from "./bundler";
+export class DtiClient {
+    builder;
+    constructor(builder) {
+        this.builder = builder;
+    }
+    dti(meta) {
+        return new DtiClientCaller(meta, this.builder);
+    }
+    buildUrl(route, actionPath) {
+        return new DtiClientRoute(route, this.builder).buildUrl(actionPath);
+    }
+    async bundle(m1, m2, m3, m4, m5, m6) {
+        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 await new DtiClientBandler(bundleMetas, this.builder).call();
+    }
+}

package/esm/errorhandle.d.ts

@@ -0,0 +1,2 @@
+import { Exception } from "@napp/exception";
+export declare function responseHandle<T>(resp: Response, parser?: (errObject: any) => Exception | undefined): Promise<T>;

package/esm/errorhandle.js

@@ -0,0 +1,50 @@
+import { Exception } from "@napp/exception";
+export async function responseHandle(resp, parser) {
+    try {
+        let rsu = await resp.text();
+        if (resp.ok) {
+            if (rsu) {
+                try {
+                    let value = JSON.parse(rsu);
+                    return value;
+                }
+                catch (error) {
+                    throw new Exception(rsu, {
+                        kind: 'serviceunavailable',
+                    });
+                }
+            }
+            return void 0;
+        }
+        if (rsu) {
+            let err;
+            try {
+                let errObject = JSON.parse(rsu);
+                if (parser) {
+                    let e1 = parser(errObject);
+                    if (e1) {
+                        err = e1;
+                    }
+                    else {
+                        err = Exception.from(errObject);
+                    }
+                }
+                else {
+                    err = Exception.from(errObject);
+                }
+            }
+            catch (error) {
+                err = new Exception(rsu, {
+                    kind: 'serviceunavailable',
+                });
+            }
+            throw err;
+        }
+        throw new Exception(`status=${resp.status}. ${resp.statusText}`, {
+            kind: 'serviceunavailable',
+        });
+    }
+    catch (error) {
+        throw Exception.from(error);
+    }
+}

package/esm/index.d.ts

@@ -0,0 +1,6 @@
+export * from './builder';
+export * from './caller';
+export * from './client';
+export * from './route';
+export * from './tree';
+export * from './errorhandle';

package/esm/index.js

@@ -0,0 +1,6 @@
+export * from './builder';
+export * from './caller';
+export * from './client';
+export * from './route';
+export * from './tree';
+export * from './errorhandle';

package/esm/route.d.ts

@@ -0,0 +1,8 @@
+import { DtiRoute } from "@napp/dti-core";
+import { DtiClientBuilder } from "./builder";
+export declare class DtiClientRoute {
+    private meta;
+    private builder;
+    constructor(meta: DtiRoute, builder: DtiClientBuilder);
+    buildUrl(action: string): string;
+}

package/esm/route.js

@@ -0,0 +1,12 @@
+export class DtiClientRoute {
+    meta;
+    builder;
+    constructor(meta, builder) {
+        this.meta = meta;
+        this.builder = builder;
+    }
+    buildUrl(action) {
+        let base = this.builder.getBaseUrl(this.meta.getFullname()) || '';
+        return base + this.meta.getPaths().join('') + action;
+    }
+}

package/esm/tree.d.ts

@@ -0,0 +1,20 @@
+export interface ITreeNamer<T> {
+    name: string;
+    parent?: string;
+    value?: T;
+    childs?: ITreeNamer<T>[];
+}
+export declare class TreeNamer<T> {
+    private name;
+    private parent?;
+    constructor(name: string, parent?: TreeNamer<T> | undefined);
+    private value?;
+    private childs?;
+    set(name: string, value: T): this;
+    findEqual(name: string): TreeNamer<T> | undefined;
+    findParent(name: string): TreeNamer<T>;
+    getValue(): T | undefined;
+    private getOrCreate;
+    private toObj;
+    print(): string;
+}

package/esm/tree.js

@@ -0,0 +1,88 @@
+export class TreeNamer {
+    name;
+    parent;
+    constructor(name, parent) {
+        this.name = name;
+        this.parent = parent;
+    }
+    value;
+    childs;
+    set(name, value) {
+        let names = (name || '').split('.').filter(it => !!it);
+        let curr = this;
+        while (names.length > 0) {
+            let name = names.shift() || '';
+            curr = curr.getOrCreate(name);
+        }
+        curr.value = value;
+        return this;
+    }
+    findEqual(name) {
+        let names = (name || '').split('.').filter(it => !!it);
+        let curr = this;
+        while (names.length > 0) {
+            let name = names.shift() || '';
+            if (curr.childs) {
+                if (name in curr.childs) {
+                    curr = curr.childs[name];
+                }
+                else {
+                    return undefined;
+                }
+            }
+        }
+        return curr;
+    }
+    findParent(name) {
+        let names = (name || '').split('.').filter(it => !!it);
+        let curr = this;
+        while (names.length > 0) {
+            let name = names.shift() || '';
+            if (curr.childs) {
+                if (name in curr.childs) {
+                    curr = curr.childs[name];
+                }
+                else {
+                    return curr;
+                }
+            }
+        }
+        return curr;
+    }
+    getValue() {
+        if (this.value) {
+            return this.value;
+        }
+        if (this.parent) {
+            return this.parent.getValue();
+        }
+        return undefined;
+    }
+    getOrCreate(name) {
+        this.childs = this.childs || {};
+        if (name in this.childs) {
+            return this.childs[name];
+        }
+        return this.childs[name] = new TreeNamer(name, this);
+    }
+    toObj() {
+        let obj = {
+            name: this.name,
+            parent: this.parent?.name,
+            value: this.value
+        };
+        if (this.childs) {
+            obj.childs = [];
+            for (let p of Object.keys(this.childs)) {
+                let it = this.childs[p];
+                if (it && it.name && typeof it.toObj === 'function' && typeof it.getOrCreate === 'function') {
+                    obj.childs.push(it.toObj());
+                }
+            }
+        }
+        return obj;
+    }
+    print() {
+        return JSON.stringify(this.toObj(), null, 4);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@napp/dti-client",
-    "version": "4.4.4",
+    "version": "4.5.2",
     "description": "data transaction interface client 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",
@@ -16,7 +24,7 @@
     "author": "Farcek <farcek@gmail.com>",
     "license": "ISC",
     "dependencies": {
-        "@napp/dti-core": "4.4.4"
+        "@napp/dti-core": "4.5.2"
     },
     "peerDependencies": {
         "@napp/exception": "^9.1.4",

package/route.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DtiClientRoute = void 0;
 class DtiClientRoute {
+    meta;
+    builder;
     constructor(meta, builder) {
         this.meta = meta;
         this.builder = builder;

package/tree.js

@@ -2,10 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeNamer = void 0;
 class TreeNamer {
+    name;
+    parent;
     constructor(name, parent) {
         this.name = name;
         this.parent = parent;
     }
+    value;
+    childs;
     set(name, value) {
         let names = (name || '').split('.').filter(it => !!it);
         let curr = this;
@@ -65,10 +69,9 @@ class TreeNamer {
         return this.childs[name] = new TreeNamer(name, this);
     }
     toObj() {
-        var _a;
         let obj = {
             name: this.name,
-            parent: (_a = this.parent) === null || _a === void 0 ? void 0 : _a.name,
+            parent: this.parent?.name,
             value: this.value
         };
         if (this.childs) {