@napp/dti-client 3.0.8 → 4.0.1

package/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/builder.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+    }
+    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 client_1.DtiClient(this);
+    }
+}
+exports.DtiClientBuilder = DtiClientBuilder;

package/caller.d.ts

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

package/caller.js

@@ -0,0 +1,130 @@
+"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.DtiClientCaller = void 0;
+const dti_core_1 = require("@napp/dti-core");
+const cross_fetch_1 = require("cross-fetch");
+const base64url_1 = __importDefault(require("base64url"));
+const route_1 = require("./route");
+class DtiClientCaller {
+    constructor(meta, builder) {
+        this.meta = meta;
+        this.builder = builder;
+        this.routeClient = new route_1.DtiClientRoute(meta.getRoute(), builder);
+    }
+    validate(param) {
+        this.meta.validate(param);
+    }
+    getMethod() {
+        let m = this.meta.getMode();
+        if (m === dti_core_1.DtiMode.QString || m === dti_core_1.DtiMode.QJson) {
+            return 'get';
+        }
+        return 'post';
+    }
+    getBody(param) {
+        let m = this.meta.getMode();
+        if (m === dti_core_1.DtiMode.BJson) {
+            if (param) {
+                return JSON.stringify(param);
+            }
+        }
+        if (m === dti_core_1.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 === dti_core_1.DtiMode.QJson) {
+            if (param) {
+                let p = base64url_1.default.encode(JSON.stringify(param));
+                return new URLSearchParams({ p }).toString();
+            }
+        }
+        else if (m === dti_core_1.DtiMode.QString) {
+            if (param) {
+                return new URLSearchParams(param).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 = Object.assign(Object.assign({}, headers), confHeaders);
+        }
+        if (m === dti_core_1.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());
+    }
+    call(param) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.validate(param);
+            }
+            catch (error) {
+                throw dti_core_1.DtiError.fromCode('validation', error);
+            }
+            let url = this.getUrl();
+            let query = this.getQeury(param);
+            let method = this.getMethod();
+            let headers = this.getHeaders(param);
+            let body = this.getBody(param);
+            let resp = yield (0, cross_fetch_1.fetch)(url + (query ? `?${query}` : ''), {
+                method, headers, body
+            });
+            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.DtiClientCaller = DtiClientCaller;

package/client.d.ts

@@ -0,0 +1,9 @@
+import { DtiAction, DtiRoute } from "@napp/dti-core";
+import { DtiClientBuilder } from "./builder";
+import { DtiClientCaller } from "./caller";
+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;
+}

package/client.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtiClient = void 0;
+const route_1 = require("./route");
+const caller_1 = require("./caller");
+class DtiClient {
+    constructor(builder) {
+        this.builder = builder;
+    }
+    dti(meta) {
+        return new caller_1.DtiClientCaller(meta, this.builder);
+    }
+    buildUrl(route, actionPath) {
+        return new route_1.DtiClientRoute(route, this.builder).buildUrl(actionPath);
+    }
+}
+exports.DtiClient = DtiClient;

package/index.d.ts

@@ -1 +1,5 @@
-export * from './adapter';
+export * from './builder';
+export * from './caller';
+export * from './client';
+export * from './route';
+export * from './tree';

package/index.js

@@ -1,13 +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("./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("./builder"), exports);
+__exportStar(require("./caller"), exports);
+__exportStar(require("./client"), exports);
+__exportStar(require("./route"), exports);
+__exportStar(require("./tree"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@napp/dti-client",
-    "version": "3.0.8",
+    "version": "4.0.1",
     "description": "data transaction interface client library",
     "types": "index.d.ts",
     "main": "index.js",
@@ -12,6 +12,8 @@
     "author": "Farcek <farcek@gmail.com>",
     "license": "ISC",
     "dependencies": {
-        "@napp/dti-core": "3.0.8"
+        "@napp/dti-core": "4.0.1",
+        "base64url": "latest",
+        "cross-fetch": "latest"
     }
 }

package/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/route.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtiClientRoute = void 0;
+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;
+    }
+}
+exports.DtiClientRoute = DtiClientRoute;

package/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/tree.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeNamer = void 0;
+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() {
+        var _a;
+        let obj = {
+            name: this.name,
+            parent: (_a = this.parent) === null || _a === void 0 ? void 0 : _a.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);
+    }
+}
+exports.TreeNamer = TreeNamer;

package/adapter.d.ts

@@ -1,31 +0,0 @@
-import { Dti } from "@napp/dti-core";
-export interface ODtiClientAdapter {
-    caller: <RES, PQ, PB>(meta: Dti<RES, PQ, PB>, param: {
-        q?: PQ;
-        b?: PB;
-    }) => Promise<RES>;
-}
-export declare class DtiClientAdapter {
-    private opt;
-    constructor(opt: ODtiClientAdapter);
-    dti<RES, PQ, PB>(meta: Dti<RES, PQ, PB>): DtiClient<RES, PQ, PB>;
-}
-export interface ODtiClient {
-    adp: DtiClientAdapter;
-}
-export declare class DtiClient<RES, PQ, PB> {
-    private caller;
-    private meta;
-    constructor(caller: (param: {
-        q?: PQ;
-        b?: PB;
-    }) => Promise<RES>, meta: Dti<RES, PQ, PB>);
-    check(param: {
-        q?: PQ;
-        b?: PB;
-    }): void;
-    call(param: {
-        q?: PQ;
-        b?: PB;
-    }, checkIgnore?: boolean): Promise<RES>;
-}

package/adapter.js

@@ -1,85 +0,0 @@
-"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 __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DtiClient = exports.DtiClientAdapter = void 0;
-var DtiClientAdapter = /** @class */ (function () {
-    function DtiClientAdapter(opt) {
-        this.opt = opt;
-    }
-    DtiClientAdapter.prototype.dti = function (meta) {
-        var _this = this;
-        return new DtiClient(function (param) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.opt.caller(meta, param)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        }); }, meta);
-    };
-    return DtiClientAdapter;
-}());
-exports.DtiClientAdapter = DtiClientAdapter;
-var DtiClient = /** @class */ (function () {
-    function DtiClient(caller, meta) {
-        this.caller = caller;
-        this.meta = meta;
-    }
-    DtiClient.prototype.check = function (param) {
-        this.meta.checkQ(param.q);
-        this.meta.checkB(param.b);
-    };
-    DtiClient.prototype.call = function (param, checkIgnore) {
-        return __awaiter(this, void 0, void 0, function () {
-            var c;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        c = checkIgnore === true ? false : true;
-                        if (c) {
-                            this.check(param);
-                        }
-                        return [4 /*yield*/, this.caller(param)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    return DtiClient;
-}());
-exports.DtiClient = DtiClient;