oak-domain 2.4.1 → 2.4.2

package/lib/store/actionDef.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzeActionDefDict = exports.getFullProjection = void 0;
 var tslib_1 = require("tslib");
+var types_1 = require("../types");
+var lodash_1 = require("../utils/lodash");
+var filter_1 = require("./filter");
 function getFullProjection(entity, schema) {
     var attributes = schema[entity].attributes;
     var projection = {
@@ -20,56 +23,116 @@ function getFullProjection(entity, schema) {
 }
 exports.getFullProjection = getFullProjection;
 function makeIntrinsicWatchers(schema) {
-    var _this = this;
     var watchers = [];
-    var _loop_1 = function (entity) {
+    for (var entity in schema) {
         var attributes = schema[entity].attributes;
-        var now = Date.now();
         var expiresAt = attributes.expiresAt, expired = attributes.expired;
         if (expiresAt && expiresAt.type === 'datetime' && expired && expired.type === 'boolean') {
             // 如果有定义expiresAt和expired，则自动生成一个检查的watcher
             watchers.push({
                 entity: entity,
                 name: "\u5BF9\u8C61".concat(entity, "\u4E0A\u7684\u8FC7\u671F\u81EA\u52A8watcher"),
-                filter: function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                    return tslib_1.__generator(this, function (_a) {
-                        return [2 /*return*/, {
-                                expired: false,
-                                expiresAt: {
-                                    $lte: now,
-                                },
-                            }];
-                    });
-                }); },
+                filter: function () {
+                    return {
+                        expired: false,
+                        expiresAt: {
+                            $lte: Date.now(),
+                        },
+                    };
+                },
                 action: 'update',
                 actionData: {
                     expired: true,
                 },
             });
         }
-    };
-    for (var entity in schema) {
-        _loop_1(entity);
     }
     return watchers;
 }
+function checkUniqueBetweenRows(rows, uniqAttrs) {
+    // 先检查这些行本身之间有无unique冲突
+    var uniqRows = (0, lodash_1.uniqBy)(rows, function (d) {
+        var e_1, _a;
+        var s = '';
+        try {
+            for (var uniqAttrs_1 = tslib_1.__values(uniqAttrs), uniqAttrs_1_1 = uniqAttrs_1.next(); !uniqAttrs_1_1.done; uniqAttrs_1_1 = uniqAttrs_1.next()) {
+                var a = uniqAttrs_1_1.value;
+                if (d[a] === null || d[a] === undefined) {
+                    s + d.id;
+                }
+                else {
+                    s + "-".concat(d[a]);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (uniqAttrs_1_1 && !uniqAttrs_1_1.done && (_a = uniqAttrs_1.return)) _a.call(uniqAttrs_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return s;
+    });
+    if (uniqRows.length < rows.length) {
+        throw new types_1.OakUniqueViolationException([{
+                attrs: uniqAttrs,
+            }]);
+    }
+}
+function checkCountLessThan(count, uniqAttrs, than, id) {
+    if (than === void 0) { than = 0; }
+    if (count instanceof Promise) {
+        return count.then(function (count2) {
+            if (count2 > than) {
+                throw new types_1.OakUniqueViolationException([{
+                        id: id,
+                        attrs: uniqAttrs,
+                    }]);
+            }
+        });
+    }
+    if (count > than) {
+        throw new types_1.OakUniqueViolationException([{
+                id: id,
+                attrs: uniqAttrs,
+            }]);
+    }
+}
+function checkUnique(entity, row, context, uniqAttrs, extraFilter) {
+    var filter = (0, lodash_1.pick)(row, uniqAttrs);
+    for (var a in filter) {
+        if (filter[a] === null || filter[a] === undefined) {
+            delete filter[a];
+        }
+    }
+    if (Object.keys(filter).length < uniqAttrs.length) {
+        // 说明有null值，不需要检查约束
+        return;
+    }
+    var filter2 = extraFilter ? (0, filter_1.addFilterSegment)([filter, extraFilter]) : filter;
+    var count = context.count(entity, { filter: filter2 }, { dontCollect: true });
+    return checkCountLessThan(count, uniqAttrs, 0, row.id);
+}
 function analyzeActionDefDict(schema, actionDefDict) {
+    var _a;
     var checkers = [];
     var triggers = [];
+    // action状态转换矩阵相应的checker
     for (var entity in actionDefDict) {
-        var _loop_2 = function (attr) {
+        var _loop_1 = function (attr) {
             var def = actionDefDict[entity][attr];
-            var _a = def, stm = _a.stm, is = _a.is;
+            var _b = def, stm = _b.stm, is = _b.is;
             var _loop_3 = function (action) {
-                var _b, _c;
+                var _c, _d;
                 var actionStm = stm[action];
-                var conditionalFilter = typeof actionStm[0] === 'string' ? (_b = {},
-                    _b[attr] = actionStm[0],
-                    _b) : (_c = {},
-                    _c[attr] = {
+                var conditionalFilter = typeof actionStm[0] === 'string' ? (_c = {},
+                    _c[attr] = actionStm[0],
+                    _c) : (_d = {},
+                    _d[attr] = {
                         $in: actionStm[0],
                     },
-                    _c);
+                    _d);
                 checkers.push({
                     action: action,
                     type: 'row',
@@ -123,8 +186,143 @@ function analyzeActionDefDict(schema, actionDefDict) {
             }
         };
         for (var attr in actionDefDict[entity]) {
-            _loop_2(attr);
+            _loop_1(attr);
+        }
+    }
+    var _loop_2 = function (entity) {
+        var e_2, _e;
+        var indexes = schema[entity].indexes;
+        if (indexes) {
+            var _loop_4 = function (index) {
+                if ((_a = index.config) === null || _a === void 0 ? void 0 : _a.unique) {
+                    var attributes = index.attributes;
+                    var uniqAttrs_2 = attributes.map(function (ele) { return ele.name; });
+                    checkers.push({
+                        entity: entity,
+                        action: 'create',
+                        type: 'logical',
+                        priority: 20,
+                        checker: function (operation, context) {
+                            var data = operation.data;
+                            if (data instanceof Array) {
+                                checkUniqueBetweenRows(data, uniqAttrs_2);
+                                var checkResult = data.map(function (ele) { return checkUnique(entity, ele, context, uniqAttrs_2); });
+                                if (checkResult[0] instanceof Promise) {
+                                    return Promise.all(checkResult).then(function () { return undefined; });
+                                }
+                            }
+                            else {
+                                return checkUnique(entity, data, context, uniqAttrs_2);
+                            }
+                        }
+                    }, {
+                        entity: entity,
+                        action: 'update',
+                        type: 'logical',
+                        priority: 20,
+                        checker: function (operation, context) {
+                            var e_3, _a, e_4, _b, _c;
+                            var _d = operation, data = _d.data, operationFilter = _d.filter;
+                            var attrs = Object.keys(data);
+                            var refAttrs = (0, lodash_1.intersection)(attrs, uniqAttrs_2);
+                            if (refAttrs.length === 0) {
+                                // 如果本次更新和unique约束的属性之间没有交集则直接返回
+                                return;
+                            }
+                            try {
+                                for (var refAttrs_1 = (e_3 = void 0, tslib_1.__values(refAttrs)), refAttrs_1_1 = refAttrs_1.next(); !refAttrs_1_1.done; refAttrs_1_1 = refAttrs_1.next()) {
+                                    var attr = refAttrs_1_1.value;
+                                    // 如果有更新为null值，不用再检查约束
+                                    if (data[attr] === null || data[attr] === undefined) {
+                                        return;
+                                    }
+                                }
+                            }
+                            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                            finally {
+                                try {
+                                    if (refAttrs_1_1 && !refAttrs_1_1.done && (_a = refAttrs_1.return)) _a.call(refAttrs_1);
+                                }
+                                finally { if (e_3) throw e_3.error; }
+                            }
+                            if (refAttrs.length === uniqAttrs_2.length) {
+                                // 如果更新了全部属性，直接检查
+                                var filter = (0, lodash_1.pick)(data, refAttrs);
+                                // 在这些行以外的行不和更新后的键值冲突
+                                var count = context.count(entity, {
+                                    filter: (0, filter_1.addFilterSegment)([filter, {
+                                            $not: operationFilter,
+                                        }]),
+                                }, { dontCollect: true });
+                                var checkCount = checkCountLessThan(count, uniqAttrs_2);
+                                // 更新的行只能有一行
+                                var rowCount = context.count(entity, {
+                                    filter: operationFilter,
+                                }, { dontCollect: true });
+                                var checkRowCount = checkCountLessThan(rowCount, uniqAttrs_2, 1);
+                                // 如果更新的行数为零似乎也可以，但这应该不可能出现吧，by Xc 20230131
+                                if (checkRowCount instanceof Promise) {
+                                    return Promise.all([checkCount, checkRowCount]).then(function () { return undefined; });
+                                }
+                            }
+                            // 否则需要结合本行现有的属性来进行检查
+                            var projection = { id: 1 };
+                            try {
+                                for (var uniqAttrs_3 = (e_4 = void 0, tslib_1.__values(uniqAttrs_2)), uniqAttrs_3_1 = uniqAttrs_3.next(); !uniqAttrs_3_1.done; uniqAttrs_3_1 = uniqAttrs_3.next()) {
+                                    var attr = uniqAttrs_3_1.value;
+                                    Object.assign(projection, (_c = {},
+                                        _c[attr] = 1,
+                                        _c));
+                                }
+                            }
+                            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                            finally {
+                                try {
+                                    if (uniqAttrs_3_1 && !uniqAttrs_3_1.done && (_b = uniqAttrs_3.return)) _b.call(uniqAttrs_3);
+                                }
+                                finally { if (e_4) throw e_4.error; }
+                            }
+                            var checkWithRows = function (rows2) {
+                                var rows22 = rows2.map(function (ele) { return Object.assign(ele, data); });
+                                // 先检查这些行本身之间是否冲突
+                                checkUniqueBetweenRows(rows22, uniqAttrs_2);
+                                var checkResults = rows22.map(function (row) { return checkUnique(entity, row, context, uniqAttrs_2, {
+                                    $not: operationFilter
+                                }); });
+                                if (checkResults[0] instanceof Promise) {
+                                    return Promise.all(checkResults).then(function () { return undefined; });
+                                }
+                            };
+                            var currentRows = context.select(entity, {
+                                data: projection,
+                                filter: operationFilter,
+                            }, { dontCollect: true });
+                            if (currentRows instanceof Promise) {
+                                return currentRows.then(function (row2) { return checkWithRows(row2); });
+                            }
+                            return checkWithRows(currentRows);
+                        }
+                    });
+                }
+            };
+            try {
+                for (var indexes_1 = (e_2 = void 0, tslib_1.__values(indexes)), indexes_1_1 = indexes_1.next(); !indexes_1_1.done; indexes_1_1 = indexes_1.next()) {
+                    var index = indexes_1_1.value;
+                    _loop_4(index);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (indexes_1_1 && !indexes_1_1.done && (_e = indexes_1.return)) _e.call(indexes_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
         }
+    };
+    // unique索引相应的checker
+    for (var entity in schema) {
+        _loop_2(entity);
     }
     return {
         triggers: triggers,

package/lib/types/Action.d.ts

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

package/lib/types/Auth.d.ts

@@ -2,12 +2,12 @@ import { CascadeActionAuth, CascadeRelationAuth } from ".";
 import { AsyncContext } from "../store/AsyncRowStore";
 import { SyncContext } from "../store/SyncRowStore";
 import { EntityDict, OperateOption, SelectOption } from "../types/Entity";
-export type CheckerType = 'relation' | 'row' | 'data' | 'logical' | 'logicalRelation';
+export declare type CheckerType = 'relation' | 'row' | 'data' | 'logical' | 'logicalRelation';
 /**
  * conditionalFilter是指该action发生时，operation所操作的行中有满足conditionalFilter的行
  * 被转化成trigger的filter条件，详细可看trigger中的说明
  */
-export type DataChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
+export declare type DataChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
     type: 'data';
     entity: T;
@@ -15,7 +15,7 @@ export type DataChecker<ED extends EntityDict, T extends keyof ED, Cxt extends A
     checker: (data: ED[T]['Create']['data'] | ED[T]['Update']['data'], context: Cxt) => void | Promise<void>;
     conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter'] | Promise<ED[T]['Selection']['filter']>);
 };
-export type RowChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
+export declare type RowChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
     type: 'row';
     entity: T;
@@ -28,7 +28,7 @@ export type RowChecker<ED extends EntityDict, T extends keyof ED, Cxt extends As
     };
     conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter'] | Promise<ED[T]['Update']['filter']>);
 };
-export type RelationChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
+export declare type RelationChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
     type: 'relation';
     entity: T;
@@ -38,7 +38,7 @@ export type RelationChecker<ED extends EntityDict, T extends keyof ED, Cxt exten
     errMsg: string;
     conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter'] | Promise<ED[T]['Selection']['filter']>);
 };
-export type LogicalChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
+export declare type LogicalChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
     type: 'logical';
     when?: 'after';
@@ -47,7 +47,7 @@ export type LogicalChecker<ED extends EntityDict, T extends keyof ED, Cxt extend
     checker: (operation: ED[T]['Operation'] | ED[T]['Selection'], context: Cxt, option: OperateOption | SelectOption) => void | Promise<void>;
     conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter']);
 };
-export type LogicalRelationChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
+export declare type LogicalRelationChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
     type: 'logicalRelation';
     when?: 'after';
@@ -56,11 +56,11 @@ export type LogicalRelationChecker<ED extends EntityDict, T extends keyof ED, Cx
     checker: (operation: ED[T]['Operation'] | ED[T]['Selection'], context: Cxt, option: OperateOption | SelectOption) => void | Promise<void>;
     conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter']);
 };
-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> | LogicalRelationChecker<ED, T, Cxt>;
-export type AuthDef<ED extends EntityDict, T extends keyof ED> = {
+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> = {
     relationAuth?: CascadeRelationAuth<NonNullable<ED[T]['Relation']>>;
     actionAuth?: CascadeActionAuth<ED[T]['Action']>;
 };
-export type AuthDefDict<ED extends EntityDict> = {
+export declare type AuthDefDict<ED extends EntityDict> = {
     [K in keyof ED]?: AuthDef<ED, K>;
 };

package/lib/types/DataType.d.ts

@@ -1,18 +1,18 @@
 import { Geo, SingleGeo } from "./Geo";
-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 String<L extends number> = string;
-export type Text = string;
-export type Image = string;
-export type File = string;
-export type Datetime = number | Date;
-export type Boolean = boolean;
-export type PrimaryKey = string;
-export type ForeignKey<E extends string> = string;
-export type Sequence = string;
+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 Boolean = boolean;
+export declare type PrimaryKey = string;
+export declare type ForeignKey<E extends string> = string;
+export declare type Sequence = string;
 export { Geo, SingleGeo } from './Geo';
-export type DataTypes = number | string | Datetime | Geo | Object | SingleGeo;
+export declare type DataTypes = number | string | Datetime | Geo | Object | SingleGeo;
 export declare const types: string[];
 export declare const unIndexedTypes: string[];

package/lib/types/Demand.d.ts

@@ -1,12 +1,12 @@
 import { RefOrExpression } from "./Expression";
 import { OneOf } from "./Polyfill";
 export declare const EXPRESSION_PREFIX = "$expr";
-export type NodeId = `node-${number}`;
-export type ExpressionKey = '$expr' | '$expr1' | '$expr2' | '$expr3' | '$expr4' | '$expr5' | '$expr6' | '$expr7' | '$expr8' | '$expr9' | '$expr10' | '$expr11' | '$expr12' | '$expr13' | '$expr14' | '$expr15' | '$expr16' | '$expr17' | '$expr18' | '$expr19' | '$expr20';
-export type ExprOp<A> = {
+export declare type NodeId = `node-${number}`;
+export declare type ExpressionKey = '$expr' | '$expr1' | '$expr2' | '$expr3' | '$expr4' | '$expr5' | '$expr6' | '$expr7' | '$expr8' | '$expr9' | '$expr10' | '$expr11' | '$expr12' | '$expr13' | '$expr14' | '$expr15' | '$expr16' | '$expr17' | '$expr18' | '$expr19' | '$expr20';
+export declare type ExprOp<A> = {
     [K in ExpressionKey]: RefOrExpression<A>;
 };
-export type Q_NumberComparisonValue = number | OneOf<{
+export declare type Q_NumberComparisonValue = number | OneOf<{
     $gt: number;
     $lt: number;
     $gte: number;
@@ -17,7 +17,7 @@ export type Q_NumberComparisonValue = number | OneOf<{
     $nin: number[];
     $between: [number, number];
 }>;
-export type Q_StringComparisonValue = string | OneOf<{
+export declare type Q_StringComparisonValue = string | OneOf<{
     $gt: string;
     $lt: string;
     $gte: string;
@@ -30,44 +30,44 @@ export type Q_StringComparisonValue = string | OneOf<{
     $in: string[];
     $nin: string[];
 }>;
-export type Q_BooleanComparisonValue = boolean;
-export type Q_DateComparisonValue = Q_NumberComparisonValue;
-export type Q_EnumComparisonValue<E> = E | OneOf<{
+export declare type Q_BooleanComparisonValue = boolean;
+export declare type Q_DateComparisonValue = Q_NumberComparisonValue;
+export declare type Q_EnumComparisonValue<E> = E | OneOf<{
     $in: E[];
     $nin: E[];
 }>;
-export type Q_ExistsValue = {
+export declare type Q_ExistsValue = {
     $exists: boolean;
 };
-export type Q_NumberValue = Q_NumberComparisonValue | Q_ExistsValue;
-export type Q_StringValue = Q_StringComparisonValue | Q_ExistsValue;
-export type Q_BooleanValue = Q_BooleanComparisonValue | Q_ExistsValue;
-export type Q_DateValue = Q_DateComparisonValue | Q_ExistsValue;
-export type Q_EnumValue<E> = Q_EnumComparisonValue<E> | Q_ExistsValue;
-export type Q_State<S> = S | {
+export declare type Q_NumberValue = Q_NumberComparisonValue | Q_ExistsValue;
+export declare type Q_StringValue = Q_StringComparisonValue | Q_ExistsValue;
+export declare type Q_BooleanValue = Q_BooleanComparisonValue | Q_ExistsValue;
+export declare type Q_DateValue = Q_DateComparisonValue | Q_ExistsValue;
+export declare type Q_EnumValue<E> = Q_EnumComparisonValue<E> | Q_ExistsValue;
+export declare type Q_State<S> = S | {
     $in: S[];
 } | {
     $nin: S[];
 } | Q_ExistsValue;
-export type Q_FullTextValue = {
+export declare type Q_FullTextValue = {
     $search: string;
     $language?: 'zh_CN' | 'en_US';
 };
-export type Q_FullTextKey = '$text';
-export type FulltextFilter = {
+export declare type Q_FullTextKey = '$text';
+export declare type FulltextFilter = {
     [F in Q_FullTextKey]?: Q_FullTextValue;
 };
-type Q_LogicKey = '$and' | '$or';
-type Q_LinearLogicKey = '$not';
-export type MakeFilterWrapper<F extends Object> = {
+declare type Q_LogicKey = '$and' | '$or';
+declare type Q_LinearLogicKey = '$not';
+export declare type MakeFilterWrapper<F extends Object> = {
     [Q in Q_LogicKey]?: Array<MakeFilterWrapper<F>>;
 } & {
     [Q in Q_LinearLogicKey]?: MakeFilterWrapper<F>;
 } & Partial<F>;
-export type MakeFilter<F extends Object> = {
+export declare type MakeFilter<F extends Object> = {
     '#id'?: NodeId;
 } & MakeFilterWrapper<F>;
-export type RefAttr<A> = {
+export declare type RefAttr<A> = {
     '#attr': A;
 } | {
     '#refId': NodeId;

package/lib/types/Endpoint.d.ts

@@ -8,4 +8,4 @@ export interface EndpointItem<ED extends EntityDict, BackCxt extends AsyncContex
     method: 'get' | 'post' | 'put' | 'delete';
     fn: (context: BackCxt, params: Record<string, string>, headers: IncomingHttpHeaders, req: IncomingMessage, body?: any) => Promise<any>;
 }
-export type Endpoint<ED extends EntityDict, BackCxt extends AsyncContext<ED>> = EndpointItem<ED, BackCxt> | EndpointItem<ED, BackCxt>[];
+export declare type Endpoint<ED extends EntityDict, BackCxt extends AsyncContext<ED>> = EndpointItem<ED, BackCxt> | EndpointItem<ED, BackCxt>[];