@itwin/presentation-backend 3.6.0-dev.52 → 3.6.0-dev.54

package/lib/cjs/presentation-backend/PresentationRpcImpl.js

@@ -1,366 +1,379 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module RPC
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PresentationRpcImpl = exports.MAX_ALLOWED_KEYS_PAGE_SIZE = exports.MAX_ALLOWED_PAGE_SIZE = void 0;
-const core_backend_1 = require("@itwin/core-backend");
-const core_bentley_1 = require("@itwin/core-bentley");
-const presentation_common_1 = require("@itwin/presentation-common");
-const BackendLoggerCategory_1 = require("./BackendLoggerCategory");
-const Presentation_1 = require("./Presentation");
-const TemporaryStorage_1 = require("./TemporaryStorage");
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const packageJsonVersion = require("../../../package.json").version;
-/** @internal */
-exports.MAX_ALLOWED_PAGE_SIZE = 1000;
-/** @internal */
-exports.MAX_ALLOWED_KEYS_PAGE_SIZE = 10000;
-/**
- * The backend implementation of PresentationRpcInterface. All it's basically
- * responsible for is forwarding calls to [[Presentation.manager]].
- *
- * @internal
- */
-class PresentationRpcImpl extends presentation_common_1.PresentationRpcInterface {
-    constructor(props) {
-        var _a;
-        super();
-        this._requestTimeout = (_a = props === null || props === void 0 ? void 0 : props.requestTimeout) !== null && _a !== void 0 ? _a : 90 * 1000;
-        this._pendingRequests = new TemporaryStorage_1.TemporaryStorage({
-            // remove the pending request after request timeout + 10 seconds - this gives
-            // frontend 10 seconds to re-send the request until it's removed from requests' cache
-            unusedValueLifetime: (this._requestTimeout > 0) ? (this._requestTimeout + 10 * 1000) : undefined,
-            // attempt to clean up every second
-            cleanupInterval: 1000,
-            cleanupHandler: (id, _, reason) => {
-                var _a;
-                if (reason !== "request") {
-                    core_bentley_1.Logger.logTrace(BackendLoggerCategory_1.PresentationBackendLoggerCategory.Rpc, `Cleaning up request without frontend retrieving it: ${id}.`);
-                    // istanbul ignore next
-                    (_a = this._cancelEvents.get(id)) === null || _a === void 0 ? void 0 : _a.raiseEvent();
-                }
-                this._cancelEvents.delete(id);
-            },
-        });
-        this._cancelEvents = new Map();
-    }
-    dispose() {
-        this._pendingRequests.dispose();
-    }
-    get requestTimeout() { return this._requestTimeout; }
-    get pendingRequests() { return this._pendingRequests; }
-    /** Returns an ok response with result inside */
-    successResponse(result, diagnostics) {
-        return {
-            statusCode: presentation_common_1.PresentationStatus.Success,
-            result,
-            diagnostics,
-        };
-    }
-    /** Returns a bad request response with empty result and an error code */
-    errorResponse(errorCode, errorMessage, diagnostics) {
-        return {
-            statusCode: errorCode,
-            result: undefined,
-            errorMessage,
-            diagnostics,
-        };
-    }
-    /**
-     * Get the [[PresentationManager]] used by this RPC impl.
-     */
-    getManager(clientId) {
-        return Presentation_1.Presentation.getManager(clientId);
-    }
-    getIModel(token) {
-        let imodel;
-        try {
-            imodel = core_backend_1.IModelDb.findByKey(token.key);
-        }
-        catch {
-            throw new presentation_common_1.PresentationError(presentation_common_1.PresentationStatus.InvalidArgument, "IModelRpcProps doesn't point to a valid iModel");
-        }
-        return imodel;
-    }
-    async makeRequest(token, requestId, requestOptions, request) {
-        const requestKey = JSON.stringify({ iModelKey: token.key, requestId, requestOptions });
-        core_bentley_1.Logger.logInfo(BackendLoggerCategory_1.PresentationBackendLoggerCategory.Rpc, `Received '${requestId}' request. Params: ${requestKey}`);
-        let resultPromise = this._pendingRequests.getValue(requestKey);
-        if (resultPromise) {
-            core_bentley_1.Logger.logTrace(BackendLoggerCategory_1.PresentationBackendLoggerCategory.Rpc, `Request already pending`);
-        }
-        else {
-            core_bentley_1.Logger.logTrace(BackendLoggerCategory_1.PresentationBackendLoggerCategory.Rpc, `Request not found, creating a new one`);
-            let imodel;
-            try {
-                imodel = this.getIModel(token);
-            }
-            catch (e) {
-                (0, core_bentley_1.assert)(e instanceof Error);
-                return this.errorResponse(presentation_common_1.PresentationStatus.InvalidArgument, e.message);
-            }
-            const { clientId: _, diagnostics: diagnosticsOptions, rulesetVariables, ...options } = requestOptions;
-            const managerRequestOptions = {
-                ...options,
-                imodel,
-                cancelEvent: new core_bentley_1.BeEvent(),
-            };
-            // set up ruleset variables
-            if (rulesetVariables)
-                managerRequestOptions.rulesetVariables = rulesetVariables.map(presentation_common_1.RulesetVariable.fromJSON);
-            // set up diagnostics listener
-            let diagnostics;
-            const getDiagnostics = () => {
-                if (!diagnostics)
-                    diagnostics = {};
-                return diagnostics;
-            };
-            if (diagnosticsOptions) {
-                if (diagnosticsOptions.backendVersion) {
-                    getDiagnostics().backendVersion = packageJsonVersion;
-                }
-                managerRequestOptions.diagnostics = {
-                    ...diagnosticsOptions,
-                    handler: (d) => {
-                        if (d.logs) {
-                            const target = getDiagnostics();
-                            if (target.logs)
-                                target.logs.push(...d.logs);
-                            else
-                                target.logs = [...d.logs];
-                        }
-                    },
-                };
-            }
-            // initiate request
-            resultPromise = request(managerRequestOptions)
-                .then((result) => this.successResponse(result, diagnostics))
-                .catch((e) => this.errorResponse(e.errorNumber, e.message, diagnostics));
-            // store the request promise
-            this._pendingRequests.addValue(requestKey, resultPromise);
-            this._cancelEvents.set(requestKey, managerRequestOptions.cancelEvent);
-        }
-        if (this._requestTimeout === 0) {
-            core_bentley_1.Logger.logTrace(BackendLoggerCategory_1.PresentationBackendLoggerCategory.Rpc, `Request timeout not configured, returning promise without a timeout.`);
-            resultPromise.finally(() => {
-                this._pendingRequests.deleteValue(requestKey);
-            });
-            return resultPromise;
-        }
-        let timeout;
-        const timeoutPromise = new Promise((_resolve, reject) => {
-            timeout = setTimeout(() => {
-                reject("Timed out");
-            }, this._requestTimeout);
-        });
-        /* eslint-disable @typescript-eslint/indent */
-        core_bentley_1.Logger.logTrace(BackendLoggerCategory_1.PresentationBackendLoggerCategory.Rpc, `Returning a promise with a timeout of ${this._requestTimeout}.`);
-        return Promise
-            .race([resultPromise, timeoutPromise])
-            .catch(() => {
-            core_bentley_1.Logger.logTrace(BackendLoggerCategory_1.PresentationBackendLoggerCategory.Rpc, `Request timeout, returning "BackendTimeout" status.`);
-            return this.errorResponse(presentation_common_1.PresentationStatus.BackendTimeout);
-        })
-            .then((response) => {
-            if (response.statusCode !== presentation_common_1.PresentationStatus.BackendTimeout) {
-                core_bentley_1.Logger.logTrace(BackendLoggerCategory_1.PresentationBackendLoggerCategory.Rpc, `Request completed, returning result.`);
-                this._pendingRequests.deleteValue(requestKey);
-            }
-            clearTimeout(timeout);
-            return response;
-        });
-        /* eslint-enable @typescript-eslint/indent */
-    }
-    async getNodesCount(token, requestOptions) {
-        return this.makeRequest(token, "getNodesCount", requestOptions, async (options) => {
-            options = {
-                ...options,
-                parentKey: nodeKeyFromJson(options.parentKey),
-            };
-            return this.getManager(requestOptions.clientId).getNodesCount(options);
-        });
-    }
-    async getPagedNodes(token, requestOptions) {
-        return this.makeRequest(token, "getPagedNodes", requestOptions, async (options) => {
-            options = enforceValidPageSize({
-                ...options,
-                parentKey: nodeKeyFromJson(options.parentKey),
-            });
-            const [nodes, count] = await Promise.all([
-                this.getManager(requestOptions.clientId).getDetail().getNodes(options),
-                this.getManager(requestOptions.clientId).getNodesCount(options),
-            ]);
-            return { total: count, items: nodes.map(presentation_common_1.Node.toJSON) };
-        });
-    }
-    async getNodePaths(token, requestOptions) {
-        return this.makeRequest(token, "getNodePaths", requestOptions, async (options) => {
-            const result = await this.getManager(requestOptions.clientId).getNodePaths(options);
-            return result.map(presentation_common_1.NodePathElement.toJSON);
-        });
-    }
-    async getFilteredNodePaths(token, requestOptions) {
-        return this.makeRequest(token, "getFilteredNodePaths", requestOptions, async (options) => {
-            const result = await this.getManager(requestOptions.clientId).getFilteredNodePaths(options);
-            return result.map(presentation_common_1.NodePathElement.toJSON);
-        });
-    }
-    async getContentSources(token, requestOptions) {
-        return this.makeRequest(token, "getContentSources", requestOptions, async (options) => {
-            const result = await this.getManager(requestOptions.clientId).getContentSources(options);
-            const classesMap = {};
-            const selectClasses = result.map((sci) => presentation_common_1.SelectClassInfo.toCompressedJSON(sci, classesMap));
-            return { sources: selectClasses, classesMap };
-        });
-    }
-    async getContentDescriptor(token, requestOptions) {
-        return this.makeRequest(token, "getContentDescriptor", requestOptions, async (options) => {
-            options = {
-                ...options,
-                keys: presentation_common_1.KeySet.fromJSON(options.keys),
-            };
-            if (options.transport === "unparsed-json") {
-                // Here we send a plain JSON string but we will parse it to DescriptorJSON on the frontend. This way we are
-                // bypassing unnecessary deserialization and serialization.
-                return Presentation_1.Presentation.getManager().getDetail().getContentDescriptor(options);
-            }
-            else {
-                // Support for older frontends that still expect a parsed descriptor
-                const descriptor = await Presentation_1.Presentation.getManager().getContentDescriptor(options);
-                return descriptor === null || descriptor === void 0 ? void 0 : descriptor.toJSON();
-            }
-        });
-    }
-    async getContentSetSize(token, requestOptions) {
-        return this.makeRequest(token, "getContentSetSize", requestOptions, async (options) => {
-            options = {
-                ...options,
-                keys: presentation_common_1.KeySet.fromJSON(options.keys),
-            };
-            return this.getManager(requestOptions.clientId).getContentSetSize(options);
-        });
-    }
-    async getPagedContent(token, requestOptions) {
-        return this.makeRequest(token, "getPagedContent", requestOptions, async (options) => {
-            options = enforceValidPageSize({
-                ...options,
-                keys: presentation_common_1.KeySet.fromJSON(options.keys),
-            });
-            const [size, content] = await Promise.all([
-                this.getManager(requestOptions.clientId).getContentSetSize(options),
-                this.getManager(requestOptions.clientId).getDetail().getContent(options),
-            ]);
-            if (!content)
-                return undefined;
-            return {
-                descriptor: content.descriptor.toJSON(),
-                contentSet: {
-                    total: size,
-                    items: content.contentSet.map((i) => i.toJSON()),
-                },
-            };
-        });
-    }
-    async getPagedContentSet(token, requestOptions) {
-        const content = await this.getPagedContent(token, requestOptions);
-        return this.successResponse(content.result ? content.result.contentSet : { total: 0, items: [] });
-    }
-    async getElementProperties(token, requestOptions) {
-        return this.makeRequest(token, "getElementProperties", { ...requestOptions }, async (options) => {
-            return this.getManager(requestOptions.clientId).getDetail().getElementProperties(options);
-        });
-    }
-    async getPagedDistinctValues(token, requestOptions) {
-        return this.makeRequest(token, "getPagedDistinctValues", requestOptions, async (options) => {
-            options = enforceValidPageSize({
-                ...options,
-                keys: presentation_common_1.KeySet.fromJSON(options.keys),
-            });
-            const response = await this.getManager(requestOptions.clientId).getPagedDistinctValues(options);
-            return {
-                ...response,
-                items: response.items.map(presentation_common_1.DisplayValueGroup.toJSON),
-            };
-        });
-    }
-    async getContentInstanceKeys(token, requestOptions) {
-        return this.makeRequest(token, "getContentInstanceKeys", requestOptions, async (options) => {
-            const { displayType, ...optionsNoDisplayType } = options;
-            options = enforceValidPageSize({
-                ...optionsNoDisplayType,
-                keys: presentation_common_1.KeySet.fromJSON(optionsNoDisplayType.keys),
-                descriptor: {
-                    displayType,
-                    contentFlags: presentation_common_1.ContentFlags.KeysOnly,
-                },
-            }, exports.MAX_ALLOWED_KEYS_PAGE_SIZE);
-            const [size, content] = await Promise.all([
-                this.getManager(requestOptions.clientId).getContentSetSize(options),
-                this.getManager(requestOptions.clientId).getDetail().getContent(options),
-            ]);
-            if (size === 0 || !content)
-                return { total: 0, items: new presentation_common_1.KeySet().toJSON() };
-            return {
-                total: size,
-                items: content.contentSet.reduce((keys, item) => keys.add(item.primaryKeys), new presentation_common_1.KeySet()).toJSON(),
-            };
-        });
-    }
-    async getDisplayLabelDefinition(token, requestOptions) {
-        return this.makeRequest(token, "getDisplayLabelDefinition", requestOptions, async (options) => {
-            const label = await this.getManager(requestOptions.clientId).getDetail().getDisplayLabelDefinition(options);
-            return presentation_common_1.LabelDefinition.toJSON(label);
-        });
-    }
-    async getPagedDisplayLabelDefinitions(token, requestOptions) {
-        const pageOpts = enforceValidPageSize({ paging: { start: 0, size: requestOptions.keys.length } });
-        if (pageOpts.paging.size < requestOptions.keys.length)
-            requestOptions.keys.splice(pageOpts.paging.size);
-        return this.makeRequest(token, "getPagedDisplayLabelDefinitions", requestOptions, async (options) => {
-            const labels = await this.getManager(requestOptions.clientId).getDetail().getDisplayLabelDefinitions({ ...options, keys: options.keys.map(presentation_common_1.InstanceKey.fromJSON) });
-            return {
-                total: options.keys.length,
-                items: labels.map(presentation_common_1.LabelDefinition.toJSON),
-            };
-        });
-    }
-    async getSelectionScopes(token, requestOptions) {
-        return this.makeRequest(token, "getSelectionScopes", requestOptions, async (options) => this.getManager(requestOptions.clientId).getSelectionScopes(options));
-    }
-    async computeSelection(token, requestOptions, ids, scopeId) {
-        return this.makeRequest(token, "computeSelection", requestOptions, async (options) => {
-            if (!(0, presentation_common_1.isComputeSelectionRequestOptions)(options)) {
-                options = {
-                    ...options,
-                    elementIds: ids,
-                    scope: { id: scopeId },
-                };
-            }
-            const keys = await this.getManager(requestOptions.clientId).computeSelection(options);
-            return keys.toJSON();
-        });
-    }
-}
-exports.PresentationRpcImpl = PresentationRpcImpl;
-const enforceValidPageSize = (requestOptions, maxPageSize = exports.MAX_ALLOWED_PAGE_SIZE) => {
-    var _a;
-    const validPageSize = getValidPageSize((_a = requestOptions.paging) === null || _a === void 0 ? void 0 : _a.size, maxPageSize);
-    if (!requestOptions.paging || requestOptions.paging.size !== validPageSize)
-        return { ...requestOptions, paging: { ...requestOptions.paging, size: validPageSize } };
-    return requestOptions;
-};
-const getValidPageSize = (size, maxPageSize) => {
-    const requestedSize = size !== null && size !== void 0 ? size : 0;
-    return (requestedSize === 0 || requestedSize > maxPageSize) ? maxPageSize : requestedSize;
-};
-const nodeKeyFromJson = (json) => {
-    if (!json)
-        return undefined;
-    return presentation_common_1.NodeKey.fromJSON(json);
-};
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module RPC
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresentationRpcImpl = exports.MAX_ALLOWED_KEYS_PAGE_SIZE = exports.MAX_ALLOWED_PAGE_SIZE = void 0;
+const core_backend_1 = require("@itwin/core-backend");
+const core_bentley_1 = require("@itwin/core-bentley");
+const presentation_common_1 = require("@itwin/presentation-common");
+const BackendLoggerCategory_1 = require("./BackendLoggerCategory");
+const Presentation_1 = require("./Presentation");
+const TemporaryStorage_1 = require("./TemporaryStorage");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const packageJsonVersion = require("../../../package.json").version;
+/** @internal */
+exports.MAX_ALLOWED_PAGE_SIZE = 1000;
+/** @internal */
+exports.MAX_ALLOWED_KEYS_PAGE_SIZE = 10000;
+/**
+ * The backend implementation of PresentationRpcInterface. All it's basically
+ * responsible for is forwarding calls to [[Presentation.manager]].
+ *
+ * @internal
+ */
+class PresentationRpcImpl extends presentation_common_1.PresentationRpcInterface {
+    constructor(props) {
+        var _a;
+        super();
+        this._requestTimeout = (_a = props === null || props === void 0 ? void 0 : props.requestTimeout) !== null && _a !== void 0 ? _a : 90 * 1000;
+        this._pendingRequests = new TemporaryStorage_1.TemporaryStorage({
+            // remove the pending request after request timeout + 10 seconds - this gives
+            // frontend 10 seconds to re-send the request until it's removed from requests' cache
+            unusedValueLifetime: (this._requestTimeout > 0) ? (this._requestTimeout + 10 * 1000) : undefined,
+            // attempt to clean up every second
+            cleanupInterval: 1000,
+            cleanupHandler: (id, _, reason) => {
+                var _a;
+                if (reason !== "request") {
+                    core_bentley_1.Logger.logTrace(BackendLoggerCategory_1.PresentationBackendLoggerCategory.Rpc, `Cleaning up request without frontend retrieving it: ${id}.`);
+                    // istanbul ignore next
+                    (_a = this._cancelEvents.get(id)) === null || _a === void 0 ? void 0 : _a.raiseEvent();
+                }
+                this._cancelEvents.delete(id);
+            },
+        });
+        this._cancelEvents = new Map();
+    }
+    dispose() {
+        this._pendingRequests.dispose();
+    }
+    get requestTimeout() { return this._requestTimeout; }
+    get pendingRequests() { return this._pendingRequests; }
+    /** Returns an ok response with result inside */
+    successResponse(result, diagnostics) {
+        return {
+            statusCode: presentation_common_1.PresentationStatus.Success,
+            result,
+            diagnostics,
+        };
+    }
+    /** Returns a bad request response with empty result and an error code */
+    errorResponse(errorCode, errorMessage, diagnostics) {
+        return {
+            statusCode: errorCode,
+            result: undefined,
+            errorMessage,
+            diagnostics,
+        };
+    }
+    /**
+     * Get the [[PresentationManager]] used by this RPC impl.
+     */
+    getManager(clientId) {
+        return Presentation_1.Presentation.getManager(clientId);
+    }
+    getIModel(token) {
+        let imodel;
+        try {
+            imodel = core_backend_1.IModelDb.findByKey(token.key);
+        }
+        catch {
+            throw new presentation_common_1.PresentationError(presentation_common_1.PresentationStatus.InvalidArgument, "IModelRpcProps doesn't point to a valid iModel");
+        }
+        return imodel;
+    }
+    async makeRequest(token, requestId, requestOptions, request) {
+        const requestKey = JSON.stringify({ iModelKey: token.key, requestId, requestOptions });
+        core_bentley_1.Logger.logInfo(BackendLoggerCategory_1.PresentationBackendLoggerCategory.Rpc, `Received '${requestId}' request. Params: ${requestKey}`);
+        let resultPromise = this._pendingRequests.getValue(requestKey);
+        if (resultPromise) {
+            core_bentley_1.Logger.logTrace(BackendLoggerCategory_1.PresentationBackendLoggerCategory.Rpc, `Request already pending`);
+        }
+        else {
+            core_bentley_1.Logger.logTrace(BackendLoggerCategory_1.PresentationBackendLoggerCategory.Rpc, `Request not found, creating a new one`);
+            let imodel;
+            try {
+                imodel = this.getIModel(token);
+            }
+            catch (e) {
+                (0, core_bentley_1.assert)(e instanceof Error);
+                return this.errorResponse(presentation_common_1.PresentationStatus.InvalidArgument, e.message);
+            }
+            const { clientId: _, diagnostics: diagnosticsOptions, rulesetVariables, ...options } = requestOptions;
+            const managerRequestOptions = {
+                ...options,
+                imodel,
+                cancelEvent: new core_bentley_1.BeEvent(),
+            };
+            // set up ruleset variables
+            if (rulesetVariables)
+                managerRequestOptions.rulesetVariables = rulesetVariables.map(presentation_common_1.RulesetVariable.fromJSON);
+            // set up diagnostics listener
+            let diagnostics;
+            const getDiagnostics = () => {
+                if (!diagnostics)
+                    diagnostics = {};
+                return diagnostics;
+            };
+            if (diagnosticsOptions) {
+                if (diagnosticsOptions.backendVersion) {
+                    getDiagnostics().backendVersion = packageJsonVersion;
+                }
+                managerRequestOptions.diagnostics = {
+                    ...diagnosticsOptions,
+                    handler: (d) => {
+                        if (d.logs) {
+                            const target = getDiagnostics();
+                            if (target.logs)
+                                target.logs.push(...d.logs);
+                            else
+                                target.logs = [...d.logs];
+                        }
+                    },
+                };
+            }
+            // initiate request
+            resultPromise = request(managerRequestOptions)
+                .then((result) => this.successResponse(result, diagnostics))
+                .catch((e) => this.errorResponse(e.errorNumber, e.message, diagnostics));
+            // store the request promise
+            this._pendingRequests.addValue(requestKey, resultPromise);
+            this._cancelEvents.set(requestKey, managerRequestOptions.cancelEvent);
+        }
+        if (this._requestTimeout === 0) {
+            core_bentley_1.Logger.logTrace(BackendLoggerCategory_1.PresentationBackendLoggerCategory.Rpc, `Request timeout not configured, returning promise without a timeout.`);
+            resultPromise.finally(() => {
+                this._pendingRequests.deleteValue(requestKey);
+            });
+            return resultPromise;
+        }
+        let timeout;
+        const timeoutPromise = new Promise((_resolve, reject) => {
+            timeout = setTimeout(() => {
+                reject("Timed out");
+            }, this._requestTimeout);
+        });
+        /* eslint-disable @typescript-eslint/indent */
+        core_bentley_1.Logger.logTrace(BackendLoggerCategory_1.PresentationBackendLoggerCategory.Rpc, `Returning a promise with a timeout of ${this._requestTimeout}.`);
+        return Promise
+            .race([resultPromise, timeoutPromise])
+            .catch(() => {
+            core_bentley_1.Logger.logTrace(BackendLoggerCategory_1.PresentationBackendLoggerCategory.Rpc, `Request timeout, returning "BackendTimeout" status.`);
+            return this.errorResponse(presentation_common_1.PresentationStatus.BackendTimeout);
+        })
+            .then((response) => {
+            if (response.statusCode !== presentation_common_1.PresentationStatus.BackendTimeout) {
+                core_bentley_1.Logger.logTrace(BackendLoggerCategory_1.PresentationBackendLoggerCategory.Rpc, `Request completed, returning result.`);
+                this._pendingRequests.deleteValue(requestKey);
+            }
+            clearTimeout(timeout);
+            return response;
+        });
+        /* eslint-enable @typescript-eslint/indent */
+    }
+    async getNodesCount(token, requestOptions) {
+        return this.makeRequest(token, "getNodesCount", requestOptions, async (options) => {
+            options = {
+                ...options,
+                parentKey: nodeKeyFromJson(options.parentKey),
+            };
+            return this.getManager(requestOptions.clientId).getNodesCount(options);
+        });
+    }
+    async getPagedNodes(token, requestOptions) {
+        return this.makeRequest(token, "getPagedNodes", requestOptions, async (options) => {
+            options = enforceValidPageSize({
+                ...options,
+                parentKey: nodeKeyFromJson(options.parentKey),
+            });
+            const [serializedNodesJson, count] = await Promise.all([
+                this.getManager(requestOptions.clientId).getDetail().getNodes(options),
+                this.getManager(requestOptions.clientId).getNodesCount(options),
+            ]);
+            const nodesJson = JSON.parse(serializedNodesJson);
+            return {
+                total: count,
+                items: nodesJson.nodes,
+            };
+        });
+    }
+    async getNodesDescriptor(token, requestOptions) {
+        return this.makeRequest(token, "getNodesDescriptor", requestOptions, async (options) => {
+            options = {
+                ...options,
+                parentKey: nodeKeyFromJson(options.parentKey),
+            };
+            return this.getManager().getDetail().getNodesDescriptor(options);
+        });
+    }
+    async getNodePaths(token, requestOptions) {
+        return this.makeRequest(token, "getNodePaths", requestOptions, async (options) => {
+            const result = await this.getManager(requestOptions.clientId).getNodePaths(options);
+            return result.map(presentation_common_1.NodePathElement.toJSON);
+        });
+    }
+    async getFilteredNodePaths(token, requestOptions) {
+        return this.makeRequest(token, "getFilteredNodePaths", requestOptions, async (options) => {
+            const result = await this.getManager(requestOptions.clientId).getFilteredNodePaths(options);
+            return result.map(presentation_common_1.NodePathElement.toJSON);
+        });
+    }
+    async getContentSources(token, requestOptions) {
+        return this.makeRequest(token, "getContentSources", requestOptions, async (options) => {
+            const result = await this.getManager(requestOptions.clientId).getContentSources(options);
+            const classesMap = {};
+            const selectClasses = result.map((sci) => presentation_common_1.SelectClassInfo.toCompressedJSON(sci, classesMap));
+            return { sources: selectClasses, classesMap };
+        });
+    }
+    async getContentDescriptor(token, requestOptions) {
+        return this.makeRequest(token, "getContentDescriptor", requestOptions, async (options) => {
+            options = {
+                ...options,
+                keys: presentation_common_1.KeySet.fromJSON(options.keys),
+            };
+            if (options.transport === "unparsed-json") {
+                // Here we send a plain JSON string but we will parse it to DescriptorJSON on the frontend. This way we are
+                // bypassing unnecessary deserialization and serialization.
+                return Presentation_1.Presentation.getManager().getDetail().getContentDescriptor(options);
+            }
+            else {
+                // Support for older frontends that still expect a parsed descriptor
+                const descriptor = await Presentation_1.Presentation.getManager().getContentDescriptor(options);
+                return descriptor === null || descriptor === void 0 ? void 0 : descriptor.toJSON();
+            }
+        });
+    }
+    async getContentSetSize(token, requestOptions) {
+        return this.makeRequest(token, "getContentSetSize", requestOptions, async (options) => {
+            options = {
+                ...options,
+                keys: presentation_common_1.KeySet.fromJSON(options.keys),
+            };
+            return this.getManager(requestOptions.clientId).getContentSetSize(options);
+        });
+    }
+    async getPagedContent(token, requestOptions) {
+        return this.makeRequest(token, "getPagedContent", requestOptions, async (options) => {
+            options = enforceValidPageSize({
+                ...options,
+                keys: presentation_common_1.KeySet.fromJSON(options.keys),
+            });
+            const [size, content] = await Promise.all([
+                this.getManager(requestOptions.clientId).getContentSetSize(options),
+                this.getManager(requestOptions.clientId).getDetail().getContent(options),
+            ]);
+            if (!content)
+                return undefined;
+            return {
+                descriptor: content.descriptor.toJSON(),
+                contentSet: {
+                    total: size,
+                    items: content.contentSet.map((i) => i.toJSON()),
+                },
+            };
+        });
+    }
+    async getPagedContentSet(token, requestOptions) {
+        const content = await this.getPagedContent(token, requestOptions);
+        return this.successResponse(content.result ? content.result.contentSet : { total: 0, items: [] });
+    }
+    async getElementProperties(token, requestOptions) {
+        return this.makeRequest(token, "getElementProperties", { ...requestOptions }, async (options) => {
+            return this.getManager(requestOptions.clientId).getDetail().getElementProperties(options);
+        });
+    }
+    async getPagedDistinctValues(token, requestOptions) {
+        return this.makeRequest(token, "getPagedDistinctValues", requestOptions, async (options) => {
+            options = enforceValidPageSize({
+                ...options,
+                keys: presentation_common_1.KeySet.fromJSON(options.keys),
+            });
+            const response = await this.getManager(requestOptions.clientId).getPagedDistinctValues(options);
+            return {
+                ...response,
+                items: response.items.map(presentation_common_1.DisplayValueGroup.toJSON),
+            };
+        });
+    }
+    async getContentInstanceKeys(token, requestOptions) {
+        return this.makeRequest(token, "getContentInstanceKeys", requestOptions, async (options) => {
+            const { displayType, ...optionsNoDisplayType } = options;
+            options = enforceValidPageSize({
+                ...optionsNoDisplayType,
+                keys: presentation_common_1.KeySet.fromJSON(optionsNoDisplayType.keys),
+                descriptor: {
+                    displayType,
+                    contentFlags: presentation_common_1.ContentFlags.KeysOnly,
+                },
+            }, exports.MAX_ALLOWED_KEYS_PAGE_SIZE);
+            const [size, content] = await Promise.all([
+                this.getManager(requestOptions.clientId).getContentSetSize(options),
+                this.getManager(requestOptions.clientId).getDetail().getContent(options),
+            ]);
+            if (size === 0 || !content)
+                return { total: 0, items: new presentation_common_1.KeySet().toJSON() };
+            return {
+                total: size,
+                items: content.contentSet.reduce((keys, item) => keys.add(item.primaryKeys), new presentation_common_1.KeySet()).toJSON(),
+            };
+        });
+    }
+    async getDisplayLabelDefinition(token, requestOptions) {
+        return this.makeRequest(token, "getDisplayLabelDefinition", requestOptions, async (options) => {
+            const label = await this.getManager(requestOptions.clientId).getDetail().getDisplayLabelDefinition(options);
+            return presentation_common_1.LabelDefinition.toJSON(label);
+        });
+    }
+    async getPagedDisplayLabelDefinitions(token, requestOptions) {
+        const pageOpts = enforceValidPageSize({ paging: { start: 0, size: requestOptions.keys.length } });
+        if (pageOpts.paging.size < requestOptions.keys.length)
+            requestOptions.keys.splice(pageOpts.paging.size);
+        return this.makeRequest(token, "getPagedDisplayLabelDefinitions", requestOptions, async (options) => {
+            const labels = await this.getManager(requestOptions.clientId).getDetail().getDisplayLabelDefinitions({ ...options, keys: options.keys.map(presentation_common_1.InstanceKey.fromJSON) });
+            return {
+                total: options.keys.length,
+                items: labels.map(presentation_common_1.LabelDefinition.toJSON),
+            };
+        });
+    }
+    async getSelectionScopes(token, requestOptions) {
+        return this.makeRequest(token, "getSelectionScopes", requestOptions, async (options) => this.getManager(requestOptions.clientId).getSelectionScopes(options));
+    }
+    async computeSelection(token, requestOptions, ids, scopeId) {
+        return this.makeRequest(token, "computeSelection", requestOptions, async (options) => {
+            if (!(0, presentation_common_1.isComputeSelectionRequestOptions)(options)) {
+                options = {
+                    ...options,
+                    elementIds: ids,
+                    scope: { id: scopeId },
+                };
+            }
+            const keys = await this.getManager(requestOptions.clientId).computeSelection(options);
+            return keys.toJSON();
+        });
+    }
+}
+exports.PresentationRpcImpl = PresentationRpcImpl;
+const enforceValidPageSize = (requestOptions, maxPageSize = exports.MAX_ALLOWED_PAGE_SIZE) => {
+    var _a;
+    const validPageSize = getValidPageSize((_a = requestOptions.paging) === null || _a === void 0 ? void 0 : _a.size, maxPageSize);
+    if (!requestOptions.paging || requestOptions.paging.size !== validPageSize)
+        return { ...requestOptions, paging: { ...requestOptions.paging, size: validPageSize } };
+    return requestOptions;
+};
+const getValidPageSize = (size, maxPageSize) => {
+    const requestedSize = size !== null && size !== void 0 ? size : 0;
+    return (requestedSize === 0 || requestedSize > maxPageSize) ? maxPageSize : requestedSize;
+};
+const nodeKeyFromJson = (json) => {
+    if (!json)
+        return undefined;
+    return presentation_common_1.NodeKey.fromJSON(json);
+};
 //# sourceMappingURL=PresentationRpcImpl.js.map