oak-domain 4.2.1 → 4.2.2

package/lib/store/CascadeStore.d.ts

@@ -61,14 +61,14 @@ export declare abstract class CascadeStore<ED extends EntityDict & BaseEntityDic
      * @param filter
      * @returns
      */
-    protected destructCascadeUpdate<T extends keyof ED, Cxt extends SyncContext<ED> | AsyncContext<ED>, OP extends OperateOption, R>(entity: T, action: ED[T]['Action'], data: ED[T]['CreateSingle']['data'] | ED[T]['Update']['data'] | ED[T]['Remove']['data'], context: Cxt, option: OP, cascadeUpdate: <T2 extends keyof ED>(entity: T2, operation: ED[T2]['Operation'], context: Cxt, option: OP) => R, filter?: ED[T]['Update']['filter']): {
+    protected destructCascadeUpdate<T extends keyof ED, Cxt extends SyncContext<ED> | AsyncContext<ED>, OP extends OperateOption, R>(entity: T, action: ED[T]['Action'], data: ED[T]['CreateSingle']['data'] | ED[T]['Update']['data'] | ED[T]['Remove']['data'], context: Cxt, option: OP, cascadeUpdate: <T2 extends keyof ED>(entity: T2, operation: ED[T2]['Operation'], context: Cxt, option: OP) => R, filter?: ED[T]['Update']['filter'], bornAt?: number): {
         data: Record<string, any>;
         beforeFns: (() => R)[];
         afterFns: (() => R)[];
     };
     protected preProcessDataCreated<T extends keyof ED>(entity: T, data: ED[T]['Create']['data']): void;
     protected preProcessDataUpdated(data: Record<string, any>): void;
-    judgeRelation(entity: keyof ED, attr: string): string | 1 | 2 | string[] | 0;
+    judgeRelation(entity: keyof ED, attr: string): string | 1 | 2 | string[] | 0 | -1;
     /**
      * 和具体的update过程无关的例程放在这里，包括对later动作的处理、对oper的记录以及对record的收集等
      * @param entity

package/lib/store/CascadeStore.js

@@ -674,7 +674,7 @@ class CascadeStore extends RowStore_1.RowStore {
      * @param filter
      * @returns
      */
-    destructCascadeUpdate(entity, action, data, context, option, cascadeUpdate, filter) {
+    destructCascadeUpdate(entity, action, data, context, option, cascadeUpdate, filter, bornAt) {
         const modiAttr = this.getSchema()[entity].toModi;
         const option2 = Object.assign({}, option);
         const opData = {};
@@ -696,7 +696,7 @@ class CascadeStore extends RowStore_1.RowStore {
             }
         }
         for (const attr in data) {
-            const relation = (0, relation_1.judgeRelation)(this.storageSchema, entity, attr);
+            const relation = (0, relation_1.judgeRelation)(this.storageSchema, entity, attr, !!bornAt);
             if (relation === 1) {
                 Object.assign(opData, {
                     [attr]: data[attr],
@@ -814,8 +814,7 @@ class CascadeStore extends RowStore_1.RowStore {
                 }
                 beforeFns.push(() => cascadeUpdate.call(this, relation, operationMto, context, option2));
             }
-            else {
-                (0, assert_1.default)(relation instanceof Array);
+            else if (relation instanceof Array) {
                 const [entityOtm, foreignKey] = relation;
                 const otmOperations = data[attr];
                 const dealWithOneToMany = (otm) => {
@@ -969,6 +968,9 @@ class CascadeStore extends RowStore_1.RowStore {
                     dealWithOneToMany(otmOperations);
                 }
             }
+            else {
+                console.warn(`接收到不合法的属性「${attr}」`);
+            }
         }
         return {
             data: opData,
@@ -1444,7 +1446,7 @@ class CascadeStore extends RowStore_1.RowStore {
         }
     }
     cascadeUpdate(entity, operation, context, option) {
-        const { action, data, filter, id } = operation;
+        const { action, data, filter, id, bornAt } = operation;
         let opData;
         const wholeBeforeFns = [];
         const wholeAfterFns = [];
@@ -1484,21 +1486,21 @@ class CascadeStore extends RowStore_1.RowStore {
      * @param option
      */
     async cascadeUpdateAsync(entity, operation, context, option) {
-        const { action, data, filter, id } = operation;
+        const { action, data, filter, id, bornAt } = operation;
         let opData;
         const wholeBeforeFns = [];
         const wholeAfterFns = [];
         if (['create', 'create-l'].includes(action) && data instanceof Array) {
             opData = [];
             for (const d of data) {
-                const { data: od, beforeFns, afterFns } = this.destructCascadeUpdate(entity, action, d, context, option, this.cascadeUpdateAsync);
+                const { data: od, beforeFns, afterFns } = this.destructCascadeUpdate(entity, action, d, context, option, this.cascadeUpdateAsync, undefined, bornAt);
                 opData.push(od);
                 wholeBeforeFns.push(...beforeFns);
                 wholeAfterFns.push(...afterFns);
             }
         }
         else {
-            const { data: od, beforeFns, afterFns } = this.destructCascadeUpdate(entity, action, data, context, option, this.cascadeUpdateAsync, filter);
+            const { data: od, beforeFns, afterFns } = this.destructCascadeUpdate(entity, action, data, context, option, this.cascadeUpdateAsync, filter, bornAt);
             opData = od;
             wholeBeforeFns.push(...beforeFns);
             wholeAfterFns.push(...afterFns);

package/lib/store/RelationAuth.js

@@ -53,7 +53,7 @@ class RelationAuth {
          * @param destRelationId
          * @returns
          */
-        const checkOnRelationId = (destRelationId, entity, filter) => {
+        const checkOnRelationId = (entity, destRelationId, filter) => {
             /**
              * 找到能创建此relation的所有父级relation，只要user和其中一个有关联即可以通过
              */
@@ -114,20 +114,48 @@ class RelationAuth {
          * @param relationFilter 限定relationId的条件
          * @param intersection 是否交集（对每个relationId都得有权限）
          * @param entityFilter 限定entity的条件
+         * @param entity 对应的entity
+         * @attention 这里为了代码复用，有可能是要通过本函数内部来查询确定entity；所以要保证，如果传入的relationFilter就可以确定relationId，则这里的entity参数必传。
          * @returns
          */
-        const checkOnMultipleRelations = (relationFilter, intersection, entityFilter) => {
-            const relations = context.select('relation', {
-                data: {
-                    id: 1,
-                    entity: 1,
-                    entityId: 1,
-                },
-                filter: relationFilter
-            }, { dontCollect: true });
-            if (relations instanceof Promise) {
-                return relations.then((rs) => {
-                    return Promise.all(rs.map(ele => checkOnRelationId(ele.id, ele.entity, entityFilter))).then((value) => {
+        const checkOnMultipleRelations = (relationFilter, intersection, entityFilter, entity) => {
+            let entity2 = entity;
+            const getRelationIds = () => {
+                const relevantIds = (0, filter_1.getRelevantIds)(relationFilter);
+                if (relevantIds.length > 0) {
+                    return relevantIds;
+                }
+                const relations = context.select('relation', {
+                    data: {
+                        id: 1,
+                        entity: 1,
+                        entityId: 1,
+                    },
+                    filter: relationFilter
+                }, { dontCollect: true });
+                if (relations instanceof Promise) {
+                    return relations.then((rs) => {
+                        if (!entity2) {
+                            entity2 = rs[0]?.entity;
+                        }
+                        else {
+                            (0, assert_1.default)(entity2 === rs[0]?.entity);
+                        }
+                        return rs.map(ele => ele.id);
+                    });
+                }
+                if (!entity2) {
+                    entity2 = relations[0]?.entity;
+                }
+                else {
+                    (0, assert_1.default)(entity2 === relations[0]?.entity);
+                }
+                return relations.map(ele => ele.id);
+            };
+            const relationIds = getRelationIds();
+            if (relationIds instanceof Promise) {
+                return relationIds.then((ids) => {
+                    return Promise.all(ids.map(ele => checkOnRelationId(entity2, ele, entityFilter))).then((value) => {
                         if (intersection) {
                             return !(value.includes(false));
                         }
@@ -135,7 +163,7 @@ class RelationAuth {
                     });
                 });
             }
-            const value = relations.map(ele => checkOnRelationId(ele.id, ele.entity, entityFilter));
+            const value = relationIds.map(ele => checkOnRelationId(entity2, ele, entityFilter));
             if (intersection) {
                 return !(value.includes(false));
             }
@@ -156,12 +184,14 @@ class RelationAuth {
             }
             if (relationId) {
                 // 如果指定relation，则测试该relation上是否可行
-                (0, assert_1.default)(typeof relationId === 'string');
-                return checkOnRelationId(relationId, entity, entityFilter);
+                // 目前可能会有多个relationIds传入（userEntityGrant做测试），但一定是可以确定的relationId集合                
+                return checkOnMultipleRelations({ id: relationId }, true, entityFilter, entity);
             }
             else {
                 // 否则为测试“能否”有权限管理的资格，此时只要有一个就可以
                 // 这是为上层的menu所有，真正的创建不可能走到这里
+                // bug fixed，目前框架不支持entityId为null，所以这里暂时只支持entityId一种方式的测试
+                (0, assert_1.default)(entityId);
                 return checkOnMultipleRelations({
                     entity,
                     $or: [
@@ -171,10 +201,10 @@ class RelationAuth {
                             },
                         },
                         {
-                            [entity]: entityFilter,
+                            entityId,
                         }
                     ]
-                }, false, entityFilter);
+                }, false, entityFilter, entity);
             }
         }
         else {
@@ -184,7 +214,7 @@ class RelationAuth {
                 userRelation$relation: filter,
             }, false, {
                 userRelation$entity: filter,
-            });
+            }, filter.entity);
         }
     }
     checkOperateSpecialEntities2(entity2, action, filter, context) {

package/lib/store/relation.d.ts

@@ -9,4 +9,4 @@ import { StorageSchema } from "../types/Storage";
  * @param row
  * @returns
  */
-export declare function judgeRelation<ED extends EntityDict & BaseEntityDict>(schema: StorageSchema<ED>, entity: keyof ED, attr: string): string | 1 | 2 | string[] | 0;
+export declare function judgeRelation<ED extends EntityDict & BaseEntityDict>(schema: StorageSchema<ED>, entity: keyof ED, attr: string, allowUnrecoganized?: boolean): string | 1 | 2 | string[] | 0 | -1;

package/lib/store/relation.js

@@ -13,7 +13,7 @@ const Entity_1 = require("../types/Entity");
  * @param row
  * @returns
  */
-function judgeRelation(schema, entity, attr) {
+function judgeRelation(schema, entity, attr, allowUnrecoganized) {
     const { [entity]: { attributes } } = schema;
     if (attr.startsWith(Demand_1.EXPRESSION_PREFIX) || attr.startsWith('#')) {
         // 表达式属性或者metadata
@@ -60,8 +60,15 @@ function judgeRelation(schema, entity, attr) {
         return 2;
     }
     else {
-        (0, assert_1.default)(Entity_1.initinctiveAttributes.includes(attr), `${entity}对象中的${attr}属性找不到`);
-        return 1;
+        if (Entity_1.initinctiveAttributes.includes(attr)) {
+            return 1;
+        }
+        else if (allowUnrecoganized) {
+            return -1;
+        }
+        else {
+            throw new Error(`${entity}对象中的${attr}属性找不到`);
+        }
     }
 }
 exports.judgeRelation = judgeRelation;

package/lib/types/Sync.d.ts

@@ -17,26 +17,47 @@ export type SelfEncryptInfo = {
     privateKey: string;
     algorithm: Algorithm;
 };
-export interface SyncEntityDef<ED extends EntityDict & BaseEntityDict, T extends keyof ED> {
+export interface PullEntityDef<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>> {
+    direction: 'pull';
     entity: T;
     path: string;
     recursive?: boolean;
     relationName?: string;
-    direction: 'pull' | 'push' | 'bio';
+    process?: <A extends ED[T]['Action']>(action: A, data: ED[T]['Operation']['data'], context: Cxt) => Promise<void>;
 }
-export interface SyncRemoteConfigBase<ED extends EntityDict & BaseEntityDict> {
+export interface PushEntityDef<ED extends EntityDict & BaseEntityDict, T extends keyof ED, Cxt extends AsyncContext<ED>> {
+    direction: 'push';
+    entity: T;
+    path: string;
+    recursive?: boolean;
+    relationName?: string;
+    actions?: ED[T]['Action'][];
+    onSynchronized?: (result: {
+        action: ED[T]['Action'];
+        data: ED[T]['Operation']['data'];
+        result: Array<{
+            userId: string;
+            rowIds: string[];
+            error?: Error;
+        }>;
+    }, context: Cxt) => Promise<void>;
+}
+export interface SyncRemoteConfigBase<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> {
     entity: keyof ED;
+    entitySelf?: keyof ED;
     endpoint?: string;
     pathToUser?: string;
     relationName?: string;
-    syncEntities: Array<SyncEntityDef<ED, keyof ED>>;
+    pushEntities?: Array<PushEntityDef<ED, keyof ED, Cxt>>;
+    pullEntities?: Array<PullEntityDef<ED, keyof ED, Cxt>>;
 }
-interface SyncRemoteConfig<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> extends SyncRemoteConfigBase<ED> {
+interface SyncRemoteConfig<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> extends SyncRemoteConfigBase<ED, Cxt> {
     getPushInfo: (userId: string, context: Cxt) => Promise<RemotePushInfo>;
     getPullInfo: (id: string, context: Cxt) => Promise<RemotePullInfo>;
 }
 export interface SyncSelfConfigBase<ED extends EntityDict & BaseEntityDict> {
     endpoint?: string;
+    entitySelf: keyof ED;
 }
 interface SyncSelfConfig<ED extends EntityDict & BaseEntityDict, Cxt extends AsyncContext<ED>> extends SyncSelfConfigBase<ED> {
     getSelfEncryptInfo: (context: Cxt) => Promise<SelfEncryptInfo>;

package/lib/types/Sync.js

@@ -6,3 +6,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 ;
 ;
 ;
+;

package/lib/utils/relationPath.d.ts

@@ -11,7 +11,7 @@ import { EntityDict } from "../types/Entity";
  */
 export declare function destructRelationPath<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(schema: StorageSchema<ED>, entity: T, path: string, relationFilter: ED['userRelation']['Selection']['filter'], recursive?: boolean): {
     projection: ED[T]['Selection']['data'];
-    getData: (d: Partial<ED[T]['Schema']>) => ED['userRelation']['Schema'][];
+    getData: (d: Partial<ED[T]['Schema']>) => ED['userRelation']['Schema'][] | undefined;
 };
 /**
  * 根据entity的相对path，找到对应的根结点对象上的直接userId
@@ -27,5 +27,5 @@ export declare function destructDirectPath<ED extends EntityDict & BaseEntityDic
         entity: keyof ED;
         entityId: string;
         userId: string;
-    }[];
+    }[] | undefined;
 };

package/lib/utils/relationPath.js

@@ -59,7 +59,7 @@ function destructRelationPath(schema, entity, path, relationFilter, recursive) {
                             userId: 1,
                         },
                         filter: relationFilter,
-                    }
+                    } // as ED['userRelation']['Selection']
                 },
                 getData: (d) => {
                     return d.userRelation$entity;
@@ -100,7 +100,7 @@ function destructRelationPath(schema, entity, path, relationFilter, recursive) {
                         data: projection,
                     },
                 },
-                getData: (d) => d[attr] && d[attr].map((ele) => getData(ele)),
+                getData: (d) => d[attr] && d[attr].map(ele => getData(ele)).flat().filter(ele => !!ele),
             };
         }
     };
@@ -133,11 +133,11 @@ function destructDirectPath(schema, entity, path, recursive) {
                     },
                     getData: (d) => {
                         if (d) {
-                            return {
-                                entity: e,
-                                entityId: d.id,
-                                userId: d.entityId,
-                            };
+                            return [{
+                                    entity: e,
+                                    entityId: d.id,
+                                    userId: d.entityId,
+                                }];
                         }
                     },
                 };
@@ -151,11 +151,11 @@ function destructDirectPath(schema, entity, path, recursive) {
                     },
                     getData: (d) => {
                         if (d) {
-                            return {
-                                entity: e,
-                                entityId: d.id,
-                                userId: d[`${attr}Id`]
-                            };
+                            return [{
+                                    entity: e,
+                                    entityId: d.id,
+                                    userId: d[`${attr}Id`],
+                                }];
                         }
                     },
                 };
@@ -193,7 +193,7 @@ function destructDirectPath(schema, entity, path, recursive) {
                         data: projection,
                     },
                 },
-                getData: (d) => d[attr] && d[attr].map((ele) => getData(ele)),
+                getData: (d) => d[attr] && d[attr].map(ele => getData(ele)).flat().filter(ele => !!ele),
             };
         }
     };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oak-domain",
-    "version": "4.2.1",
+    "version": "4.2.2",
     "author": {
         "name": "XuChang"
     },