oak-domain 1.0.0

package/lib/store/relation.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.judgeRelation = void 0;
+var assert_1 = __importDefault(require("assert"));
+var Demand_1 = require("../types/Demand");
+var Entity_1 = require("../types/Entity");
+/**
+ * 判断对象和属性之间的关系
+ * @param schema
+ * @param entity
+ * @param attr
+ * @param row
+ * @returns
+ */
+function judgeRelation(schema, entity, attr) {
+    var _a = schema, _b = entity, attributes = _a[_b].attributes;
+    if (attr.startsWith(Demand_1.EXPRESSION_PREFIX) || attr.startsWith('#')) {
+        // 表达式属性或者metadata
+        return 0;
+    }
+    if (attributes.hasOwnProperty(attr) || Entity_1.initinctiveAttributes.includes(attr)) {
+        // 原生属性
+        return 1;
+    }
+    if (attr.includes('$')) {
+        var entity2 = attr.slice(0, attr.indexOf('$'));
+        (0, assert_1.default)(schema.hasOwnProperty(entity2));
+        var foreignKey = attr.slice(attr.indexOf('$') + 1);
+        var _c = schema, _d = entity2, attributes2 = _c[_d].attributes;
+        if (foreignKey === 'entity') {
+            // 基于反指对象的反向关联
+            return [entity2];
+        }
+        else if (attributes2.hasOwnProperty("".concat(foreignKey, "Id"))
+            && attributes2["".concat(foreignKey, "Id")].type === 'ref'
+            && attributes2["".concat(foreignKey, "Id")].ref === entity) {
+            // 基于外键的反向关联
+            return [entity2, "".concat(foreignKey, "Id")];
+        }
+        else {
+            // 这种情况应该不会跑到
+            (0, assert_1.default)(false);
+        }
+    }
+    else if ((attributes.hasOwnProperty("".concat(attr, "Id")))) {
+        var _e = attributes["".concat(attr, "Id")], type = _e.type, ref = _e.ref;
+        (0, assert_1.default)(type === 'ref');
+        return ref;
+    }
+    else if (attributes.hasOwnProperty('entity')
+        && attributes.hasOwnProperty('entityId')
+        && schema.hasOwnProperty(attr)) {
+        // 反向指针的外键
+        return 2;
+    }
+    else {
+        (0, assert_1.default)(Entity_1.initinctiveAttributes.includes(attr), "".concat(attr, "\u5C5E\u6027\u627E\u4E0D\u5230"));
+        return 1;
+    }
+}
+exports.judgeRelation = judgeRelation;

package/lib/store/watchers.d.ts

@@ -0,0 +1,2 @@
+import { Context, EntityDict, StorageSchema, Watcher } from "../types";
+export declare function makeIntrinsicWatchers<ED extends EntityDict, Cxt extends Context<ED>>(schema: StorageSchema<ED>): Watcher<ED, keyof ED, Cxt>[];

package/lib/store/watchers.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeIntrinsicWatchers = void 0;
+function makeIntrinsicWatchers(schema) {
+    const watchers = [];
+    for (const entity in schema) {
+        const { attributes } = schema[entity];
+        const { expiresAt, expired } = attributes;
+        if (expiresAt && expiresAt.type === 'datetime' && expired && expired.type === 'boolean') {
+            // 如果有定义expiresAt和expired，则自动生成一个检查的watcher
+            watchers.push({
+                entity,
+                name: `对象${entity}上的过期自动watcher`,
+                filter: async () => {
+                    const now = Date.now();
+                    return {
+                        expired: false,
+                        expiresAt: {
+                            $lte: now,
+                        },
+                    };
+                },
+                action: 'update',
+                actionData: {
+                    expired: true,
+                },
+            });
+        }
+    }
+    return watchers;
+}
+exports.makeIntrinsicWatchers = makeIntrinsicWatchers;

package/lib/types/Action.d.ts

@@ -0,0 +1,14 @@
+import { EntityDict } from "./Entity";
+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 declare type ActionDictOfEntityDict<E extends EntityDict> = {
+    [T in keyof E]?: {
+        [A in keyof E[T]['OpSchema']]?: ActionDef<string, string>;
+    };
+};

package/lib/types/Action.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/AppLoader.d.ts

@@ -0,0 +1,11 @@
+import { Context, RowStore } from ".";
+import { EntityDict } from "./Entity";
+export declare abstract class AppLoader<ED extends EntityDict, Cxt extends Context<ED>> {
+    protected path: string;
+    constructor(path: string);
+    abstract execAspect(name: string, context: Cxt, params?: any): Promise<any>;
+    abstract initialize(dropIfExists?: boolean): Promise<void>;
+    abstract mount(): Promise<void>;
+    abstract unmount(): Promise<void>;
+    abstract getStore(): RowStore<ED, Cxt>;
+}

package/lib/types/AppLoader.js

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

package/lib/types/Aspect.d.ts

@@ -0,0 +1,12 @@
+import { EntityDict } from "./Entity";
+import { Context } from './Context';
+import { OpRecord } from "./Entity";
+export interface Aspect<ED extends EntityDict, Cxt extends Context<ED>> {
+    (params: any, context: Cxt): Promise<any>;
+}
+export interface AspectWrapper<ED extends EntityDict, Cxt extends Context<ED>, AD extends Record<string, Aspect<ED, Cxt>>> {
+    exec: <T extends keyof AD>(name: T, params: Parameters<AD[T]>[0]) => Promise<{
+        result: Awaited<ReturnType<AD[T]>>;
+        opRecords: OpRecord<ED>[];
+    }>;
+}

package/lib/types/Aspect.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;
+;

package/lib/types/Auth.d.ts

@@ -0,0 +1,28 @@
+import { EntityDict } from "../types/Entity";
+import { Context } from "./Context";
+import { CreateTriggerBase, RemoveTriggerBase, UpdateTriggerBase, CheckerType, SelectTriggerBefore } from "./Trigger";
+export declare type CreateChecker<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> = {
+    type: CheckerType;
+    action: 'create';
+    entity: T;
+    checker: CreateTriggerBase<ED, T, Cxt>['fn'];
+};
+export declare type UpdateChecker<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> = {
+    type: CheckerType;
+    action: UpdateTriggerBase<ED, T, Cxt>['action'];
+    entity: T;
+    checker: UpdateTriggerBase<ED, T, Cxt>['fn'];
+};
+export declare type RemoveChecker<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> = {
+    type: CheckerType;
+    action: 'remove';
+    entity: T;
+    checker: RemoveTriggerBase<ED, T, Cxt>['fn'];
+};
+export declare type SelectChecker<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> = {
+    type: CheckerType;
+    action: 'select';
+    entity: T;
+    checker: SelectTriggerBefore<ED, T, Cxt>['fn'];
+};
+export declare type Checker<ED extends EntityDict, T extends keyof ED, Cxt extends Context<ED>> = CreateChecker<ED, T, Cxt> | UpdateChecker<ED, T, Cxt> | RemoveChecker<ED, T, Cxt> | SelectChecker<ED, T, Cxt>;

package/lib/types/Auth.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/Connector.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import { IncomingHttpHeaders } from "http";
+import { RowStore } from ".";
+import { Context } from "./Context";
+import { EntityDict, OpRecord } from "./Entity";
+import { OakException } from "./Exception";
+export declare abstract class Connector<ED extends EntityDict, Cxt extends Context<ED>> {
+    abstract callAspect(name: string, params: any, context: Cxt): Promise<{
+        result: any;
+        opRecords: OpRecord<ED>[];
+    }>;
+    abstract getRouter(): string;
+    abstract parseRequest(headers: IncomingHttpHeaders, body: any, store: RowStore<ED, Cxt>): {
+        name: string;
+        params: any;
+        context: Cxt;
+    };
+    abstract serializeResult(result: any, context: Cxt, headers: IncomingHttpHeaders, body: any): {
+        body: any;
+        headers?: Record<string, any>;
+    };
+    abstract serializeException(exception: OakException, headers: IncomingHttpHeaders, body: any): {
+        body: any;
+        headers?: Record<string, any>;
+    };
+}

package/lib/types/Connector.js

@@ -0,0 +1,9 @@
+"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/Context.d.ts

@@ -0,0 +1,14 @@
+import { EntityDict, OpRecord } from './Entity';
+import { RowStore } from './RowStore';
+export interface Context<ED extends EntityDict> {
+    opRecords: OpRecord<ED>[];
+    rowStore: RowStore<ED, this>;
+    begin(options?: object): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    getCurrentTxnId(): string | undefined;
+    on(event: 'commit' | 'rollback', callback: () => Promise<void>): void;
+    toString(): Promise<string>;
+    getScene(): string | undefined;
+    setScene(scene?: string): void;
+}

package/lib/types/Context.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;

package/lib/types/DataType.d.ts

@@ -0,0 +1,17 @@
+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 Boolean = boolean;
+export declare type PrimaryKey = string;
+export declare type ForeignKey<E extends string> = string;
+export { Geo, SingleGeo } from './Geo';
+export declare type DataTypes = number | string | Datetime | Geo | object | SingleGeo;
+export declare const types: string[];
+export declare const unIndexedTypes: string[];

package/lib/types/DataType.js

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

package/lib/types/Demand.d.ts

@@ -0,0 +1,77 @@
+import { RefOrExpression } from "./Expression";
+import { OneOf } from "./Polyfill";
+export declare const EXPRESSION_PREFIX = "$expr";
+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 declare type Q_NumberComparisonValue = number | OneOf<{
+    $gt: number;
+    $lt: number;
+    $gte: number;
+    $lte: number;
+    $eq: number;
+    $ne: number;
+    $in: number[];
+    $nin: number[];
+    $between: [number, number];
+}>;
+export declare type Q_StringComparisonValue = string | OneOf<{
+    $gt: string;
+    $lt: string;
+    $gte: string;
+    $lte: string;
+    $eq: string;
+    $ne: string;
+    $startsWith: string;
+    $endsWith: string;
+    $includes: string;
+    $in: string[];
+    $nin: string[];
+}>;
+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 declare type Q_ExistsValue = {
+    $exists: boolean;
+};
+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 declare type Q_FullTextValue = {
+    $search: string;
+    $language?: 'zh_CN' | 'en_US';
+};
+export declare type Q_FullTextKey = '$text';
+export declare type FulltextFilter = {
+    [F in Q_FullTextKey]?: Q_FullTextValue;
+};
+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 declare type MakeFilter<F extends Object> = {
+    '#id'?: NodeId;
+} & MakeFilterWrapper<F>;
+export declare type RefAttr<A> = {
+    '#attr': A;
+} | {
+    '#refId': NodeId;
+    '#refAttr': string;
+};
+export declare function isRefAttrNode<A>(node: any): node is RefAttr<A>;
+export {};

package/lib/types/Demand.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRefAttrNode = exports.EXPRESSION_PREFIX = void 0;
+exports.EXPRESSION_PREFIX = '$expr';
+function isRefAttrNode(node) {
+    return node.hasOwnProperty('#attr') || (node.hasOwnProperty('#refId') && node.hasOwnProperty('#refAttr'));
+}
+exports.isRefAttrNode = isRefAttrNode;
+;

package/lib/types/Entity.d.ts

@@ -0,0 +1,138 @@
+import { GenericAction } from '../actions/action';
+import { ExpressionKey, ExprOp, MakeFilter, NodeId } from './Demand';
+import { OneOf, OptionalKeys } from './Polyfill';
+export declare type TriggerDataAttribute = '$$triggerData$$';
+export declare type TriggerTimestampAttribute = '$$triggerTimestamp$$';
+declare type PrimaryKeyAttribute = 'id';
+export declare type InstinctiveAttributes = PrimaryKeyAttribute | '$$createAt$$' | '$$updateAt$$' | '$$deleteAt$$' | TriggerDataAttribute | TriggerTimestampAttribute;
+export declare const initinctiveAttributes: string[];
+export declare type Filter<A extends string, F extends Object | undefined = undefined> = {
+    filter?: A extends 'create' ? undefined : F;
+    indexFrom?: A extends 'create' ? undefined : number;
+    count?: A extends 'create' ? undefined : number;
+};
+export declare type SelectOption = {
+    dontCollect?: boolean;
+    ignoreTrigger?: true;
+    obscure?: boolean;
+    forUpdate?: true;
+    includedDeleted?: true;
+    dummy?: 1;
+};
+export declare type OperateOption = {
+    dontCollect?: boolean;
+    dummy?: 1;
+};
+export declare type FormUpdateData<SH extends GeneralEntityShape> = Partial<Omit<SH, InstinctiveAttributes>>;
+export declare type FormCreateData<SH extends GeneralEntityShape> = Omit<SH, InstinctiveAttributes> & {
+    id: string;
+};
+export declare type Operation<A extends GenericAction | string, DATA extends Object, FILTER extends Object | undefined = undefined, SORTER extends Object | undefined = undefined> = {
+    action: A;
+    data: DATA;
+    sorter?: SORTER;
+    option?: A extends 'select' ? SelectOption : undefined;
+} & Filter<A, FILTER>;
+export declare type Selection<DATA extends Object, FILTER extends Object | undefined = undefined, SORT extends Object | undefined = undefined> = Operation<'select', DATA, FILTER, SORT>;
+export interface EntityShape {
+    id: string;
+    $$createAt$$: number | Date;
+    $$updateAt$$: number | Date;
+    $$deleteAt$$?: number | Date | null;
+}
+export interface FileCarrierEntityShape extends EntityShape {
+}
+interface GeneralEntityShape extends EntityShape {
+    [K: string]: any;
+}
+export interface EntityDef {
+    Schema: GeneralEntityShape;
+    OpSchema: GeneralEntityShape;
+    Action: string;
+    ParticularAction?: string;
+    Selection: Omit<DeduceSelection<this['Schema']>, 'action'>;
+    Operation: DeduceOperation<this['Schema']>;
+    Create: DeduceCreateOperation<this['Schema']>;
+    CreateSingle: DeduceCreateSingleOperation<this['Schema']>;
+    CreateMulti: DeduceCreateMultipleOperation<this['Schema']>;
+    Update: DeduceUpdateOperation<this['Schema']>;
+    Remove: DeduceRemoveOperation<this['Schema']>;
+}
+export interface EntityDict {
+    [E: string]: EntityDef;
+}
+export interface OtmSubProjection extends Omit<DeduceSelection<any>, 'action'> {
+    $entity: string;
+}
+declare type DeduceProjection<SH extends GeneralEntityShape> = Partial<{
+    '#id': NodeId;
+} & {
+    [K in keyof SH]: 1 | OtmSubProjection | any;
+} & ExprOp<keyof SH>>;
+export declare type AttrFilter<SH extends GeneralEntityShape> = {
+    [K in keyof SH]: any;
+};
+export declare type DeduceFilter<SH extends GeneralEntityShape> = MakeFilter<AttrFilter<SH> & ExprOp<keyof SH>>;
+export declare type DeduceSorterAttr<SH extends GeneralEntityShape> = OneOf<{
+    [K: string]: 1 | object | undefined;
+} & ExprOp<keyof SH>>;
+export declare type DeduceSorterItem<SH extends GeneralEntityShape> = {
+    $attr: DeduceSorterAttr<SH>;
+    $direction?: "asc" | "desc";
+};
+export declare type DeduceSorter<SH extends GeneralEntityShape> = Array<DeduceSorterItem<SH>>;
+export declare type DeduceSelection<SH extends GeneralEntityShape> = Selection<DeduceProjection<SH>, DeduceFilter<SH>, DeduceSorter<SH>>;
+export declare type DeduceCreateOperationData<SH extends GeneralEntityShape> = FormCreateData<SH> & {
+    [k: string]: any;
+};
+export declare type DeduceCreateSingleOperation<SH extends GeneralEntityShape> = Operation<'create', DeduceCreateOperationData<SH>>;
+export declare type DeduceCreateMultipleOperation<SH extends GeneralEntityShape> = Operation<'create', Array<DeduceCreateOperationData<SH>>>;
+export declare type DeduceCreateOperation<SH extends GeneralEntityShape> = DeduceCreateSingleOperation<SH> | DeduceCreateMultipleOperation<SH>;
+export declare type DeduceUpdateOperationData<SH extends GeneralEntityShape> = FormUpdateData<SH> & {
+    [k: string]: any;
+};
+export declare type DeduceUpdateOperation<SH extends GeneralEntityShape> = Operation<'update' | string, DeduceUpdateOperationData<SH>, DeduceFilter<SH>, DeduceSorter<SH>>;
+export declare type DeduceRemoveOperationData<SH extends GeneralEntityShape> = {
+    [A in keyof SH]?: any;
+} & {
+    [A: string]: any;
+};
+export declare type DeduceRemoveOperation<SH extends GeneralEntityShape> = Operation<'remove', DeduceRemoveOperationData<SH>, DeduceFilter<SH>, DeduceSorter<SH>>;
+export declare type DeduceOperation<SH extends GeneralEntityShape> = DeduceCreateOperation<SH> | DeduceUpdateOperation<SH> | DeduceRemoveOperation<SH> | DeduceSelection<SH>;
+export declare type CreateOpResult<ED extends EntityDict, T extends keyof ED> = {
+    a: 'c';
+    e: T;
+    d: ED[T]['OpSchema'] | ED[T]['OpSchema'][];
+};
+export declare type UpdateOpResult<ED extends EntityDict, T extends keyof ED> = {
+    a: 'u';
+    e: T;
+    d: FormUpdateData<ED[T]['OpSchema']>;
+    f?: DeduceFilter<ED[T]['Schema']>;
+};
+export declare type RemoveOpResult<ED extends EntityDict, T extends keyof ED> = {
+    a: 'r';
+    e: T;
+    f?: DeduceFilter<ED[T]['Schema']>;
+};
+export declare type SelectOpResult<ED extends EntityDict> = {
+    a: 's';
+    d: {
+        [T in keyof ED]?: {
+            [ID: string]: ED[T]['OpSchema'];
+        };
+    };
+};
+export declare type OpRecord<ED extends EntityDict> = CreateOpResult<ED, keyof ED> | UpdateOpResult<ED, keyof ED> | RemoveOpResult<ED, keyof ED> | SelectOpResult<ED>;
+export declare type OperationResult<ED extends EntityDict> = {
+    [K in keyof ED]?: {
+        [A in ED[K]['Action']]?: number;
+    };
+};
+export declare type SelectRowShape<E extends GeneralEntityShape, P extends DeduceProjection<GeneralEntityShape>> = {
+    [K in keyof P]: K extends ExpressionKey ? any : (K extends keyof E ? (P[K] extends 1 | undefined ? E[K] : (P[K] extends OtmSubProjection ? SelectRowShape<Required<E>[K][0], P[K]['data']>[] | Array<never> : (K extends OptionalKeys<E> ? SelectRowShape<NonNullable<Required<E>[K]>, P[K]> | null : SelectRowShape<NonNullable<Required<E>[K]>, P[K]>))) : never);
+};
+export declare type SelectionResult<E extends GeneralEntityShape, P extends DeduceProjection<GeneralEntityShape>> = {
+    result: Array<SelectRowShape<E, P>>;
+};
+export {};

package/lib/types/Entity.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initinctiveAttributes = void 0;
+exports.initinctiveAttributes = ['id', '$$createAt$$', '$$updateAt$$', '$$deleteAt$$', '$$triggerData$$', '$$triggerTimestamp$$'];
+;
+;
+;
+;

package/lib/types/Exception.d.ts

@@ -0,0 +1,48 @@
+import { EntityDict, OpRecord } from "./Entity";
+export declare class OakException extends Error {
+    constructor(message?: string);
+    toString(): string;
+}
+export declare class OakExternalException extends Error {
+}
+export declare class OakUserException extends OakException {
+}
+/**
+ * 数据不一致异常，系统认为现有的数据不允许相应的动作时抛此异常
+ *
+ */
+export declare class OakRowInconsistencyException<ED extends EntityDict> extends OakUserException {
+    private data?;
+    constructor(data?: OpRecord<ED>, message?: string);
+    getData(): OpRecord<ED> | undefined;
+    toString(): string;
+}
+/**
+ * 当输入的数据非法时抛此异常，attributes表示非法的属性
+ */
+export declare class OakInputIllegalException extends OakUserException {
+    private attributes;
+    constructor(attributes: string[], message?: string);
+    getAttributes(): string[];
+    addAttributesPrefix(prefix: string): void;
+    toString(): string;
+}
+/**
+ * 用户权限不够时抛的异常
+ */
+export declare class OakUserUnpermittedException extends OakUserException {
+}
+/**
+ * 要插入行时，发现已经有相同的行数据
+ */
+export declare class OakCongruentRowExists<ED extends EntityDict, T extends keyof ED> extends OakUserException {
+    private data;
+    constructor(data: ED[T]['OpSchema'], message?: string);
+    getData(): ED[T]["OpSchema"];
+    toString(): string;
+}
+export declare function makeException(data: {
+    name: string;
+    message?: string;
+    [A: string]: any;
+}): OakException | OakExternalException | undefined;