@napp/dti-core 3.0.7 → 4.0.1

package/action.d.ts

@@ -0,0 +1,21 @@
+import { DtiMode } from "./common";
+import { DtiRoute } from "./route";
+interface ODtiAction<RESULT, PARAM> {
+    name: string;
+    route: DtiRoute;
+    mode?: DtiMode;
+    path?: string;
+    validate?: (p: PARAM) => void;
+}
+export declare class DtiAction<RESULT, PARAM> {
+    private opt;
+    private constructor();
+    getName(): string;
+    getRoute(): DtiRoute;
+    getMode(): DtiMode;
+    getPath(): string;
+    getFullname(): string;
+    validate(p: PARAM): void;
+    static define<RESULT, PARAM>(opt: ODtiAction<RESULT, PARAM>): DtiAction<RESULT, PARAM>;
+}
+export {};

package/action.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtiAction = void 0;
+const common_1 = require("./common");
+class DtiAction {
+    constructor(opt) {
+        this.opt = opt;
+        opt.route.regAction(this);
+    }
+    getName() {
+        return this.opt.name;
+    }
+    getRoute() {
+        return this.opt.route;
+    }
+    getMode() {
+        return this.opt.mode || common_1.DtiMode.QString;
+    }
+    getPath() {
+        return '/' + (this.opt.path || this.getName());
+    }
+    getFullname() {
+        return `${this.getRoute().getFullname()}.${this.getName()}`;
+    }
+    validate(p) {
+        if (this.opt.validate) {
+            this.opt.validate(p);
+        }
+    }
+    static define(opt) {
+        return new DtiAction(opt);
+    }
+}
+exports.DtiAction = DtiAction;

package/common.d.ts

@@ -1,26 +1,6 @@
-export declare enum DtiMode {
-    QJson = "qjson",
-    QStr = "qstr",
-    BJson = "bjson",
-    BForm = "bform"
-}
-export interface Serializer<T> {
-    encode: (param: T) => string;
-    decode: (text: string) => T;
-}
-export interface DtiOption<RES, RQ = void, RB = void> {
-    name: string;
-    role?: (q: RQ, b: RB) => string;
-    path?: string;
-    method?: 'get' | 'post';
-    /**
-     * default: json
-     */
-    bodyMode?: string;
-    /**
-     * default: base64
-     */
-    queryMode?: string;
-    checkQ?: (q: RQ) => void;
-    checkB?: (b: RB) => void;
-}
+export declare enum DtiMode {
+    QString = 1,
+    QJson = 2,
+    BJson = 3,
+    BFrom = 4
+}

package/common.js

@@ -1,10 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DtiMode = void 0;
-var DtiMode;
-(function (DtiMode) {
-    DtiMode["QJson"] = "qjson";
-    DtiMode["QStr"] = "qstr";
-    DtiMode["BJson"] = "bjson";
-    DtiMode["BForm"] = "bform";
-})(DtiMode = exports.DtiMode || (exports.DtiMode = {}));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtiMode = void 0;
+var DtiMode;
+(function (DtiMode) {
+    DtiMode[DtiMode["QString"] = 1] = "QString";
+    DtiMode[DtiMode["QJson"] = 2] = "QJson";
+    DtiMode[DtiMode["BJson"] = 3] = "BJson";
+    DtiMode[DtiMode["BFrom"] = 4] = "BFrom";
+})(DtiMode = exports.DtiMode || (exports.DtiMode = {}));

package/error.d.ts

@@ -0,0 +1,21 @@
+export interface IDtiError {
+    code: string;
+    message: string;
+}
+export declare class DtiError extends Error implements IDtiError {
+    code: string;
+    constructor(code: string, message: string);
+    toPlanObject(): {
+        code: string;
+        message: string;
+    };
+    toJson(): {
+        code: string;
+        message: string;
+    };
+    static fromCode(code: string, obj: any): DtiError;
+    static from(obj: any): DtiError;
+}
+export declare class DtiErrorUnknown extends DtiError {
+    constructor(message: string);
+}

package/error.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtiErrorUnknown = exports.DtiError = void 0;
+class DtiError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'DtiError';
+        Object.setPrototypeOf(this, DtiError.prototype);
+    }
+    toPlanObject() {
+        return {
+            code: this.code,
+            message: this.message
+        };
+    }
+    toJson() {
+        return this.toPlanObject();
+    }
+    static fromCode(code, obj) {
+        if (obj) {
+            if (obj instanceof DtiError) {
+                return new DtiError(code, obj.message);
+            }
+            if (obj instanceof Error) {
+                return new DtiError(code, obj.message);
+            }
+            if (obj.message) {
+                return new DtiError(code, '' + obj.message);
+            }
+            if (obj.error) {
+                return new DtiError(code, '' + obj.error);
+            }
+            return new DtiError(code, '' + obj);
+        }
+        return new DtiError(code, "undefined error");
+    }
+    static from(obj) {
+        if (obj) {
+            if (obj instanceof DtiError) {
+                return obj;
+            }
+            if (obj instanceof Error) {
+                if ('code' in obj) {
+                    return new DtiError(`${obj.code}`, `${obj.message}`);
+                }
+                return new DtiError(obj.name, obj.message);
+            }
+            if (obj.code && obj.message) {
+                return new DtiError('' + obj.code, '' + obj.message);
+            }
+            if (obj.code && obj.error) {
+                return new DtiError('' + obj.code, '' + obj.error);
+            }
+            if (obj.name && obj.message) {
+                return new DtiError('' + obj.name, '' + obj.message);
+            }
+            if (obj.name && obj.error) {
+                return new DtiError('' + obj.name, '' + obj.error);
+            }
+            if (obj.code) {
+                return new DtiError('' + obj.code, 'error code=' + obj.code);
+            }
+            if (obj.name) {
+                return new DtiError('' + obj.name, 'error code=' + obj.name);
+            }
+            if (obj.message) {
+                return new DtiError('nocode', '' + obj.message);
+            }
+            if (obj.error) {
+                return new DtiError('nocode', '' + obj.error);
+            }
+            return new DtiErrorUnknown('unknown error; error=' + obj);
+        }
+        return new DtiErrorUnknown("undefined error");
+    }
+}
+exports.DtiError = DtiError;
+class DtiErrorUnknown extends DtiError {
+    constructor(message) {
+        super('unknown', message);
+        this.name = 'DtiErrorUnknown';
+        Object.setPrototypeOf(this, DtiErrorUnknown.prototype);
+    }
+}
+exports.DtiErrorUnknown = DtiErrorUnknown;

package/index.d.ts

@@ -1,2 +1,4 @@
-export * from './common';
-export * from './meta';
+export * from './common';
+export * from './action';
+export * from './route';
+export * from './error';

package/index.js

@@ -1,14 +1,20 @@
-"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("./common"), exports);
-__exportStar(require("./meta"), 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("./common"), exports);
+__exportStar(require("./action"), exports);
+__exportStar(require("./route"), exports);
+__exportStar(require("./error"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@napp/dti-core",
-    "version": "3.0.7",
+    "version": "4.0.1",
     "description": "data transaction interface core library",
     "types": "index.d.ts",
     "main": "index.js",

package/route.d.ts

@@ -0,0 +1,21 @@
+import { DtiAction } from "./action";
+export interface ODtiRoute {
+    path?: string;
+}
+export declare class DtiRoute {
+    name: string;
+    private constructor();
+    private _parent?;
+    private _children?;
+    private _actions?;
+    private path?;
+    getChildroutes(): DtiRoute[];
+    regChildroute(route: DtiRoute): this;
+    getActions(): DtiAction<any, any>[];
+    regAction<RESULT, PARAM>(action: DtiAction<RESULT, PARAM>): this;
+    getNames(): string[];
+    getFullname(): string;
+    getPaths(): string[];
+    getLocalPath(): string;
+    static factory(name: string, opt?: ODtiRoute): DtiRoute;
+}

package/route.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtiRoute = void 0;
+class DtiRoute {
+    constructor(name) {
+        this.name = name;
+    }
+    getChildroutes() {
+        return this._children || [];
+    }
+    regChildroute(route) {
+        if (route._parent) {
+            throw new Error(`cannot register the route ("${route.name}") on route ("${this.name}"). already registered #"${route._parent.name}"  `);
+        }
+        route._parent = this;
+        this._children = [...this._children || [], route];
+        return this;
+    }
+    getActions() {
+        return this._actions || [];
+    }
+    regAction(action) {
+        // if (action.getRoute()) {
+        //     throw new Error(`the action(${action.name}) already registed. registered route(${action.route.name})`)
+        // }
+        let name = action.getName();
+        for (let a of this._actions || []) {
+            if (a.getName() === name) {
+                throw new Error(`the action(${name}) is registered`);
+            }
+        }
+        this._actions = [...this._actions || [], action];
+        return this;
+    }
+    getNames() {
+        if (this._parent) {
+            let paths = this._parent.getNames();
+            return [...paths, this.name];
+        }
+        return [this.name];
+    }
+    getFullname() {
+        return this.getNames().join('.');
+    }
+    getPaths() {
+        if (this._parent) {
+            let paths = this._parent.getPaths();
+            return [...paths, this.getLocalPath()];
+        }
+        return [this.getLocalPath()];
+    }
+    getLocalPath() {
+        return `/${this.path || this.name}`;
+    }
+    static factory(name, opt) {
+        let route = new DtiRoute(name);
+        if (opt === null || opt === void 0 ? void 0 : opt.path) {
+            route.path = opt.path;
+        }
+        return route;
+    }
+}
+exports.DtiRoute = DtiRoute;

package/meta.d.ts

@@ -1,13 +0,0 @@
-import { DtiOption } from "./common";
-export declare class Dti<RES, PQ, PB> {
-    private opt;
-    constructor(opt: DtiOption<RES, PQ, PB>);
-    get name(): string;
-    get method(): "get" | "post";
-    get path(): string;
-    get queryMode(): string;
-    get bodyMode(): string;
-    checkQ(q: PQ): void;
-    checkB(b: PB): void;
-    static define<RES, PQ, PB>(opt: DtiOption<RES, PQ, PB>): Dti<RES, PQ, PB>;
-}

package/meta.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Dti = void 0;
-var Dti = /** @class */ (function () {
-    function Dti(opt) {
-        this.opt = opt;
-    }
-    Object.defineProperty(Dti.prototype, "name", {
-        get: function () {
-            return this.opt.name;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Dti.prototype, "method", {
-        get: function () {
-            var method = this.opt.method;
-            if (method === 'get')
-                return 'get';
-            if (method === 'post')
-                return 'post';
-            if (this.opt.checkB)
-                return 'post';
-            return 'get';
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Dti.prototype, "path", {
-        get: function () {
-            var _a = this.opt, name = _a.name, path = _a.path;
-            if (path)
-                return path;
-            return '/' + name;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Dti.prototype, "queryMode", {
-        get: function () {
-            return this.opt.queryMode || '';
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Dti.prototype, "bodyMode", {
-        get: function () {
-            return this.opt.bodyMode || '';
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Dti.prototype.checkQ = function (q) {
-        if (this.opt.checkQ) {
-            this.opt.checkQ(q);
-        }
-    };
-    Dti.prototype.checkB = function (b) {
-        if (this.opt.checkB) {
-            this.opt.checkB(b);
-        }
-    };
-    Dti.define = function (opt) {
-        return new Dti(opt);
-    };
-    return Dti;
-}());
-exports.Dti = Dti;
-var m = Dti.define({
-    name: ''
-});