oak-domain 2.3.1 → 2.4.0

package/lib/store/filter.d.ts

@@ -96,5 +96,14 @@ export declare function makeTreeAncestorFilter<ED extends EntityDict, T extends
  * @param level
  */
 export declare function makeTreeDescendantFilter<ED extends EntityDict, T extends keyof ED>(entity: T, parentKey: string, filter: ED[T]['Selection']['filter'], level?: number, includeAll?: boolean, includeSelf?: boolean): ED[T]['Selection']['filter'];
-export declare function checkFilterContains<ED extends EntityDict, T extends keyof ED, Cxt extends SyncContext<ED> | AsyncContext<ED>>(entity: T, context: Cxt, contained: ED[T]['Selection']['filter'], filter?: ED[T]['Selection']['filter']): boolean | Promise<boolean>;
-export declare function checkFilterRepel<ED extends EntityDict, T extends keyof ED, Cxt extends SyncContext<ED> | AsyncContext<ED>>(entity: T, context: Cxt, filter1: ED[T]['Selection']['filter'], filter2: ED[T]['Selection']['filter']): boolean | Promise<boolean>;
+/**
+ * 检查filter是否包含contained（filter查询的数据一定满足contained）
+ * @param entity
+ * @param context
+ * @param contained
+ * @param filter
+ * @param dataCompare
+ * @returns
+ */
+export declare function checkFilterContains<ED extends EntityDict, T extends keyof ED, Cxt extends SyncContext<ED> | AsyncContext<ED>>(entity: T, context: Cxt, contained: ED[T]['Selection']['filter'], filter?: ED[T]['Selection']['filter'], dataCompare?: true): boolean | Promise<boolean>;
+export declare function checkFilterRepel<ED extends EntityDict, T extends keyof ED, Cxt extends SyncContext<ED> | AsyncContext<ED>>(entity: T, context: Cxt, filter1: ED[T]['Selection']['filter'], filter2: ED[T]['Selection']['filter'], dataCompare?: true): boolean | Promise<boolean>;

package/lib/store/filter.js

@@ -828,7 +828,16 @@ function makeTreeDescendantFilter(entity, parentKey, filter, level, includeAll,
     return currentLevelInFilter;
 }
 exports.makeTreeDescendantFilter = makeTreeDescendantFilter;
-function checkFilterContains(entity, context, contained, filter) {
+/**
+ * 检查filter是否包含contained（filter查询的数据一定满足contained）
+ * @param entity
+ * @param context
+ * @param contained
+ * @param filter
+ * @param dataCompare
+ * @returns
+ */
+function checkFilterContains(entity, context, contained, filter, dataCompare) {
     if (!filter) {
         throw new types_1.OakRowInconsistencyException();
     }
@@ -837,23 +846,26 @@ function checkFilterContains(entity, context, contained, filter) {
     if (contains(entity, schema, filter, contained)) {
         return true;
     }
-    // 再判断加上了conditionalFilter后取得的行数是否缩减
-    var filter2 = combineFilters([filter, {
-            $not: contained,
-        }]);
-    var count = context.count(entity, {
-        filter: filter2,
-    }, {
-        dontCollect: true,
-        blockTrigger: true,
-    });
-    if (count instanceof Promise) {
-        return count.then(function (count2) { return count2 === 0; });
+    if (dataCompare) {
+        // 再判断加上了conditionalFilter后取得的行数是否缩减
+        var filter2 = combineFilters([filter, {
+                $not: contained,
+            }]);
+        var count = context.count(entity, {
+            filter: filter2,
+        }, {
+            dontCollect: true,
+            blockTrigger: true,
+        });
+        if (count instanceof Promise) {
+            return count.then(function (count2) { return count2 === 0; });
+        }
+        return count === 0;
     }
-    return count === 0;
+    return false;
 }
 exports.checkFilterContains = checkFilterContains;
-function checkFilterRepel(entity, context, filter1, filter2) {
+function checkFilterRepel(entity, context, filter1, filter2, dataCompare) {
     if (!filter2) {
         throw new types_1.OakRowInconsistencyException();
     }
@@ -863,16 +875,19 @@ function checkFilterRepel(entity, context, filter1, filter2) {
         return true;
     }
     // 再判断两者同时成立时取得的行数是否为0
-    var filter3 = combineFilters([filter2, filter1]);
-    var count = context.count(entity, {
-        filter: filter3,
-    }, {
-        dontCollect: true,
-        blockTrigger: true,
-    });
-    if (count instanceof Promise) {
-        return count.then(function (count2) { return count2 !== 0; });
+    if (dataCompare) {
+        var filter3 = combineFilters([filter2, filter1]);
+        var count = context.count(entity, {
+            filter: filter3,
+        }, {
+            dontCollect: true,
+            blockTrigger: true,
+        });
+        if (count instanceof Promise) {
+            return count.then(function (count2) { return count2 === 0; });
+        }
+        return count === 0;
     }
-    return count !== 0;
+    return false;
 }
 exports.checkFilterRepel = checkFilterRepel;

package/lib/store/modi.js

@@ -58,14 +58,6 @@ function abandonModis(filter, context, option) {
                             _d.action = 'abandon',
                             _d.data = {},
                             _d.filter = filter,
-                            _d.sorter = [
-                                {
-                                    $attr: {
-                                        $$createAt$$: 1,
-                                    },
-                                    $direction: 'asc',
-                                }
-                            ],
                             _d), Object.assign({}, option, {
                             blockTrigger: false,
                         })]))];

package/lib/store/relation.d.ts

@@ -10,4 +10,4 @@ import { StorageSchema } from "../types/Storage";
  */
 export declare function judgeRelation<ED extends {
     [E: string]: EntityDef;
-}>(schema: StorageSchema<ED>, entity: keyof ED, attr: string): string | 2 | 1 | string[] | 0;
+}>(schema: StorageSchema<ED>, entity: keyof ED, attr: string): string | 1 | 2 | string[] | 0;

package/lib/store/relation.js

@@ -59,7 +59,7 @@ function judgeRelation(schema, entity, attr) {
         return 2;
     }
     else {
-        (0, assert_1.default)(Entity_1.initinctiveAttributes.includes(attr), "".concat(attr, "\u5C5E\u6027\u627E\u4E0D\u5230"));
+        (0, assert_1.default)(Entity_1.initinctiveAttributes.includes(attr), "".concat(entity, "\u5BF9\u8C61\u4E2D\u7684").concat(attr, "\u5C5E\u6027\u627E\u4E0D\u5230"));
         return 1;
     }
 }

package/lib/types/Action.d.ts

@@ -1,4 +1,5 @@
-import { EntityDict } from "./Entity";
+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> = {
@@ -12,3 +13,6 @@ export declare type ActionDictOfEntityDict<E extends EntityDict> = {
         [A in keyof E[T]['OpSchema']]?: ActionDef<string, string>;
     };
 };
+export declare type CascadeActionAuth<A extends Action = ''> = {
+    [K in A | GenericAction]?: CascadeRelationItem | (CascadeRelationItem | CascadeRelationItem[])[];
+};

package/lib/types/Auth.d.ts

@@ -1,8 +1,8 @@
+import { CascadeActionAuth, CascadeRelationAuth } from ".";
 import { AsyncContext } from "../store/AsyncRowStore";
 import { SyncContext } from "../store/SyncRowStore";
 import { EntityDict, OperateOption, SelectOption } from "../types/Entity";
-import { RefOrExpression } from "./Expression";
-export declare type CheckerType = 'relation' | 'row' | 'data' | 'expression' | 'expressionRelation';
+export declare type CheckerType = 'relation' | 'row' | 'data' | 'logical' | 'logicalRelation';
 /**
  * conditionalFilter是指该action发生时，operation所操作的行中有满足conditionalFilter的行
  * 被转化成trigger的filter条件，详细可看trigger中的说明
@@ -12,55 +12,55 @@ export declare type DataChecker<ED extends EntityDict, T extends keyof ED, Cxt e
     type: 'data';
     entity: T;
     action: Omit<ED[T]['Action'], 'remove'> | Array<Omit<ED[T]['Action'], 'remove'>>;
-    checker: (data: ED[T]['Create']['data'] | ED[T]['Update']['data'], context: Cxt) => void;
-    conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter']);
+    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 declare type RowChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
     type: 'row';
     entity: T;
     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) => ED[T]['Selection']['filter']);
+    filter: ED[T]['Selection']['filter'] | ((operation: ED[T]['Operation'] | ED[T]['Selection'], context: Cxt, option: OperateOption | SelectOption) => ED[T]['Selection']['filter'] | Promise<ED[T]['Selection']['filter']>);
     errMsg?: string;
     inconsistentRows?: {
         entity: keyof ED;
         selection: (filter?: ED[T]['Selection']['filter']) => ED[keyof ED]['Selection'];
     };
-    conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter']);
+    conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter'] | Promise<ED[T]['Update']['filter']>);
 };
 export declare type RelationChecker<ED extends EntityDict, T extends keyof ED, Cxt extends AsyncContext<ED> | SyncContext<ED>> = {
     priority?: number;
     type: 'relation';
     entity: T;
-    action: Omit<ED[T]['Action'], 'create'> | Array<Omit<ED[T]['Action'], 'create'>>;
-    relationFilter: (operation: ED[T]['Operation'] | ED[T]['Selection'], context: Cxt, option: OperateOption | SelectOption) => ED[T]['Selection']['filter'];
+    when?: 'after';
+    action: ED[T]['Action'] | Array<ED[T]['Action']>;
+    relationFilter: (operation: ED[T]['Operation'] | ED[T]['Selection'], context: Cxt, option: OperateOption | SelectOption) => ED[T]['Selection']['filter'] | Promise<ED[T]['Selection']['filter']>;
     errMsg: string;
-    conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter']);
+    conditionalFilter?: ED[T]['Update']['filter'] | ((operation: ED[T]['Operation'], context: Cxt, option: OperateOption) => ED[T]['Update']['filter'] | Promise<ED[T]['Selection']['filter']>);
 };
-export declare type ExpressionChecker<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: 'expression';
+    type: 'logical';
+    when?: 'after';
     entity: T;
     action: ED[T]['Action'] | Array<ED[T]['Action']>;
-    expression: <T2 extends keyof ED>(operation: ED[T]['Operation'] | ED[T]['Selection'], context: Cxt, option: OperateOption | SelectOption) => {
-        entity: T2;
-        expr: RefOrExpression<keyof ED[T2]['OpSchema']>;
-        filter: ED[T2]['Selection']['filter'];
-    } | undefined | string;
-    errMsg: string;
+    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 declare type ExpressionRelationChecker<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: 'expressionRelation';
+    type: 'logicalRelation';
+    when?: 'after';
     entity: T;
     action: ED[T]['Action'] | Array<ED[T]['Action']>;
-    expression: <T2 extends keyof ED>(operation: ED[T]['Operation'] | ED[T]['Selection'], context: Cxt, option: OperateOption | SelectOption) => {
-        entity: T2;
-        expr: RefOrExpression<keyof ED[T2]['OpSchema']>;
-        filter: ED[T2]['Selection']['filter'];
-    } | undefined | string;
-    errMsg: string;
+    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 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> | ExpressionChecker<ED, T, Cxt> | ExpressionRelationChecker<ED, T, Cxt>;
+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 declare type AuthDefDict<ED extends EntityDict> = {
+    [K in keyof ED]?: AuthDef<ED, K>;
+};

package/lib/types/Endpoint.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { IncomingHttpHeaders, IncomingMessage } from "http";
+import { AsyncContext } from "../store/AsyncRowStore";
+import { EntityDict } from "./Entity";
+export interface Endpoint<ED extends EntityDict, BackCxt extends AsyncContext<ED>> {
+    name: string;
+    params?: string[];
+    method: 'get' | 'post' | 'put' | 'delete';
+    fn: (context: BackCxt, params: Record<string, string>, headers: IncomingHttpHeaders, req: IncomingMessage, body?: any) => Promise<any>;
+}

package/lib/types/Endpoint.js

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

package/lib/types/Entity.d.ts

@@ -1,6 +1,3 @@
-import { GenericAction } from '../actions/action';
-import { ExprOp, MakeFilter, NodeId } from './Demand';
-import { OneOf } from './Polyfill';
 import { PrimaryKey, Sequence } from './DataType';
 declare type TriggerDataAttributeType = '$$triggerData$$';
 declare type TriggerTimestampAttributeType = '$$triggerTimestamp$$';
@@ -18,7 +15,7 @@ export declare const DeleteAtAttribute = "$$deleteAt$$";
 export declare const SeqAttribute = "$$seq$$";
 export declare type InstinctiveAttributes = PrimaryKeyAttributeType | CreateAtAttributeType | UpdateAtAttributeType | DeleteAtAttributeType | TriggerDataAttributeType | TriggerTimestampAttributeType | SeqAttributeType;
 export declare const initinctiveAttributes: string[];
-export declare type Filter<A extends string, F extends Object | undefined = undefined> = {
+declare type FilterPart<A extends string, F extends Object | undefined> = {
     filter?: A extends 'create' ? undefined : F;
     indexFrom?: A extends 'create' ? undefined : number;
     count?: A extends 'create' ? undefined : number;
@@ -44,16 +41,15 @@ export declare type OperateOption = {
 export declare type FormUpdateData<SH extends GeneralEntityShape> = Partial<{
     [K in keyof Omit<SH, InstinctiveAttributes>]: SH[K] | null;
 }>;
-export declare type FormCreateData<SH extends GeneralEntityShape> = Omit<SH, InstinctiveAttributes> & {
+export declare type FormCreateData<SH extends GeneralEntityShape> = Partial<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> = {
+export declare type Operation<A extends string, D extends Projection, F extends Filter | undefined = undefined, S extends Sorter | undefined = undefined> = {
     id?: string;
     action: A;
-    data: DATA;
-    sorter?: SORTER;
-} & 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>;
+    data: D;
+    sorter?: S;
+} & FilterPart<A, F>;
 export interface EntityShape {
     id: PrimaryKey;
     $$seq$$: Sequence;
@@ -61,8 +57,6 @@ export interface EntityShape {
     $$updateAt$$: number | Date;
     $$deleteAt$$?: number | Date | null;
 }
-export interface FileCarrierEntityShape extends EntityShape {
-}
 interface GeneralEntityShape extends EntityShape {
     [K: string]: any;
 }
@@ -72,28 +66,24 @@ export interface EntityDef {
     OpSchema: GeneralEntityShape;
     Action: string;
     ParticularAction?: string;
-    Selection: Omit<DeduceSelection<this['Schema']>, 'action'>;
-    Aggregation: Omit<DeduceAggregation<this['Schema'], DeduceProjection<this['Schema']>, DeduceFilter<this['Schema']>, DeduceSorter<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']>;
+    Selection: Omit<Operation<'select', Projection, Filter, Sorter>, 'action'>;
+    Aggregation: Omit<DeduceAggregation<Projection, Filter, Sorter>, 'action'>;
+    Operation: CUDOperation;
+    Create: CreateOperation;
+    CreateSingle: CreateSingleOperation;
+    CreateMulti: CreateMultipleOperation;
+    Update: UpdateOperation;
+    Remove: RemoveOperation;
+    Relation?: string;
 }
 export interface EntityDict {
     [E: string]: EntityDef;
 }
-export interface OtmSubProjection extends Omit<DeduceSelection<any>, 'action'> {
+export interface OtmSubProjection extends Omit<Operation<'select', any, any, any>, 'action'> {
     $entity: string;
 }
-declare type DeduceProjection<SH extends GeneralEntityShape> = {
-    '#id'?: NodeId;
-} & {
-    [K in keyof SH]?: number | OtmSubProjection | any;
-} & Partial<ExprOp<keyof SH | string>>;
 export declare type AggregationOp = `#max-${number}` | `#min-${number}` | `#avg-${number}` | `#count-${number}` | `#sum-${number}`;
-export declare type DeduceAggregationData<SH extends GeneralEntityShape, P extends DeduceProjection<SH>> = {
+export declare type DeduceAggregationData<P extends Projection> = {
     [A in AggregationOp]?: P;
 } & {
     '#aggr'?: P;
@@ -104,36 +94,40 @@ export declare type AggregationResult<SH extends GeneralEntityShape> = Array<{
     '#data'?: Partial<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]: number | object | undefined;
-} & ExprOp<keyof SH>>;
-export declare type DeduceSorterItem<SH extends GeneralEntityShape> = {
-    $attr: DeduceSorterAttr<SH>;
+    [K in keyof SH]?: any;
+};
+declare type SortAttr = {
+    [K: string]: any;
+};
+declare type SorterItem = {
+    $attr: SortAttr;
     $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 DeduceAggregation<SH extends GeneralEntityShape, P extends DeduceProjection<SH>, F extends DeduceFilter<SH>, S extends DeduceSorter<SH>> = Omit<Operation<'aggregate', DeduceAggregationData<SH, P>, F, S>, 'action'>;
-export declare type DeduceCreateOperationData<SH extends GeneralEntityShape> = {
+declare type Sorter = Array<SorterItem>;
+declare type Filter = {
+    [K: string]: any;
+};
+declare type Projection = {
+    [K: string]: any;
+};
+export declare type DeduceAggregation<P extends Projection, F extends Filter, S extends Sorter> = Omit<Operation<'aggregate', DeduceAggregationData<P>, F, S>, 'action'>;
+declare type CreateOperationData = {
     id: string;
-} & {
-    [k in keyof Omit<SH, InstinctiveAttributes>]?: any;
+    [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> = {
-    [k in keyof Omit<SH, InstinctiveAttributes>]?: any;
+declare type CreateSingleOperation = Operation<'create', CreateOperationData, undefined, undefined>;
+declare type CreateMultipleOperation = Operation<'create', Array<CreateOperationData>, undefined, undefined>;
+declare type CreateOperation = CreateSingleOperation | CreateMultipleOperation;
+declare type UpdateOperationData = {
+    id?: never;
+    [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 Omit<SH, InstinctiveAttributes>]?: any;
+export declare type UpdateOperation = Operation<string, UpdateOperationData, Filter, Sorter>;
+declare type RemoveOperationData = {
+    [k: 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>;
+export declare type RemoveOperation = Operation<'remove', RemoveOperationData, Filter, Sorter>;
+export declare type CUDOperation = CreateOperation | UpdateOperation | RemoveOperation;
 export declare type CreateOpResult<ED extends EntityDict, T extends keyof ED> = {
     a: 'c';
     e: T;
@@ -142,17 +136,24 @@ export declare type CreateOpResult<ED extends EntityDict, T extends keyof ED> =
 export declare type UpdateOpResult<ED extends EntityDict, T extends keyof ED> = {
     a: 'u';
     e: T;
-    d: DeduceUpdateOperationData<ED[T]['Schema']>;
-    f?: DeduceFilter<ED[T]['Schema']>;
+    d: UpdateOperationData;
+    f?: Filter;
 };
 export declare type RemoveOpResult<ED extends EntityDict, T extends keyof ED> = {
     a: 'r';
     e: T;
-    f?: DeduceFilter<ED[T]['Schema']>;
+    f?: Filter;
 };
 export declare type RelationHierarchy<R extends string> = {
     [K in R]?: R[];
 };
+export declare type CascadeRelationItem = {
+    cascadePath: string;
+    relations?: string[];
+};
+export declare type CascadeRelationAuth<R extends string> = {
+    [K in R]?: CascadeRelationItem | (CascadeRelationItem | CascadeRelationItem[])[];
+};
 export declare type SelectOpResult<ED extends EntityDict> = {
     a: 's';
     d: {
@@ -172,19 +173,4 @@ export declare type Configuration = {
     actionType?: ActionType;
     static?: boolean;
 };
-export declare type Exportation<ED extends EntityDict, T extends keyof ED, K extends string> = {
-    name: string;
-    id: string;
-    entity: T;
-    projection: ED[T]['Selection']['data'];
-    headers: K[];
-    fn: (data: ED[T]['Schema']) => Partial<Record<K, string | number | boolean | null>>;
-};
-export declare type Importation<ED extends EntityDict, T extends keyof ED, K extends string> = {
-    name: string;
-    id: string;
-    entity: T;
-    headers: K[];
-    fn: (data: Partial<Record<K, string | number | boolean>>) => ED[T]['CreateSingle']['data'];
-};
 export {};

package/lib/types/Entity.js

@@ -12,4 +12,3 @@ exports.initinctiveAttributes = [exports.PrimaryKeyAttribute, exports.TriggerDat
 ;
 ;
 ;
-;

package/lib/types/Exception.d.ts

@@ -5,6 +5,11 @@ export declare class OakException extends Error {
 }
 export declare class OakDataException extends OakException {
 }
+export declare class OakImportDataParseException extends OakException {
+    line: number;
+    header?: string;
+    constructor(message: string, line: number, header?: string);
+}
 export declare class OakOperExistedException extends OakDataException {
 }
 export declare class OakRowUnexistedException extends OakDataException {

package/lib/types/Exception.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeException = exports.OakDeadlock = exports.OakCongruentRowExists = exports.OakRowLockedException = exports.OakUnloggedInException = exports.OakUserUnpermittedException = exports.OakInputIllegalException = exports.OakRowInconsistencyException = exports.OakUserException = exports.OakExternalException = exports.OakRowUnexistedException = exports.OakOperExistedException = exports.OakDataException = exports.OakException = void 0;
+exports.makeException = exports.OakDeadlock = exports.OakCongruentRowExists = exports.OakRowLockedException = exports.OakUnloggedInException = exports.OakUserUnpermittedException = exports.OakInputIllegalException = exports.OakRowInconsistencyException = exports.OakUserException = exports.OakExternalException = exports.OakRowUnexistedException = exports.OakOperExistedException = exports.OakImportDataParseException = exports.OakDataException = exports.OakException = void 0;
 var tslib_1 = require("tslib");
 var OakException = /** @class */ (function (_super) {
     tslib_1.__extends(OakException, _super);
@@ -36,6 +36,18 @@ var OakDataException = /** @class */ (function (_super) {
     return OakDataException;
 }(OakException));
 exports.OakDataException = OakDataException;
+var OakImportDataParseException = /** @class */ (function (_super) {
+    tslib_1.__extends(OakImportDataParseException, _super);
+    // message必传，描述具体错误的数据内容
+    function OakImportDataParseException(message, line, header) {
+        var _this = _super.call(this, message) || this;
+        _this.line = line;
+        _this.header = header;
+        return _this;
+    }
+    return OakImportDataParseException;
+}(OakException));
+exports.OakImportDataParseException = OakImportDataParseException;
 var OakOperExistedException = /** @class */ (function (_super) {
     tslib_1.__extends(OakOperExistedException, _super);
     function OakOperExistedException() {
@@ -245,6 +257,9 @@ function makeException(data) {
         case 'OakDeadlock': {
             return new OakDeadlock(data.message);
         }
+        case 'OakImportDataParseException': {
+            return new OakImportDataParseException(data.message, data.line, data.header);
+        }
         default:
             return;
     }

package/lib/types/Expression.d.ts

@@ -4,7 +4,7 @@ export declare type RefOrExpression<A> = RefAttr<A> | Expression<A>;
 declare type MathType<A> = RefOrExpression<A> | number;
 declare type StringType<A> = RefOrExpression<A> | string;
 interface Add<A> {
-    $add: (MathType<A> | StringType<A>)[];
+    $add: (MathType<A>)[];
 }
 interface Subtract<A> {
     $subtract: [MathType<A>, MathType<A>];
@@ -111,6 +111,10 @@ interface DateFloor<A> {
     $dateFloor: [RefOrExpression<A> | Date | number, 'y' | 'M' | 'd' | 'h' | 'm' | 's'];
 }
 declare type DateExpression<A> = DateYear<A> | DateMonth<A> | DateWeekday<A> | DateWeekOfYear<A> | DateDay<A> | DateDayOfYear<A> | DateDayOfMonth<A> | DateDayOfWeek<A> | DateDiff<A> | DateCeiling<A> | DateFloor<A>;
+interface StringConcat<A> {
+    $concat: StringType<A>[];
+}
+declare type StringExpression<A> = StringConcat<A>;
 interface GeoContains<A> {
     $contains: [RefOrExpression<A> | Geo, RefOrExpression<A> | Geo];
 }
@@ -118,7 +122,23 @@ interface GeoDistance<A> {
     $distance: [RefOrExpression<A> | Geo, RefOrExpression<A> | Geo];
 }
 declare type GeoExpression<A> = GeoContains<A> | GeoDistance<A>;
-export declare type Expression<A> = GeoExpression<A> | DateExpression<A> | LogicExpression<A> | BoolExpression<A> | CompareExpression<A> | MathExpression<A>;
+interface AggrCountExpression<A> {
+    $$count: RefOrExpression<A>;
+}
+interface AggrSumExpression<A> {
+    $$sum: RefOrExpression<A>;
+}
+interface AggrMaxExpression<A> {
+    $$max: RefOrExpression<A>;
+}
+interface AggrMinExpression<A> {
+    $$min: RefOrExpression<A>;
+}
+interface AggrAvgExpression<A> {
+    $$avg: RefOrExpression<A>;
+}
+export declare type AggrExpression<A> = AggrAvgExpression<A> | AggrCountExpression<A> | AggrSumExpression<A> | AggrMaxExpression<A> | AggrMinExpression<A>;
+export declare type Expression<A> = GeoExpression<A> | DateExpression<A> | LogicExpression<A> | BoolExpression<A> | CompareExpression<A> | MathExpression<A> | StringExpression<A> | AggrExpression<A>;
 export declare type ExpressionConstant = Geo | number | Date | string | boolean;
 export declare function isGeoExpression<A>(expression: any): expression is GeoExpression<A>;
 export declare function isDateExpression<A>(expression: any): expression is DateExpression<A>;
@@ -126,6 +146,8 @@ export declare function isLogicExpression<A>(expression: any): expression is Log
 export declare function isBoolExpression<A>(expression: any): expression is BoolExpression<A>;
 export declare function isCompareExpression<A>(expression: any): expression is CompareExpression<A>;
 export declare function isMathExpression<A>(expression: any): expression is MathExpression<A>;
+export declare function isStringExpression<A>(expression: any): expression is StringExpression<A>;
+export declare function isAggrExpression<A>(expression: any): expression is AggrExpression<A>;
 export declare function isExpression<A>(expression: any): expression is Expression<A>;
 export declare function opMultipleParams(op: string): boolean;
 export declare function execOp(op: string, params: any, obscure?: boolean): ExpressionConstant;

package/lib/types/Expression.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAttrRefInExpression = exports.execOp = exports.opMultipleParams = exports.isExpression = exports.isMathExpression = exports.isCompareExpression = exports.isBoolExpression = exports.isLogicExpression = exports.isDateExpression = exports.isGeoExpression = void 0;
+exports.getAttrRefInExpression = exports.execOp = exports.opMultipleParams = exports.isExpression = exports.isAggrExpression = exports.isStringExpression = exports.isMathExpression = exports.isCompareExpression = exports.isBoolExpression = exports.isLogicExpression = exports.isDateExpression = exports.isGeoExpression = void 0;
 var tslib_1 = require("tslib");
 var assert_1 = tslib_1.__importDefault(require("assert"));
 var dayjs_1 = tslib_1.__importDefault(require("dayjs"));
@@ -42,6 +42,7 @@ dayjs_1.default.extend(dayOfYear_1.default);
 ;
 ;
 ;
+;
 function isGeoExpression(expression) {
     if (Object.keys(expression).length == 1) {
         var op = Object.keys(expression)[0];
@@ -105,13 +106,34 @@ function isMathExpression(expression) {
     return false;
 }
 exports.isMathExpression = isMathExpression;
+function isStringExpression(expression) {
+    if (Object.keys(expression).length == 1) {
+        var op = Object.keys(expression)[0];
+        if (['$concat'].includes(op)) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.isStringExpression = isStringExpression;
+function isAggrExpression(expression) {
+    if (Object.keys(expression).length == 1) {
+        var op = Object.keys(expression)[0];
+        if (['$$max', '$$min', '$$sum', '$$avg', '$$count'].includes(op)) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.isAggrExpression = isAggrExpression;
 function isExpression(expression) {
     return typeof expression === 'object' && Object.keys(expression).length === 1 && Object.keys(expression)[0].startsWith('$');
 }
 exports.isExpression = isExpression;
 function opMultipleParams(op) {
     return !['$year', '$month', '$weekday', '$weekOfYear', '$day', '$dayOfMonth',
-        '$dayOfWeek', '$dayOfYear', '$not', '$true', '$false', '$abs', '$round', '$floor', '$ceil'].includes(op);
+        '$dayOfWeek', '$dayOfYear', '$not', '$true', '$false', '$abs',
+        '$round', '$floor', '$ceil', '$$max', '$$min', '$$sum', '$$avg', '$$count'].includes(op);
 }
 exports.opMultipleParams = opMultipleParams;
 function execOp(op, params, obscure) {
@@ -341,6 +363,9 @@ function execOp(op, params, obscure) {
         case '$contains': {
             throw new Error('$contains类型未实现');
         }
+        case '$concat': {
+            return params.join('');
+        }
         default: {
             (0, assert_1.default)(false, "\u4E0D\u80FD\u8BC6\u522B\u7684expression\u8FD0\u7B97\u7B26\uFF1A".concat(op));
         }