@trudb/tru-common-lib 0.2.554 → 0.2.556

package/fesm2022/trudb-tru-common-lib.mjs

@@ -1849,6 +1849,87 @@ class TruEntityAccessor {
             return queryData.results[0];
         })));
     };
+    propertyPathValues = (entity, propertyPath) => {
+        let values = [entity];
+        propertyPath.split(/[./]/).filter(part => part.length > 0).forEach((part) => {
+            const nextValues = [];
+            values.forEach((value) => {
+                if (value == null)
+                    return;
+                const nextValue = value[part];
+                if (Array.isArray(nextValue))
+                    nextValues.push(...nextValue);
+                else if (nextValue != null)
+                    nextValues.push(nextValue);
+            });
+            values = nextValues;
+        });
+        return values;
+    };
+    propertyPathIsLoaded = (entity, propertyPath) => {
+        let values = [entity];
+        const parts = propertyPath.split(/[./]/).filter(part => part.length > 0);
+        for (const part of parts) {
+            const nextValues = [];
+            for (const value of values) {
+                if (value == null)
+                    continue;
+                const entityAspect = value.entityAspect;
+                const navigationProperty = entityAspect?.entityType?.getNavigationProperty?.(part);
+                if (navigationProperty && !entityAspect.isNavigationPropertyLoaded(navigationProperty))
+                    return false;
+                const nextValue = value[part];
+                if (navigationProperty?.isScalar && nextValue == null &&
+                    navigationProperty.foreignKeyNames?.some((name) => value[name] != null))
+                    return false;
+                if (Array.isArray(nextValue))
+                    nextValues.push(...nextValue);
+                else if (nextValue != null && typeof nextValue === 'object')
+                    nextValues.push(nextValue);
+            }
+            values = nextValues;
+        }
+        return true;
+    };
+    predicateIsLocallyEvaluable = (predicate, entity, entityType) => {
+        const accessor = this;
+        const visitor = {
+            passthruPredicate: function () { return false; },
+            unaryPredicate: function (context) {
+                return this.pred.visit(context);
+            },
+            binaryPredicate: function (context) {
+                return this.expr1.visit(context) && this.expr2.visit(context);
+            },
+            andOrPredicate: function (context) {
+                return this.preds.every((item) => item.visit(context));
+            },
+            anyAllPredicate: function (context) {
+                if (!this.expr.visit(context))
+                    return false;
+                return accessor.propertyPathValues(context.entity, this.exprSource)
+                    .every(item => this.pred.visit({ ...context, entity: item, entityType: this.expr.dataType }));
+            },
+            litExpr: function () { return true; },
+            propExpr: function (context) {
+                return accessor.propertyPathIsLoaded(context.entity, this.propertyPath);
+            },
+            fnExpr: function (context) {
+                return this.exprs.every((item) => item.visit(context));
+            }
+        };
+        try {
+            return predicate.visit({ entity, entityType }, visitor);
+        }
+        catch {
+            return false;
+        }
+    };
+    queryIsLocallyEvaluable = (query, entities) => {
+        if (!query.wherePredicate)
+            return true;
+        return entities.every(entity => this.predicateIsLocallyEvaluable(query.wherePredicate, entity, entity.entityAspect?.entityType));
+    };
     searchByRefArrayCacheOnly = (entity, setupQuery = null, refs, includeDeleted = false) => {
         if (!includeDeleted)
             includeDeleted = false;
@@ -1872,6 +1953,12 @@ class TruEntityAccessor {
         var results = this._entityManager.executeQueryLocally(query);
         if (results && results.length)
             return results;
+        var refQuery = this._breezeContext.createQuery(this.getQueryServiceName(entity)).using(queryOptions);
+        if (refs.length > 0)
+            refQuery = refQuery.where(this.getPrimaryKeyName(entity), 'in', refs);
+        var refResults = this._entityManager.executeQueryLocally(refQuery);
+        if (refResults.length && !this.queryIsLocallyEvaluable(query, refResults))
+            return undefined;
         return null;
     };
     searchByRefWithQuery = (entity, setupQuery, ref) => {
@@ -6914,7 +7001,7 @@ class TruDataGridCellRenderer {
     init(params) {
         params.eGridCell.innerHTML = '';
         const value = params.value ?? '';
-        if (params.colDef.cellEditor && params.colDef.cellEditor.name === "StdRichTextList") {
+        if (params.renderRichText === true) {
             var p = document.createElement('div');
             p.innerHTML = value;
             params.eGridCell.appendChild(p);
@@ -8515,12 +8602,17 @@ class TruDataChangeParser {
     };
     entityFoundByQuery = (change) => {
         var entityAccessor = this.dataContext.entityAccess();
-        var entities = entityAccessor.searchByRefArrayCacheOnly(this.entity, this.getLatestQuery(), [change.tableRef]);
-        if (!entities?.length) {
+        var localEntities = entityAccessor.searchByRefArrayCacheOnly(this.entity, this.getLatestQuery(), [change.tableRef]);
+        var globalEntities = null;
+        if (!localEntities?.length) {
             var entityAccessor = this.globalDataContext.entityAccess();
-            entities = entityAccessor.searchByRefArrayCacheOnly(this.entity, this.getLatestQuery(), [change.tableRef]);
+            globalEntities = entityAccessor.searchByRefArrayCacheOnly(this.entity, this.getLatestQuery(), [change.tableRef]);
         }
-        return entities === null ? 0 : entities.length;
+        if (localEntities?.length || globalEntities?.length)
+            return true;
+        if (localEntities === undefined || globalEntities === undefined)
+            return undefined;
+        return false;
     };
     getEntityFromServer = (change) => {
         var entityAccessor = this.dataContext.entityAccess();
@@ -8557,20 +8649,24 @@ class TruDataChangeParser {
                         if (change.changeOperation === 'U') {
                             this.applyPropertyChanges(change, entity);
                             var results = this.getLatestResults();
-                            if (this.entityFoundByQuery(change)) {
+                            var entityMatchesQuery = this.entityFoundByQuery(change);
+                            if (entityMatchesQuery === true) {
                                 var entityAlreadyInResults = this.getEntityFromResults(results, change);
                                 if (!entityAlreadyInResults.length && this.isLoaded()) {
                                     this.addEntity(entity);
                                 }
                                 reloadResults = true;
                             }
-                            else {
+                            else if (entityMatchesQuery === false) {
                                 var entityToRemove = this.getEntityFromResults(results, change);
                                 if (entityToRemove.length) {
                                     results.splice(results.indexOf(entityToRemove[0]), 1);
                                     reloadResults = true;
                                 }
                             }
+                            else {
+                                reloadResults = true;
+                            }
                         }
                         else if (change.changeOperation === 'D') {
                             var results = this.getLatestResults();
@@ -8584,7 +8680,8 @@ class TruDataChangeParser {
                         else if (change.changeOperation === 'I') {
                             var results = this.getLatestResults();
                             var entityAlreadyInResults = this.getEntityFromResults(results, change);
-                            if (this.entityFoundByQuery(change) && !entityAlreadyInResults.length && this.isLoaded()) {
+                            var entityMatchesQuery = this.entityFoundByQuery(change);
+                            if (entityMatchesQuery === true && !entityAlreadyInResults.length && this.isLoaded()) {
                                 if (!localEntity) {
                                     var newEntity = this.dataContext.entityAccess().add(this.entity, this.contextFilters);
                                     const pkeyName = change.tableName + 'Ref';
@@ -8601,7 +8698,7 @@ class TruDataChangeParser {
                                     reloadResults = true;
                                 }
                             }
-                            else if (!this.entityFoundByQuery(change) && entityAlreadyInResults.length) {
+                            else if (entityMatchesQuery === false && entityAlreadyInResults.length) {
                                 var entityToDelete = this.getEntityFromResults(results, change);
                                 if (entityToDelete.length) {
                                     results.splice(results.indexOf(entityAlreadyInResults[0]), 1);
@@ -8629,7 +8726,7 @@ class TruDataChangeParser {
                 await this.getEntityFromServer(change).subscribe((entity) => {
                     if (entity) {
                         this.applyPropertyChanges(change, entity);
-                        if (this.entityFoundByQuery(change) && this.isLoaded()) {
+                        if (this.entityFoundByQuery(change) === true && this.isLoaded()) {
                             this.addEntity(newEntity);
                             reloadResults = true;
                         }
@@ -8646,7 +8743,7 @@ class TruDataChangeParser {
                     const pkeyName2 = change.tableName + 'Ref';
                     newEntity[pkeyName2] = change.tableRef;
                     this.applyPropertyChanges(change, newEntity);
-                    if (this.entityFoundByQuery(change) && this.isLoaded()) {
+                    if (this.entityFoundByQuery(change) === true && this.isLoaded()) {
                         this.addEntity(newEntity);
                         reloadResults = true;
                     }
@@ -8953,23 +9050,6 @@ class TruDataGrid {
             this.api.refreshCells({ force: true });
         }
     };
-    refsEqual = (left, right) => {
-        return left !== null && left !== undefined &&
-            right !== null && right !== undefined &&
-            left.toString() === right.toString();
-    };
-    confirmRowMembershipBeforeRemoval = (rowNode) => {
-        const ref = rowNode.data?.$entity?.Ref;
-        if (ref === null || ref === undefined)
-            return;
-        this.dataContext.entityAccess().searchByRefWithQuery(this.config.resultConfig.entityType, this.latestSetupQuery, ref).subscribe((results) => {
-            if (results?.length)
-                return;
-            const currentRowNode = rowNode.id === undefined ? null : this.api?.getRowNode(rowNode.id);
-            if (currentRowNode)
-                this.api.applyTransaction({ remove: [currentRowNode.data] });
-        });
-    };
     subscribeTo = () => {
         this.subs.push(this.appEnvironment.onSaveComplete$.pipe(skip(1)).subscribe(event => {
             if (event?.successful)
@@ -9038,16 +9118,17 @@ class TruDataGrid {
             dataChange.dataChanges.forEach((change) => {
                 if (change.changeOperation === 'D') {
                     this.api.forEachNode((rowNode) => {
-                        if (this.refsEqual(rowNode.data.$entity.Ref, change.tableRef))
-                            rowNodesToRemove.push(rowNode.data);
+                        if (rowNode.data.$entity.Ref === change.tableRef) {
+                            rowNodesToRemove.push({ $entity: { Ref: rowNode.id } });
+                        }
                     });
                 }
                 if (change.changeOperation === 'U' || change.changeOperation === 'I') {
                     this.api.forEachNode((rowNode) => {
-                        if (this.refsEqual(rowNode.data.$entity.Ref, change.tableRef)) {
+                        if (rowNode.data.$entity.Ref === change.tableRef) {
                             let results = this.dataContext.entityAccess().searchByRefArrayCacheOnly(this.config.resultConfig.entityType, this.latestSetupQuery, [rowNode.data.$entity.Ref]);
-                            if (!results)
-                                this.confirmRowMembershipBeforeRemoval(rowNode);
+                            if (results === null)
+                                rowNodesToRemove.push({ $entity: { Ref: rowNode.id } });
                         }
                     });
                 }