@napp/dti-client 4.4.4 → 4.4.5

package/esm/builder.d.ts

@@ -0,0 +1,14 @@
+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;
+    build(): DtiClient;
+}

package/esm/builder.js

@@ -0,0 +1,33 @@
+import { TreeNamer } from "./tree";
+import { DtiClient } from "./client";
+export class DtiClientBuilder {
+    constructor() {
+        this._baseUrls = new TreeNamer("root");
+        this._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;
+    }
+    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,93 @@
+import { DtiMode, Base62 } from "@napp/dti-core";
+import { Exception } from "@napp/exception";
+import { fetch } from "cross-fetch";
+import { responseHandle } from "./errorhandle";
+export class DtiClientBandler {
+    constructor(bundleMetas, builder) {
+        this.bundleMetas = bundleMetas;
+        this.builder = builder;
+        this.base62 = new Base62();
+    }
+    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,19 @@
+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 getUrl;
+    bundler(param: PARAM): BundleMeta<RESULT, PARAM>;
+    call(param: PARAM): Promise<RESULT>;
+    callRaw(param: PARAM): Promise<Response>;
+}

package/esm/caller.js

@@ -0,0 +1,92 @@
+import { DtiMode, Base62 } from "@napp/dti-core";
+import { fetch } from "cross-fetch";
+import { DtiClientRoute } from "./route";
+import { responseHandle } from "./errorhandle";
+export class DtiClientCaller {
+    constructor(meta, builder) {
+        this.meta = meta;
+        this.builder = builder;
+        this.base62 = new Base62();
+        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;
+    }
+    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);
+        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,33 @@
+import { DtiClientRoute } from "./route";
+import { DtiClientCaller } from "./caller";
+import { DtiClientBandler } from "./bundler";
+export class DtiClient {
+    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,10 @@
+export class DtiClientRoute {
+    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,84 @@
+export class TreeNamer {
+    constructor(name, parent) {
+        this.name = name;
+        this.parent = parent;
+    }
+    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.4.5",
     "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.4.5"
     },
     "peerDependencies": {
         "@napp/exception": "^9.1.4",