oak-domain 3.0.3 → 3.0.4

package/lib/timers/vaccum.js

@@ -1,176 +1,111 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.vaccumEntities = void 0;
-var tslib_1 = require("tslib");
-var dayjs_1 = tslib_1.__importDefault(require("dayjs"));
-var fs_1 = require("fs");
-var filter_1 = require("../store/filter");
-var stream_1 = require("stream");
-var uuid_1 = require("../utils/uuid");
+const tslib_1 = require("tslib");
+const dayjs_1 = tslib_1.__importDefault(require("dayjs"));
+const fs_1 = require("fs");
+const filter_1 = require("../store/filter");
+const stream_1 = require("stream");
+const uuid_1 = require("../utils/uuid");
 /**
  * 删除数据库中的部分数据，减少体积
  * 一般只删除日志类数据
  * @param option
  */
-function vaccumEntities(option, context) {
-    return tslib_1.__awaiter(this, void 0, void 0, function () {
-        var entities, backupDir, _loop_1, entities_1, entities_1_1, ele, e_1_1;
-        var e_1, _a;
-        var _this = this;
-        return tslib_1.__generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    entities = option.entities, backupDir = option.backupDir;
-                    _loop_1 = function (ele) {
-                        var entity, filter, aliveLine, filter2, zip, now, backFile, fd_1, attributes_1, projection_1, attr, count_1, appendData_1, createGzip, gzip_1, source_1, destination_1, _c, _d, _e;
-                        var _f, _g;
-                        return tslib_1.__generator(this, function (_h) {
-                            switch (_h.label) {
-                                case 0:
-                                    entity = ele.entity, filter = ele.filter, aliveLine = ele.aliveLine;
-                                    filter2 = {
-                                        $$createAt$$: {
-                                            $lt: aliveLine,
-                                        },
-                                    };
-                                    if (filter) {
-                                        filter2 = (0, filter_1.combineFilters)(entity, context.getSchema(), [filter2, filter]);
-                                    }
-                                    if (!(backupDir && process.env.OAK_PLATFORM === 'server')) return [3 /*break*/, 4];
-                                    zip = option.zip;
-                                    now = (0, dayjs_1.default)();
-                                    backFile = "".concat(backupDir, "/").concat(entity, "-").concat(now.format('YYYY-MM-DD HH:mm:ss'), ".csv");
-                                    if ((0, fs_1.existsSync)(backFile)) {
-                                        (0, fs_1.rmSync)(backFile);
-                                    }
-                                    fd_1 = (0, fs_1.openSync)(backFile, 'a');
-                                    attributes_1 = ['id', '$$createAt$$', '$$updateAt$$', '$$deleteAt$$'];
-                                    projection_1 = {
-                                        id: 1,
-                                        $$createAt$$: 1,
-                                        $$updateAt$$: 1,
-                                        $$deleteAt$$: 1,
-                                    };
-                                    for (attr in context.getSchema()[entity].attributes) {
-                                        Object.assign(projection_1, (_f = {},
-                                            _f[attr] = 1,
-                                            _f));
-                                        attributes_1.push(attr);
-                                    }
-                                    (0, fs_1.appendFileSync)(fd_1, attributes_1.join(','));
-                                    (0, fs_1.appendFileSync)(fd_1, '\n');
-                                    count_1 = 0;
-                                    appendData_1 = function (minCreateAt) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                        var filter3, rows, csvTxt, maxCreateAt;
-                                        return tslib_1.__generator(this, function (_a) {
-                                            switch (_a.label) {
-                                                case 0:
-                                                    filter3 = (0, filter_1.combineFilters)(entity, context.getSchema(), [filter2, {
-                                                            $$createAt$$: {
-                                                                $gt: minCreateAt,
-                                                            },
-                                                        }]);
-                                                    return [4 /*yield*/, context.select(entity, {
-                                                            data: projection_1,
-                                                            filter: filter3,
-                                                            sorter: [{
-                                                                    $attr: {
-                                                                        $$createAt$$: 1,
-                                                                    },
-                                                                    $direction: 'asc'
-                                                                }],
-                                                            indexFrom: 0,
-                                                            count: 1000,
-                                                        }, { includedDeleted: true })];
-                                                case 1:
-                                                    rows = _a.sent();
-                                                    csvTxt = rows.map(function (row) { return attributes_1.map(function (attr) { return JSON.stringify(row[attr]); }).join(','); }).join('\n');
-                                                    (0, fs_1.appendFileSync)(fd_1, csvTxt);
-                                                    (0, fs_1.appendFileSync)(fd_1, '\n');
-                                                    count_1 += rows.length;
-                                                    if (rows.length === 1000) {
-                                                        maxCreateAt = rows[999].$$createAt$$;
-                                                        return [2 /*return*/, appendData_1(maxCreateAt)];
-                                                    }
-                                                    return [2 /*return*/];
-                                            }
-                                        });
-                                    }); };
-                                    return [4 /*yield*/, appendData_1(0)];
-                                case 1:
-                                    _h.sent();
-                                    (0, fs_1.closeSync)(fd_1);
-                                    console.log("\u5907\u4EFD".concat(entity, "\u5BF9\u8C61\u5B8C\u6BD5\uFF0C\u5171\u5907\u4EFD\u4E86").concat(count_1, "\u884C\u6570\u636E"));
-                                    if (!(count_1 === 0)) return [3 /*break*/, 2];
-                                    (0, fs_1.rmSync)(backFile);
-                                    return [3 /*break*/, 4];
-                                case 2:
-                                    if (!zip) return [3 /*break*/, 4];
-                                    createGzip = require('zlib').createGzip;
-                                    gzip_1 = createGzip();
-                                    source_1 = (0, fs_1.createReadStream)(backFile);
-                                    destination_1 = (0, fs_1.createWriteStream)("".concat(backFile, ".zip"));
-                                    return [4 /*yield*/, new Promise(function (resolve, reject) {
-                                            (0, stream_1.pipeline)(source_1, gzip_1, destination_1, function (err) {
-                                                if (err) {
-                                                    reject(err);
-                                                }
-                                                else {
-                                                    resolve(undefined);
-                                                }
-                                            });
-                                        })];
-                                case 3:
-                                    _h.sent();
-                                    _h.label = 4;
-                                case 4:
-                                    _d = (_c = context).operate;
-                                    _e = [entity];
-                                    _g = {};
-                                    return [4 /*yield*/, (0, uuid_1.generateNewIdAsync)()];
-                                case 5: 
-                                // 将对应的数据删除
-                                return [4 /*yield*/, _d.apply(_c, _e.concat([(_g.id = _h.sent(),
-                                            _g.action = 'remove',
-                                            _g.data = {},
-                                            _g.filter = filter2,
-                                            _g), { deletePhysically: true }]))];
-                                case 6:
-                                    // 将对应的数据删除
-                                    _h.sent();
-                                    return [2 /*return*/];
-                            }
-                        });
-                    };
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 6, 7, 8]);
-                    entities_1 = tslib_1.__values(entities), entities_1_1 = entities_1.next();
-                    _b.label = 2;
-                case 2:
-                    if (!!entities_1_1.done) return [3 /*break*/, 5];
-                    ele = entities_1_1.value;
-                    return [5 /*yield**/, _loop_1(ele)];
-                case 3:
-                    _b.sent();
-                    _b.label = 4;
-                case 4:
-                    entities_1_1 = entities_1.next();
-                    return [3 /*break*/, 2];
-                case 5: return [3 /*break*/, 8];
-                case 6:
-                    e_1_1 = _b.sent();
-                    e_1 = { error: e_1_1 };
-                    return [3 /*break*/, 8];
-                case 7:
-                    try {
-                        if (entities_1_1 && !entities_1_1.done && (_a = entities_1.return)) _a.call(entities_1);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                    return [7 /*endfinally*/];
-                case 8: return [2 /*return*/];
+async function vaccumEntities(option, context) {
+    const { entities, backupDir } = option;
+    for (const ele of entities) {
+        const { entity, filter, aliveLine } = ele;
+        let filter2 = {
+            $$createAt$$: {
+                $lt: aliveLine,
+            },
+        };
+        if (filter) {
+            filter2 = (0, filter_1.combineFilters)(entity, context.getSchema(), [filter2, filter]);
+        }
+        if (backupDir && process.env.OAK_PLATFORM === 'server') {
+            // 使用mysqldump将待删除的数据备份出来
+            const { zip: zip } = option;
+            const now = (0, dayjs_1.default)();
+            const backFile = `${backupDir}/${entity}-${now.format('YYYY-MM-DD HH:mm:ss')}.csv`;
+            if ((0, fs_1.existsSync)(backFile)) {
+                (0, fs_1.rmSync)(backFile);
             }
-        });
-    });
+            const fd = (0, fs_1.openSync)(backFile, 'a');
+            const attributes = ['id', '$$createAt$$', '$$updateAt$$', '$$deleteAt$$'];
+            const projection = {
+                id: 1,
+                $$createAt$$: 1,
+                $$updateAt$$: 1,
+                $$deleteAt$$: 1,
+            };
+            for (const attr in context.getSchema()[entity].attributes) {
+                Object.assign(projection, {
+                    [attr]: 1,
+                });
+                attributes.push(attr);
+            }
+            (0, fs_1.appendFileSync)(fd, attributes.join(','));
+            (0, fs_1.appendFileSync)(fd, '\n');
+            let count = 0;
+            const appendData = async (minCreateAt) => {
+                const filter3 = (0, filter_1.combineFilters)(entity, context.getSchema(), [filter2, {
+                        $$createAt$$: {
+                            $gt: minCreateAt,
+                        },
+                    }]);
+                const rows = await context.select(entity, {
+                    data: projection,
+                    filter: filter3,
+                    sorter: [{
+                            $attr: {
+                                $$createAt$$: 1,
+                            },
+                            $direction: 'asc'
+                        }],
+                    indexFrom: 0,
+                    count: 1000,
+                }, { includedDeleted: true });
+                const csvTxt = rows.map((row) => attributes.map((attr) => JSON.stringify(row[attr])).join(',')).join('\n');
+                (0, fs_1.appendFileSync)(fd, csvTxt);
+                (0, fs_1.appendFileSync)(fd, '\n');
+                count += rows.length;
+                if (rows.length === 1000) {
+                    const maxCreateAt = rows[999].$$createAt$$;
+                    return appendData(maxCreateAt);
+                }
+            };
+            await appendData(0);
+            (0, fs_1.closeSync)(fd);
+            console.log(`备份${entity}对象完毕，共备份了${count}行数据`);
+            if (count === 0) {
+                (0, fs_1.rmSync)(backFile);
+            }
+            else if (zip) {
+                const { createGzip } = require('zlib');
+                const gzip = createGzip();
+                const source = (0, fs_1.createReadStream)(backFile);
+                const destination = (0, fs_1.createWriteStream)(`${backFile}.zip`);
+                await new Promise((resolve, reject) => {
+                    (0, stream_1.pipeline)(source, gzip, destination, (err) => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve(undefined);
+                        }
+                    });
+                });
+            }
+        }
+        // 将对应的数据删除
+        await context.operate(entity, {
+            id: await (0, uuid_1.generateNewIdAsync)(),
+            action: 'remove',
+            data: {},
+            filter: filter2,
+        }, { deletePhysically: true });
+    }
 }
 exports.vaccumEntities = vaccumEntities;

package/lib/triggers/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDynamicTriggers = void 0;
-var modi_1 = require("../store/modi");
+const modi_1 = require("../store/modi");
 function createDynamicTriggers(schema) {
     return (0, modi_1.createModiRelatedTriggers)(schema);
 }

package/lib/types/Action.d.ts

@@ -1,20 +1,20 @@
 import { CascadeRelationItem, EntityDict } from "./Entity";
 import { GenericAction } from '../actions/action';
-export declare type Action = string;
-export declare type State = string;
-export declare type ActionDef<A extends Action, S extends State> = {
+export type Action = string;
+export type State = string;
+export type ActionDef<A extends Action, S extends State> = {
     stm: {
         [a in A]: [p: S | S[], n: S];
     };
     is?: S;
 };
-export declare type ActionDictOfEntityDict<E extends EntityDict> = {
+export type ActionDictOfEntityDict<E extends EntityDict> = {
     [T in keyof E]?: {
         [A in keyof E[T]['OpSchema']]?: ActionDef<string, string>;
     };
 };
-export declare type CascadeActionItem = CascadeRelationItem;
-export declare type CascadeActionAuth<A extends Action = ''> = {
+export type CascadeActionItem = CascadeRelationItem;
+export type CascadeActionAuth<A extends Action = ''> = {
     [K in A | GenericAction]?: CascadeActionItem | (CascadeActionItem | CascadeActionItem[])[];
 };
-export declare type ActionOnRemove = 'setNull' | 'remove';
+export type ActionOnRemove = 'setNull' | 'remove';

package/lib/types/AppLoader.d.ts

@@ -1,9 +1,15 @@
+/// <reference types="node" />
+import { IncomingHttpHeaders } from "http";
 import { AsyncContext, AsyncRowStore } from "../store/AsyncRowStore";
-import { EntityDict } from "./Entity";
+import { EntityDict, OpRecord } from "./Entity";
 export declare abstract class AppLoader<ED extends EntityDict, Cxt extends AsyncContext<ED>> {
     protected path: string;
     constructor(path: string);
-    abstract execAspect(name: string, context: Cxt, params?: any): Promise<any>;
+    abstract execAspect(name: string, header?: IncomingHttpHeaders, contextString?: string, params?: any): Promise<{
+        opRecords?: OpRecord<ED>[];
+        message?: string;
+        result: any;
+    }>;
     abstract initialize(dropIfExists?: boolean): Promise<void>;
     abstract mount(): Promise<void>;
     abstract unmount(): Promise<void>;

package/lib/types/AppLoader.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AppLoader = void 0;
-var AppLoader = /** @class */ (function () {
-    function AppLoader(path) {
+class AppLoader {
+    path;
+    constructor(path) {
         this.path = path;
     }
-    return AppLoader;
-}());
+}
 exports.AppLoader = AppLoader;

package/lib/types/Aspect.d.ts

@@ -1,4 +1,4 @@
-import { EntityDict, SubDataDef } from "./Entity";
+import { EntityDict } from "./Entity";
 import { OpRecord } from "./Entity";
 import { AsyncContext } from "../store/AsyncRowStore";
 export interface Aspect<ED extends EntityDict, Cxt extends AsyncContext<ED>> {
@@ -10,6 +10,4 @@ export interface AspectWrapper<ED extends EntityDict, Cxt extends AsyncContext<E
         opRecords?: OpRecord<ED>[];
         message?: string | null;
     }>;
-    sub: (data: Array<SubDataDef<ED, keyof ED>>, callback: (records: OpRecord<ED>[], ids: string[]) => void) => Promise<void>;
-    unsub: (ids: string[]) => Promise<void>;
 }

package/lib/types/Auth.d.ts

@@ -2,23 +2,26 @@ import { CascadeActionAuth, CascadeRelationAuth, ActionOnRemove, SyncOrAsync } f
 import { AsyncContext } from "../store/AsyncRowStore";
 import { SyncContext } from "../store/SyncRowStore";
 import { EntityDict, OperateOption, SelectOption } from "../types/Entity";
-export declare type CheckerType = 'relation' | 'row' | 'data' | 'logical' | 'logicalRelation';
+import { ModiTurn } from './Trigger';
+export type CheckerType = 'relation' | 'row' | 'data' | 'logical' | 'logicalRelation' | 'logicalData';
 /**
  * conditionalFilter是指该action发生时，operation所操作的行中有满足conditionalFilter的行
  * 被转化成trigger的filter条件，详细可看trigger中的说明
  */
-export declare type DataChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
+export type DataChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
     type: 'data';
     entity: T;
+    mt?: ModiTurn;
     action: Omit<ED[T]['Action'], 'remove'> | Array<Omit<ED[T]['Action'], 'remove'>>;
     checker: (data: ED[T]['Create']['data'] | ED[T]['Update']['data'], context: Cxt) => SyncOrAsync<any>;
     conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => SyncOrAsync<ED[T]['Selection']['filter']>);
 };
-export declare type RowChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
+export type RowChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
     type: 'row';
     entity: T;
+    mt?: ModiTurn;
     action: Omit<ED[T]['Action'], 'create'> | Array<Omit<ED[T]['Action'], 'create'>>;
     filter: ED[T]['Selection']['filter'] | ((operation: ED[T]['Operation'] | ED[T]['Selection'], context: Cxt, option: OperateOption | SelectOption) => SyncOrAsync<ED[T]['Selection']['filter']>);
     errMsg?: string;
@@ -28,47 +31,40 @@ export declare type RowChecker<ED extends EntityDict, T extends keyof ED, Cxt ex
     };
     conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => SyncOrAsync<ED[T]['Update']['filter']>);
 };
-export declare type RelationChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
+export type RelationChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
     type: 'relation';
     entity: T;
+    mt?: ModiTurn;
     when?: 'after';
     action: ED[T]['Action'] | Array<ED[T]['Action']>;
     relationFilter: (operation: ED[T]['Operation'] | ED[T]['Selection'], context: Cxt, option: OperateOption | SelectOption) => SyncOrAsync<ED[T]['Selection']['filter']>;
     errMsg: string | ((operation: ED[T]['Operation'] | ED[T]['Selection'], context: Cxt, option?: OperateOption | SelectOption) => string);
     conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => SyncOrAsync<ED[T]['Selection']['filter']>);
 };
-export declare type LogicalChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
+export type LogicalChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
-    type: 'logical';
+    type: 'logical' | 'logicalData' | 'logicalRelation';
     when?: 'after';
+    mt?: ModiTurn;
     entity: T;
     action: ED[T]['Action'] | Array<ED[T]['Action']>;
     checker: (operation: ED[T]['Operation'] | ED[T]['Selection'], context: Cxt, option: OperateOption | SelectOption) => SyncOrAsync<any>;
     conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => SyncOrAsync<ED[T]['Update']['filter']>);
 };
-export declare type LogicalRelationChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
-    priority?: number;
-    type: 'logicalRelation';
-    when?: 'after';
-    entity: T;
-    action: ED[T]['Action'] | Array<ED[T]['Action']>;
-    checker: (operation: ED[T]['Operation'] | ED[T]['Selection'], context: Cxt, option: OperateOption | SelectOption) => any | Promise<any>;
-    conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => SyncOrAsync<ED[T]['Update']['filter']>);
-};
-export declare type Checker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = DataChecker<ED, T, Cxt> | RowChecker<ED, T, Cxt> | RelationChecker<ED, T, Cxt> | LogicalChecker<ED, T, Cxt> | LogicalRelationChecker<ED, T, Cxt>;
-export declare type AuthDef<ED extends EntityDict, T extends keyof ED> = {
+export type Checker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = DataChecker<ED, T, Cxt> | RowChecker<ED, T, Cxt> | RelationChecker<ED, T, Cxt> | LogicalChecker<ED, T, Cxt>;
+export type AuthDef<ED extends EntityDict, T extends keyof ED> = {
     relationAuth?: CascadeRelationAuth<NonNullable<ED[T]['Relation']>>;
     actionAuth?: CascadeActionAuth<ED[T]['Action']>;
     cascadeRemove?: {
         [E in (keyof ED | keyof ED[T]['Schema'] | '@entity')]?: ActionOnRemove;
     };
 };
-export declare type CascadeRemoveDefDict<ED extends EntityDict> = {
+export type CascadeRemoveDefDict<ED extends EntityDict> = {
     [T in keyof ED]?: {
         [E in (keyof ED | keyof ED[T]['Schema'] | '@entity')]?: ActionOnRemove;
     };
 };
-export declare type AuthDefDict<ED extends EntityDict> = {
+export type AuthDefDict<ED extends EntityDict> = {
     [K in keyof ED]?: AuthDef<ED, K>;
 };

package/lib/types/Connector.d.ts

@@ -1,33 +1,37 @@
 /// <reference types="node" />
 import { IncomingHttpHeaders } from "http";
-import { AsyncContext, AsyncRowStore } from "../store/AsyncRowStore";
 import { SyncContext } from "../store/SyncRowStore";
 import { EntityDict, OpRecord } from "./Entity";
 import { OakException } from "./Exception";
-export declare abstract class Connector<ED extends EntityDict, BackCxt extends AsyncContext<ED>, FrontCxt extends SyncContext<ED>> {
-    abstract callAspect(name: string, params: any, context: FrontCxt): Promise<{
+export interface Connector<ED extends EntityDict, FrontCxt extends SyncContext<ED>> {
+    callAspect: (name: string, params: any, context: FrontCxt) => Promise<{
         result: any;
         opRecords?: OpRecord<ED>[];
         message?: string | null;
     }>;
-    abstract getRouter(): string;
-    abstract parseRequest(headers: IncomingHttpHeaders, body: any, store: AsyncRowStore<ED, BackCxt>): Promise<{
-        name: string;
-        params: any;
-        context: BackCxt;
-    }>;
-    abstract serializeResult(result: any, context: BackCxt, headers: IncomingHttpHeaders, body: any): Promise<{
+    getRouter: () => string;
+    parseRequestHeaders: (headers: IncomingHttpHeaders) => {
+        contextString?: string;
+        aspectName: string;
+    };
+    serializeResult: (result: any, opRecords: OpRecord<ED>[], headers: IncomingHttpHeaders, body: any, message?: string) => Promise<{
         body: any;
         headers?: Record<string, any>;
     }>;
-    abstract serializeException(exception: OakException<ED>, headers: IncomingHttpHeaders, body: any): {
+    serializeException: (exception: OakException<ED>, headers: IncomingHttpHeaders, body: any) => {
         body: any;
         headers?: Record<string, any>;
     };
-    abstract getSubscribeRouter(): string;
-    abstract getBridgeRouter(): string;
-    abstract makeBridgeUrl(url: string, headers?: Record<string, string>): string;
-    abstract parseBridgeRequestQuery(urlParams: string): {
+    getSubscribeRouter: () => string;
+    getSubscribePointRouter: () => string;
+    getSubscribePoint: () => Promise<{
+        url: string;
+        path: string;
+    }>;
+    getBridgeRouter: () => string;
+    makeBridgeUrl: (url: string, headers?: Record<string, string>) => string;
+    getEndpointRouter: () => string;
+    parseBridgeRequestQuery: (urlParams: string) => {
         url: string;
         headers?: Record<string, string>;
     };

package/lib/types/Connector.js

@@ -1,9 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Connector = void 0;
-var Connector = /** @class */ (function () {
-    function Connector() {
-    }
-    return Connector;
-}());
-exports.Connector = Connector;

package/lib/types/DataType.d.ts

@@ -1,24 +1,25 @@
 import { Geo, SingleGeo } from "./Geo";
-export declare type Int<L extends 1 | 2 | 4 | 8> = number;
-export declare type Uint<L extends 1 | 2 | 4 | 8> = number;
-export declare type Double<P extends number, S extends number> = number;
-export declare type Float<P extends number, S extends number> = number;
-export declare type String<L extends number> = string;
-export declare type Text = string;
-export declare type Image = string;
-export declare type File = string;
-export declare type Datetime = number | Date;
-export declare type Day = number | Date;
-export declare type Time = number | Date;
-export declare type Boolean = boolean;
-export declare type Price = number;
-export declare type PrimaryKey = string;
-export declare type ForeignKey<E extends string> = string;
-export declare type Sequence = string;
+export type Int<L extends 1 | 2 | 4 | 8> = number;
+export type Uint<L extends 1 | 2 | 4 | 8> = number;
+export type Double<P extends number, S extends number> = number;
+export type Float<P extends number, S extends number> = number;
+export type Decimal<P extends number, S extends number> = number;
+export type String<L extends number> = string;
+export type Text = string;
+export type Image = string;
+export type File = string;
+export type Datetime = number | Date;
+export type Day = number | Date;
+export type Time = number | Date;
+export type Boolean = boolean;
+export type Price = number;
+export type PrimaryKey = string;
+export type ForeignKey<E extends string> = string;
+export type Sequence = string;
 export { Geo, SingleGeo } from './Geo';
-export declare type DataTypes = number | string | Datetime | Day | Time | Geo | Object | SingleGeo;
+export type DataTypes = number | string | Datetime | Day | Time | Geo | Object | SingleGeo;
 export declare const types: string[];
 export declare const unIndexedTypes: string[];
-export declare type JsonProjection<O extends object> = {
+export type JsonProjection<O extends object> = {
     [k in keyof O]?: NonNullable<O[k]> extends object ? JsonProjection<NonNullable<O[k]>> | number : number;
 };

package/lib/types/DataType.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.unIndexedTypes = exports.types = void 0;
 exports.types = ['Int', 'Uint', 'Double', 'Float', 'String', 'Text', 'Datetime', 'Day', 'Time',
-    'Boolean', 'Image', 'File', 'Geo', 'SingleGeo', 'Price'];
+    'Boolean', 'Image', 'File', 'Geo', 'SingleGeo', 'Price', 'Decimal'];
 exports.unIndexedTypes = ['Text', 'Image', 'File', 'Object'];