Presentation: Enforce result paging for hierarchy compare (#678)

* Enforce hierarchy compare result paging

* extract-api

* rush change

* Restore broken public api

* rush extract-api

* Rename to 'continuationToken'

* Add test for hierarchy compare paging

* Update RPC version

common/api/presentation-backend.api.md

@@ -20,6 +20,7 @@ import { EventSink } from '@bentley/imodeljs-backend';
 import { ExtendedContentRequestOptions } from '@bentley/presentation-common';
 import { ExtendedHierarchyRequestOptions } from '@bentley/presentation-common';
 import { FormatProps } from '@bentley/imodeljs-quantity';
+import { HierarchyCompareInfo } from '@bentley/presentation-common';
 import { HierarchyRequestOptions } from '@bentley/presentation-common';
 import { Id64String } from '@bentley/bentleyjs-core';
 import { IDisposable } from '@bentley/bentleyjs-core';
@@ -158,7 +159,7 @@ export class PresentationManager {
     // @deprecated (undocumented)
     compareHierarchies(requestContext: ClientRequestContext, requestOptions: PresentationDataCompareOptions<IModelDb, NodeKey>): Promise<PartialHierarchyModification[]>;
     // @beta
-    compareHierarchies(requestOptions: WithClientRequestContext<PresentationDataCompareOptions<IModelDb, NodeKey>>): Promise<PartialHierarchyModification[]>;
+    compareHierarchies(requestOptions: WithClientRequestContext<PresentationDataCompareOptions<IModelDb, NodeKey>>): Promise<HierarchyCompareInfo>;
     // @deprecated
     computeSelection(requestContext: ClientRequestContext, requestOptions: SelectionScopeRequestOptions<IModelDb>, ids: Id64String[], scopeId: string): Promise<KeySet>;
     // @beta
@@ -277,6 +278,8 @@ export interface PresentationManagerProps {
     };
     // @alpha
     updatesPollInterval?: number;
+    // @alpha
+    useMmap?: boolean | number;
 }
 
 // @public

common/api/presentation-common.api.md

@@ -812,6 +812,34 @@ export enum GroupingSpecificationTypes {
     SameLabelInstance = "SameLabelInstance"
 }
 
+// @alpha (undocumented)
+export interface HierarchyCompareInfo {
+    // (undocumented)
+    changes: PartialHierarchyModification[];
+    // (undocumented)
+    continuationToken?: {
+        prevHierarchyNode: string;
+        currHierarchyNode: string;
+    };
+}
+
+// @alpha (undocumented)
+export namespace HierarchyCompareInfo {
+    export function fromJSON(json: HierarchyCompareInfoJSON): HierarchyCompareInfo;
+    export function toJSON(obj: HierarchyCompareInfo): HierarchyCompareInfoJSON;
+}
+
+// @alpha (undocumented)
+export interface HierarchyCompareInfoJSON {
+    // (undocumented)
+    changes: PartialHierarchyModificationJSON[];
+    // (undocumented)
+    continuationToken?: {
+        prevHierarchyNode: string;
+        currHierarchyNode: string;
+    };
+}
+
 // @public
 export interface HierarchyRequestOptions<TIModel> extends RequestOptionsWithRuleset<TIModel> {
 }
@@ -1523,13 +1551,20 @@ export const PRESENTATION_COMMON_ROOT: string;
 
 // @alpha
 export interface PresentationDataCompareOptions<TIModel, TNodeKey> extends RequestOptionsWithRuleset<TIModel> {
+    // (undocumented)
+    continuationToken?: {
+        prevHierarchyNode: string;
+        currHierarchyNode: string;
+    };
     // (undocumented)
     expandedNodeKeys?: TNodeKey[];
     // (undocumented)
     prev: {
         rulesetOrId?: Ruleset | string;
         rulesetVariables?: RulesetVariable[];
     };
+    // (undocumented)
+    resultSetSize?: number;
 }
 
 // @alpha
@@ -1548,8 +1583,10 @@ export enum PresentationRpcEvents {
 
 // @public
 export class PresentationRpcInterface extends RpcInterface {
-    // @alpha
+    // @alpha @deprecated (undocumented)
     compareHierarchies(_token: IModelRpcProps, _options: PresentationDataCompareRpcOptions): PresentationRpcResponse<PartialHierarchyModificationJSON[]>;
+    // @alpha (undocumented)
+    compareHierarchiesPaged(_token: IModelRpcProps, _options: PresentationDataCompareRpcOptions): PresentationRpcResponse<HierarchyCompareInfoJSON>;
     // (undocumented)
     computeSelection(_token: IModelRpcProps, _options: SelectionScopeRpcRequestOptions, _ids: Id64String[], _scopeId: string): PresentationRpcResponse<KeySetJSON>;
     // @deprecated (undocumented)
@@ -2071,6 +2108,8 @@ export class RpcRequestsHandler implements IDisposable {
     // (undocumented)
     compareHierarchies(options: PresentationDataCompareOptions<IModelRpcProps, NodeKeyJSON>): Promise<PartialHierarchyModificationJSON[]>;
     // (undocumented)
+    compareHierarchiesPaged(options: PresentationDataCompareOptions<IModelRpcProps, NodeKeyJSON>): Promise<HierarchyCompareInfoJSON>;
+    // (undocumented)
     computeSelection(options: SelectionScopeRequestOptions<IModelRpcProps>, ids: Id64String[], scopeId: string): Promise<KeySetJSON>;
     // (undocumented)
     dispose(): void;

common/api/summary/presentation-common.exports.csv

@@ -104,6 +104,9 @@ public;GroupingRule
 public;GroupingSpecification = ClassGroup | PropertyGroup | SameLabelInstanceGroup
 public;GroupingSpecificationBase
 public;GroupingSpecificationTypes
+alpha;HierarchyCompareInfo
+alpha;HierarchyCompareInfo
+alpha;HierarchyCompareInfoJSON
 public;HierarchyRequestOptions
 public;HierarchyRpcRequestOptions = PresentationRpcRequestOptions
 alpha;HierarchyUpdateInfo = typeof UPDATE_FULL | PartialHierarchyModification[]

common/changes/@bentley/presentation-backend/presentation-hierarchy_compare_paging_2021-01-29-14-50.json

@@ -0,0 +1,11 @@
+{
+  "changes": [
+    {
+      "packageName": "@bentley/presentation-backend",
+      "comment": "Enforce max result set size for hierarchy compare.",
+      "type": "none"
+    }
+  ],
+  "packageName": "@bentley/presentation-backend",
+  "email": "24278440+saskliutas@users.noreply.github.com"
+}

common/changes/@bentley/presentation-common/presentation-hierarchy_compare_paging_2021-01-29-14-50.json

@@ -0,0 +1,11 @@
+{
+  "changes": [
+    {
+      "packageName": "@bentley/presentation-common",
+      "comment": "Added HierarchyCompareInfo object that describes hierarchy changes and next step from which comparison should be continued.",
+      "type": "none"
+    }
+  ],
+  "packageName": "@bentley/presentation-common",
+  "email": "24278440+saskliutas@users.noreply.github.com"
+}

common/changes/@bentley/presentation-frontend/presentation-hierarchy_compare_paging_2021-01-29-14-50.json

@@ -0,0 +1,11 @@
+{
+  "changes": [
+    {
+      "packageName": "@bentley/presentation-frontend",
+      "comment": "Changed 'compareHierarchy' to build result in pages for massive result sets. ",
+      "type": "none"
+    }
+  ],
+  "packageName": "@bentley/presentation-frontend",
+  "email": "24278440+saskliutas@users.noreply.github.com"
+}

full-stack-tests/presentation/src/frontend/Update.test.tsx

@@ -649,6 +649,77 @@ describe("Update", () => {
 
     });
 
+    describe("paging", () => {
+
+      it("collects results from multiple pages", async () => {
+        const ruleset = await Presentation.presentation.rulesets().add({
+          id: faker.random.uuid(),
+          rules: [{
+            ruleType: RuleTypes.RootNodes,
+            specifications: [{
+              specType: ChildNodeSpecificationTypes.CustomNode,
+              type: "T_ROOT-1",
+              label: "root-1",
+            }],
+          }],
+        });
+        expect(ruleset).to.not.be.undefined;
+
+        const { result, unmount } = renderHook(
+          (props: PresentationTreeNodeLoaderProps) => usePresentationTreeNodeLoader(props),
+          { initialProps: { imodel, ruleset, pagingSize: 100, enableHierarchyAutoUpdate: true } },
+        );
+        await loadHierarchy(result.current);
+        unmount();
+
+        const modifiedRuleset = await Presentation.presentation.rulesets().modify(ruleset, {
+          rules: [
+            {
+              ruleType: RuleTypes.RootNodes,
+              specifications: [{
+                specType: ChildNodeSpecificationTypes.CustomNode,
+                type: "T_ROOT-0",
+                label: "root-0",
+              }],
+            },
+            ...ruleset.rules,
+            {
+              ruleType: RuleTypes.RootNodes,
+              specifications: [{
+                specType: ChildNodeSpecificationTypes.CustomNode,
+                type: "T_ROOT-2",
+                label: "root-2",
+              }],
+            },
+          ],
+        });
+        expect(modifiedRuleset).to.not.be.undefined;
+
+        const rpcSpy = sinon.spy(Presentation.presentation.rpcRequestsHandler, "compareHierarchiesPaged");
+        const changes = await Presentation.presentation.compareHierarchies({
+          imodel,
+          prev: {
+            rulesetOrId: ruleset,
+            rulesetVariables: [],
+          },
+          rulesetOrId: modifiedRuleset,
+          rulesetVariables: [],
+          resultSetSize: 1,
+        });
+        expect(changes).to.containSubset([{
+          type: "Insert",
+          node: { key: { type: "T_ROOT-0" } },
+          position: 0,
+        }, {
+          type: "Insert",
+          node: { key: { type: "T_ROOT-2" } },
+          position: 2,
+        }]);
+        expect(rpcSpy).to.be.calledTwice;
+      });
+
+    });
+
   });
 
 });

presentation/backend/src/presentation-backend/PresentationManager.ts

@@ -14,9 +14,10 @@ import { FormatProps } from "@bentley/imodeljs-quantity";
 import {
   Content, ContentDescriptorRequestOptions, ContentFlags, ContentRequestOptions, DefaultContentDisplayTypes, Descriptor, DescriptorOverrides,
   DisplayLabelRequestOptions, DisplayLabelsRequestOptions, DisplayValueGroup, DistinctValuesRequestOptions, ExtendedContentRequestOptions,
-  ExtendedHierarchyRequestOptions, getLocalesDirectory, HierarchyRequestOptions, InstanceKey, KeySet, LabelDefinition, LabelRequestOptions, Node,
-  NodeKey, NodePathElement, Paged, PagedResponse, PartialHierarchyModification, PresentationDataCompareOptions, PresentationError, PresentationStatus,
-  PresentationUnitSystem, RequestPriority, Ruleset, SelectionInfo, SelectionScope, SelectionScopeRequestOptions,
+  ExtendedHierarchyRequestOptions, getLocalesDirectory, HierarchyCompareInfo, HierarchyRequestOptions, InstanceKey, KeySet, LabelDefinition,
+  LabelRequestOptions, Node, NodeKey, NodePathElement, Paged, PagedResponse, PartialHierarchyModification, PresentationDataCompareOptions,
+  PresentationError, PresentationStatus, PresentationUnitSystem, RequestPriority, Ruleset, SelectionInfo, SelectionScope,
+  SelectionScopeRequestOptions,
 } from "@bentley/presentation-common";
 import { PresentationBackendLoggerCategory } from "./BackendLoggerCategory";
 import { PRESENTATION_BACKEND_ASSETS_ROOT, PRESENTATION_COMMON_ASSETS_ROOT } from "./Constants";
@@ -121,7 +122,7 @@ export interface HybridCacheConfig extends HierarchyCacheConfigBase {
 export interface UnitSystemFormat {
   unitSystems: PresentationUnitSystem[];
   format: FormatProps;
-};
+}
 
 /**
  * Properties that can be used to configure [[PresentationManager]]
@@ -885,14 +886,14 @@ export class PresentationManager {
    * TODO: Return results in pages
    * @beta
    */
-  public async compareHierarchies(requestOptions: WithClientRequestContext<PresentationDataCompareOptions<IModelDb, NodeKey>>): Promise<PartialHierarchyModification[]>;
-  public async compareHierarchies(requestContextOrOptions: ClientRequestContext | WithClientRequestContext<PresentationDataCompareOptions<IModelDb, NodeKey>>, deprecatedRequestOptions?: PresentationDataCompareOptions<IModelDb, NodeKey>): Promise<PartialHierarchyModification[]> {
+  public async compareHierarchies(requestOptions: WithClientRequestContext<PresentationDataCompareOptions<IModelDb, NodeKey>>): Promise<HierarchyCompareInfo>;
+  public async compareHierarchies(requestContextOrOptions: ClientRequestContext | WithClientRequestContext<PresentationDataCompareOptions<IModelDb, NodeKey>>, deprecatedRequestOptions?: PresentationDataCompareOptions<IModelDb, NodeKey>): Promise<HierarchyCompareInfo | PartialHierarchyModification[]> {
     if (requestContextOrOptions instanceof ClientRequestContext) {
-      return this.compareHierarchies({ ...deprecatedRequestOptions!, requestContext: requestContextOrOptions });
+      return (await this.compareHierarchies({ ...deprecatedRequestOptions!, requestContext: requestContextOrOptions })).changes;
     }
 
     if (!requestContextOrOptions.prev.rulesetOrId && !requestContextOrOptions.prev.rulesetVariables)
-      return [];
+      return { changes: [] };
 
     const { strippedOptions: { prev, rulesetVariables, ...options } } = this.registerRuleset(requestContextOrOptions);
 
@@ -913,7 +914,7 @@ export class PresentationManager {
       currRulesetVariables: JSON.stringify(currRulesetVariables),
       expandedNodeKeys: JSON.stringify(options.expandedNodeKeys ?? []),
     };
-    return this.request(params, (key: string, value: any) => ((key === "") ? value.map(PartialHierarchyModification.fromJSON) : value));
+    return this.request(params, (key: string, value: any) => ((key === "") ? HierarchyCompareInfo.fromJSON(value) : value));
   }
 }
 

presentation/backend/src/presentation-backend/PresentationRpcImpl.ts

@@ -12,12 +12,12 @@ import { IModelRpcProps } from "@bentley/imodeljs-common";
 import {
   ContentDescriptorRpcRequestOptions, ContentJSON, ContentRpcRequestOptions, Descriptor, DescriptorJSON, DescriptorOverrides, DiagnosticsOptions,
   DiagnosticsScopeLogs, DisplayLabelRpcRequestOptions, DisplayLabelsRpcRequestOptions, DisplayValueGroup, DisplayValueGroupJSON,
-  DistinctValuesRpcRequestOptions, ExtendedContentRpcRequestOptions, ExtendedHierarchyRpcRequestOptions, HierarchyRpcRequestOptions, InstanceKey,
-  InstanceKeyJSON, isContentDescriptorRequestOptions, isDisplayLabelRequestOptions, isExtendedContentRequestOptions,
-  isExtendedHierarchyRequestOptions, ItemJSON, KeySet, KeySetJSON, LabelDefinition, LabelDefinitionJSON, LabelRpcRequestOptions, Node, NodeJSON,
-  NodeKey, NodeKeyJSON, NodePathElement, NodePathElementJSON, Paged, PagedResponse, PageOptions, PartialHierarchyModification,
-  PartialHierarchyModificationJSON, PresentationDataCompareRpcOptions, PresentationError, PresentationRpcInterface, PresentationRpcResponse,
-  PresentationStatus, Ruleset, SelectionInfo, SelectionScope, SelectionScopeRpcRequestOptions,
+  DistinctValuesRpcRequestOptions, ExtendedContentRpcRequestOptions, ExtendedHierarchyRpcRequestOptions, HierarchyCompareInfo,
+  HierarchyCompareInfoJSON, HierarchyRpcRequestOptions, InstanceKey, InstanceKeyJSON, isContentDescriptorRequestOptions, isDisplayLabelRequestOptions,
+  isExtendedContentRequestOptions, isExtendedHierarchyRequestOptions, ItemJSON, KeySet, KeySetJSON, LabelDefinition, LabelDefinitionJSON,
+  LabelRpcRequestOptions, Node, NodeJSON, NodeKey, NodeKeyJSON, NodePathElement, NodePathElementJSON, Paged, PagedResponse, PageOptions,
+  PartialHierarchyModification, PartialHierarchyModificationJSON, PresentationDataCompareRpcOptions, PresentationError, PresentationRpcInterface,
+  PresentationRpcResponse, PresentationStatus, Ruleset, SelectionInfo, SelectionScope, SelectionScopeRpcRequestOptions,
 } from "@bentley/presentation-common";
 import { PresentationBackendLoggerCategory } from "./BackendLoggerCategory";
 import { Presentation } from "./Presentation";
@@ -364,18 +364,35 @@ export class PresentationRpcImpl extends PresentationRpcInterface {
         ...(options.expandedNodeKeys ? { expandedNodeKeys: options.expandedNodeKeys.map(NodeKey.fromJSON) } : undefined),
       };
       const result = await this.getManager(requestOptions.clientId).compareHierarchies(options);
-      return result.map(PartialHierarchyModification.toJSON);
+      return result.changes.map(PartialHierarchyModification.toJSON);
+    });
+  }
+
+  public async compareHierarchiesPaged(token: IModelRpcProps, requestOptions: PresentationDataCompareRpcOptions): PresentationRpcResponse<HierarchyCompareInfoJSON> {
+    return this.makeRequest(token, "compareHierarchies", requestOptions, async (options) => {
+      options = {
+        ...options,
+        ...(options.expandedNodeKeys ? { expandedNodeKeys: options.expandedNodeKeys.map(NodeKey.fromJSON) } : undefined),
+        resultSetSize: getValidPageSize(requestOptions.resultSetSize),
+      };
+      const result = await this.getManager(requestOptions.clientId).compareHierarchies(options);
+      return HierarchyCompareInfo.toJSON(result);
     });
   }
 }
 
 const enforceValidPageSize = <TOptions extends Paged<object>>(requestOptions: TOptions): TOptions & { paging: PageOptions } => {
-  const requestedPageSize = requestOptions.paging?.size ?? 0;
-  if (requestedPageSize === 0 || requestedPageSize > MAX_ALLOWED_PAGE_SIZE)
-    return { ...requestOptions, paging: { ...requestOptions.paging, size: MAX_ALLOWED_PAGE_SIZE } };
+  const validPageSize = getValidPageSize(requestOptions.paging?.size);
+  if (!requestOptions.paging || requestOptions.paging.size !== validPageSize)
+    return { ...requestOptions, paging: { ...requestOptions.paging, size: validPageSize } };
   return requestOptions as (TOptions & { paging: PageOptions });
 };
 
+const getValidPageSize = (size: number | undefined) => {
+  const requestedSize = size ?? 0;
+  return (requestedSize === 0 || requestedSize > MAX_ALLOWED_PAGE_SIZE) ? MAX_ALLOWED_PAGE_SIZE : requestedSize;
+};
+
 const nodeKeyFromJson = (json: NodeKeyJSON | undefined): NodeKey | undefined => {
   if (!json)
     return undefined;