@wavemaker-ai/app-ng-runtime 1.0.0-rc.647469

package/variables/esm2022/util/variable/pagination.utils.mjs

@@ -0,0 +1,402 @@
+import { jmespath } from '@metrichor/jmespath';
+import { find, isEmpty, result, set, startsWith } from "lodash-es";
+export class PaginationUtils {
+    /**
+     * Modifies the query values with the pagination info which is retrieved from the previous API response.
+     * @param variable withholds variable information
+     * @param operationInfo has metadata of the variable
+     * @param paginationInfo has metadata of the variable pagination data
+     * @returns {void} This method does not return anything
+     */
+    static setPaginationQueryParams(variable, operationInfo, paginationInfo) {
+        operationInfo.parameters.forEach(element => {
+            // pagination input information varies based on the type
+            let inputParam;
+            if (paginationInfo.type === 'offset' || paginationInfo.input.offset) {
+                inputParam = 'offset';
+            }
+            else {
+                inputParam = 'page';
+            }
+            // modifies query values based on the pagination of variable
+            // compare parameter name with the input parameter's starting naming key (ex: channelcontext in channelcontext.pagination)
+            if (element.name === paginationInfo.input[inputParam].split('.')[0]) {
+                element.sampleValue = variable.pagination['page'];
+            }
+            else if (element.name === paginationInfo.input.size.split('.')[0]) {
+                element.sampleValue = variable.pagination['size'];
+            }
+        });
+    }
+    /**
+     * Sets pagination on the variable based on the response of the triggered api call.
+     * @param variable withholds variable information
+     * @param response has data of the api call's response
+     * @param options has info of the api's query params
+     * @returns {void} This method does not return anything
+     */
+    static setVariablePagination(variable, response, options) {
+        if (!variable.pagination) {
+            variable.pagination = {
+                empty: false
+            };
+        }
+        variable.pagination['size'] = response.size;
+        variable.pagination['page'] = response.page || 0;
+        variable.pagination['totalElements'] = response.totalElements;
+        variable.pagination['numberOfElements'] = variable.pagination['size'];
+        variable.pagination['number'] = options['page'] ? options['page'] - 1 : 0;
+        /**
+         * Deduce totalPages from totalElements by size.
+         * If the total elements are evenly split among the pages, assign the same to totalPages
+         * Else assign totalPages + 1
+         */
+        variable.pagination['totalPages'] = variable.pagination['totalElements'] / variable.pagination['size'];
+        if (variable.pagination['totalElements'] % variable.pagination['size'] === 0) {
+            variable.pagination['totalPages'] = parseInt(variable.pagination['totalPages']);
+        }
+        else {
+            variable.pagination['totalPages'] = parseInt(variable.pagination['totalPages']) + 1;
+        }
+        // If pagination type is cursor, fill next & prev
+        if (response.next) {
+            variable.pagination['next'] = response.next;
+            variable.pagination['prev'] = response.prev;
+            variable.pagination['last'] = response.next ? false : true;
+            variable.pagination['first'] = response.prev ? false : true;
+        }
+        else {
+            variable.pagination['first'] = variable.pagination['page'] <= 1 ? true : false;
+            // calculate last based on current page index against total pages
+            variable.pagination['last'] = response.hasMoreItems === '' ? !(variable.pagination['page'] < variable.pagination['totalPages']) : !response.hasMoreItems;
+        }
+    }
+    /**
+     * Resolves the expression given in pagination metadata's output
+     * @param item has value of each key which is inside output pagination metadata
+     * @param response has data of the api call's response
+     * @param resHeaders has data of the api call's response headers
+     * @param res holds the information of pagination which has to be stored on the variable
+     * @param key has key name against which data has to be stored in pagination
+     * @returns {void} This method does not return anything
+     */
+    static setPaginationItems(item, response, res, key, resHeaders) {
+        // if the item has body, resolve the expression against the response
+        if (startsWith(item, '$body')) {
+            const bodyKey = item.replace('$body.', '');
+            try {
+                res[key] = jmespath.search(response, bodyKey);
+            }
+            catch {
+                console.warn(`${item} expression needs to be corrected as per JMES guidelines`);
+            }
+        }
+        else if (startsWith(item, '$header')) { // if the item has header, resolve the expression against the response headers
+            const headerKey = item.replace('$header.', '');
+            const headers = Object.fromEntries(resHeaders.headers);
+            const headerParams = headerKey.split('.');
+            try {
+                res[key] = jmespath.search(headers, headerParams[0].toLowerCase());
+            }
+            catch {
+                console.warn(`${item} expression needs to be corrected as per JMES guidelines`);
+            }
+            if (res[key]?.length) {
+                let headerVal = res[key].join();
+                if (headerParams.length === 1) {
+                    /**
+                     * If the headerParams has only 1 key (which is not an object) name assing headerVal to the res[key]
+                     */
+                    res[key] = headerVal;
+                }
+                else {
+                    /**
+                     * If the headerParams has more than 1 key (an object), parse the stringified headerVal which is an object
+                     * Resolve the expression against headerVal object amd assign it to res[key]
+                     */
+                    let keyName = headerParams.slice(1).join('.');
+                    const headerResp = JSON.parse(headerVal);
+                    const specialChar = /[!@#$%^&*()+\=\[\]{};':"\\|,<>\/?]+/;
+                    if (specialChar.test(keyName)) {
+                        // If key name has expression (ex: comparission expression)
+                        // add root key name to keyName for JMES to resolve the expression
+                        keyName = 'headerResp.' + keyName;
+                    }
+                    try {
+                        res[key] = jmespath.search(headerResp, keyName);
+                    }
+                    catch {
+                        console.warn(`${item} expression needs to be corrected as per JMES guidelines`);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Return the pagination information of the service based on its existence on swagger or on the variable
+     * @param variable withholds variable information
+     * @param operationInfo has metadata of the variable
+     * @returns {object} This method return pagination metadata
+     */
+    static getPaginationInfo(operationInfo, variable) {
+        if (operationInfo?.paginationInfo) {
+            return operationInfo.paginationInfo;
+        }
+        else {
+            return variable._paginationConfig;
+        }
+    }
+    /**
+     * Set query params with the pagination info, if pagination metadata is present in query params
+     * @param variable withholds variable information
+     * @param operationInfo has metadata of the variable
+     * @param options has info of the api's query params
+     * @returns {void} This method does not return anything
+     */
+    static checkPaginationAtQuery(operationInfo, variable, options) {
+        const paginationInfo = this.getPaginationInfo(operationInfo, variable);
+        // If page is not first, pagination is present on the variable and paginationInfo's input meta has size set pagination in query params
+        const hasPagination = options && options['page'] && paginationInfo?.input.size && variable.pagination;
+        if (!hasPagination) {
+            return;
+        }
+        let inputParam;
+        // if pagination type is offset, asssign inputParam to offset else page
+        if (paginationInfo.type === 'offset' || paginationInfo.input.offset) {
+            inputParam = 'offset';
+        }
+        else {
+            inputParam = 'page';
+        }
+        const paramName = paginationInfo.input[inputParam].split('.')[0];
+        const paramObj = find(operationInfo.parameters, function (obj) {
+            return obj.name === paramName;
+        });
+        // check if the variable has query params and they are not empty
+        if (!isEmpty(variable.dataBinding) && paramObj && paramObj.parameterType === 'query') {
+            /**
+             * For pagination type other than offset, assign page which is recieved from options
+             * For offset type, calculate page from size and options[page]
+             */
+            if (!paginationInfo.output?.page && paginationInfo.type !== 'offset') {
+                variable.pagination['page'] = options['page'];
+            }
+            else {
+                variable.pagination['page'] = this.getOffsetInfo(variable, options);
+            }
+            this.setPaginationQueryParams(variable, operationInfo, paginationInfo);
+        }
+    }
+    /**
+     * Deduces the offset information from the size and page params
+     * @param variable withholds variable information
+     * @param options has info of the api's query params
+     * @returns {object} Returns the next offset number
+     */
+    static getOffsetInfo(variable, options) {
+        return variable.pagination['size'] * (options['page'] ? (options['page'] - 1) : 1);
+    }
+    /**
+     * Sets Pagination data on the request information
+     * @param variable withholds variable information
+     * @param operationInfo has metadata of the variable
+     * @param options has info of the api's query params
+     * @param paginationInfo has pagination information of the variable
+     * @param headers has request headers
+     * @param requestBody has request body
+     * @param url has request url
+     * @returns {object} Returns the request object which has pagination info
+     */
+    static setPaginationAtReq(paginationInfo, operationInfo, variable, headers, requestBody, url, options) {
+        let reqObj = {};
+        let inputParam;
+        let resObj = {};
+        // pagination input information varies based on the type
+        if (paginationInfo.type === 'offset' || paginationInfo.input.offset) {
+            inputParam = 'offset';
+        }
+        else {
+            inputParam = 'page';
+        }
+        const paramName = paginationInfo.input[inputParam].split('.')[0];
+        // check if paramName is present in parameters of operation info
+        const paramObj = find(operationInfo.parameters, function (obj) {
+            return obj.name === paramName;
+        });
+        // set page/offset and size from pagination if matched parameter's type is header
+        if (paramObj?.parameterType === 'header') {
+            set(reqObj, paginationInfo.input[inputParam], variable.pagination['page']);
+            set(reqObj, paginationInfo.input.size, variable.pagination['size']);
+            headers[paramName] = JSON.stringify(reqObj[paramName]);
+            resObj['headers'] = headers;
+        }
+        else if (paramObj?.parameterType === 'body') {
+            // set page/offset and size from pagination if matched parameter's type is body
+            // assign bodyVal to updated pagination info object
+            const bodyVal = JSON.parse(paramObj.sampleValue);
+            const bodyParam = paginationInfo.input[inputParam].split('.')[1];
+            if (bodyVal && bodyVal[bodyParam]) {
+                const inputBodyParam = paginationInfo.input[inputParam].split('.').splice(1).join('.');
+                if (inputParam !== 'offset') {
+                    set(reqObj, inputBodyParam, variable.pagination['page']);
+                }
+                else {
+                    set(reqObj, inputBodyParam, this.getOffsetInfo(variable, options));
+                }
+                set(reqObj, paginationInfo.input.size.split('.').splice(1).join('.'), variable.pagination['size']);
+                bodyVal[bodyParam] = reqObj[bodyParam];
+                requestBody = JSON.stringify(bodyVal);
+                resObj['requestBody'] = requestBody;
+            }
+        }
+        else if (variable.pagination.next && paramObj) {
+            /**
+             * For cursor type pagination, if pagination info is present in the path
+             * Based on whether user clicks on the next or prev button modify the url
+             */
+            if (paramObj.parameterType === 'path') {
+                const urlParams = operationInfo.relativePath.split('/'), paramConfig = '{' + paramObj.name + '}', paramIndex = urlParams.indexOf(paramConfig);
+                let invokeUrl;
+                if (variable.pagination.isNext) {
+                    invokeUrl = variable.pagination.next.split('/');
+                }
+                else {
+                    invokeUrl = variable.pagination.prev.split('/');
+                }
+                let urlPathParmas;
+                let urlPath;
+                if (operationInfo.directPath) { // For direct path, as url has hostname, derivate pathname using URL object
+                    urlPath = new URL(url);
+                    urlPathParmas = urlPath.pathname.split('/');
+                    urlPathParmas[paramIndex] = invokeUrl[paramIndex];
+                    urlPath.pathname = urlPathParmas.join('/');
+                    url = urlPath.href;
+                    resObj['url'] = url;
+                }
+                else { // Else modify the url with index as +1 (following proxy pattern)
+                    urlPathParmas = url.split('/');
+                    urlPathParmas[paramIndex + 1] = invokeUrl[paramIndex];
+                    url = urlPathParmas.join('/');
+                    resObj['url'] = url;
+                }
+            }
+            else if (paramObj.parameterType === 'query') {
+                /**
+                 * For cursor type pagination, if pagination info is present in the query
+                 * Based on whether user clicks on the next or prev button modify the url's query params
+                 */
+                const urlParams = url.split('?');
+                let invokeUrl;
+                if (variable.pagination.isNext) {
+                    invokeUrl = variable.pagination.next.split('?');
+                }
+                else {
+                    invokeUrl = variable.pagination.prev.split('?');
+                }
+                urlParams[1] = invokeUrl[1];
+                url = urlParams.join('?');
+                resObj['url'] = url;
+            }
+        }
+        return resObj;
+    }
+    /**
+     * Sets the pagination info recieved from api's response in the res object
+     * @param operationInfo has metadata of the variable
+     * @param res holds the information of pagination which has to be stored on the variable
+     * @param paramName has key name against which data has to be stored in pagination
+     * @param variable withholds variable information
+     * @returns {void} This method does not return anything
+     */
+    static setParameterVal(paramName, res, operationInfo, variable) {
+        const paginationInfo = this.getPaginationInfo(operationInfo, variable);
+        const param = paginationInfo.input[paramName].split('.')[0];
+        const sizeObj = find(operationInfo.parameters, function (obj) {
+            return obj.name === param;
+        });
+        res[paramName] = result(sizeObj, 'sampleValue');
+    }
+    /**
+     * Creates res object from the response recieved from the api triggered
+     * @param variable withholds variable information
+     * @param operationInfo has metadata of the variable
+     * @param paginationInfo has metadata of the variable's pagination
+     * @param response has data of the api call's response
+     * @param options has info of the api's query params
+     * @param resHeaders has data of the api call's response headers
+     * @returns {object} An object which holds the information of pagination which has to be stored on the variable
+     */
+    static generatePaginationRes(operationInfo, paginationInfo, response, resHeaders, options, variable) {
+        let res = {};
+        const resOutput = paginationInfo.output;
+        // If pagination type is not cursor, create the following metadata
+        if (!resOutput?.next) {
+            /**
+             * If size is present in the pagination's output metadata deduce size from api's response
+             * Else deduce size from the pagination's input metadata size key
+             */
+            if (resOutput?.size) {
+                this.setPaginationItems(resOutput.size, response, res, 'size', resHeaders);
+            }
+            else {
+                this.setParameterVal('size', res, operationInfo, variable);
+            }
+            /**
+             * If page is present in the pagination's output metadata deduce page from api's response
+             * Else deduce page from the pagination's input metadata page key
+             */
+            if (resOutput?.page) {
+                this.setPaginationItems(resOutput.page, response, res, 'page', resHeaders);
+            }
+            else if (paginationInfo.type !== 'offset') {
+                this.setParameterVal('page', res, operationInfo, variable);
+            }
+            /**
+             * If totalElements has $minValue in it, set totalElements as $minValue
+             * If the rendered elements are greater than $minValue, set totalElements as Number of elements rendered + 1
+
+             * If totalElements is present in the pagination's output metadata deduce totalElements from api's response
+
+             * If Pagination type is offset, deduce totalElements from size and options[page] else deduce from size and res[page]
+                */
+            if (startsWith(resOutput?.totalElements, '$minValue')) {
+                const totalEl = resOutput.totalElements.replace('$minValue=', '');
+                const pageParam = res['page'] ? res['page'] : options['page'];
+                const elRendered = res['size'] * pageParam;
+                if (!variable.pagination || variable.pagination['totalElements'] > elRendered) {
+                    res['totalElements'] = parseInt(totalEl);
+                }
+                else {
+                    res['totalElements'] = elRendered + 1;
+                }
+            }
+            else if (resOutput?.totalElements) {
+                this.setPaginationItems(resOutput.totalElements, response, res, 'totalElements', resHeaders);
+            }
+            else {
+                if (paginationInfo.type === 'offset' || paginationInfo.input.offset) {
+                    res['totalElements'] = (res['size'] * (options['page'] ? options['page'] : 1)) + 1;
+                }
+                else {
+                    res['totalElements'] = (res['size'] * res['page']) + 1;
+                }
+            }
+            /**
+             * If hasMoreItems is present in the pagination's output metadata deduce hasMoreItems from api's response
+             * Else assign it as empty which will be calculated at pagination object generation
+             */
+            if (resOutput?.hasMoreItems) {
+                this.setPaginationItems(resOutput.hasMoreItems, response, res, 'hasMoreItems', resHeaders);
+            }
+            else {
+                res['hasMoreItems'] = '';
+            }
+        }
+        else if (resOutput) { // For cursor type pagination set next and prev keys in res object
+            this.setPaginationItems(resOutput.next, response, res, 'next', resHeaders);
+            this.setPaginationItems(resOutput.prev, response, res, 'prev', resHeaders);
+        }
+        return res;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagination.utils.js","sourceRoot":"","sources":["../../../../../projects/variables/src/util/variable/pagination.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { jmespath } from '@metrichor/jmespath';\nimport {find, isEmpty, result, set, startsWith} from \"lodash-es\";\n\nexport class PaginationUtils {\n    /**\n     * Modifies the query values with the pagination info which is retrieved from the previous API response.\n     * @param variable withholds variable information\n     * @param operationInfo has metadata of the variable\n     * @param paginationInfo has metadata of the variable pagination data\n     * @returns {void} This method does not return anything\n     */\n    static setPaginationQueryParams(variable, operationInfo, paginationInfo) {\n        operationInfo.parameters.forEach(element => {\n            // pagination input information varies based on the type\n            let inputParam;\n            if (paginationInfo.type === 'offset' || paginationInfo.input.offset) {\n                inputParam = 'offset';\n            } else {\n                inputParam = 'page';\n            }\n            // modifies query values based on the pagination of variable\n            // compare parameter name with the input parameter's starting naming key (ex: channelcontext in channelcontext.pagination)\n            if (element.name === paginationInfo.input[inputParam].split('.')[0]) {\n                element.sampleValue = variable.pagination['page'];\n            } else if (element.name === paginationInfo.input.size.split('.')[0]) {\n                element.sampleValue = variable.pagination['size'];\n            }\n        });\n    }\n\n    /**\n     * Sets pagination on the variable based on the response of the triggered api call.\n     * @param variable withholds variable information\n     * @param response has data of the api call's response\n     * @param options has info of the api's query params\n     * @returns {void} This method does not return anything\n     */\n    static setVariablePagination(variable, response, options) {\n        if (!variable.pagination) {\n            variable.pagination = {\n                empty: false\n            };\n        }\n        variable.pagination['size'] = response.size;\n        variable.pagination['page'] =  response.page || 0;\n        variable.pagination['totalElements'] = response.totalElements;\n        variable.pagination['numberOfElements'] = variable.pagination['size'];\n        variable.pagination['number'] =  options['page'] ? options['page'] - 1 : 0;\n\n        /**\n         * Deduce totalPages from totalElements by size.\n         * If the total elements are evenly split among the pages, assign the same to totalPages\n         * Else assign totalPages + 1\n         */\n        variable.pagination['totalPages'] =  variable.pagination['totalElements'] / variable.pagination['size'];\n        if (variable.pagination['totalElements'] % variable.pagination['size'] === 0) {\n            variable.pagination['totalPages'] = parseInt(variable.pagination['totalPages']);\n        } else {\n            variable.pagination['totalPages'] = parseInt(variable.pagination['totalPages']) + 1;\n        }\n\n        // If pagination type is cursor, fill next & prev\n        if (response.next) {\n            variable.pagination['next'] = response.next;\n            variable.pagination['prev'] = response.prev;\n            variable.pagination['last'] = response.next ? false : true;\n            variable.pagination['first'] = response.prev ? false : true;\n        } else {\n            variable.pagination['first'] = variable.pagination['page'] <= 1 ? true : false;\n            // calculate last based on current page index against total pages\n            variable.pagination['last'] = response.hasMoreItems === '' ? !(variable.pagination['page'] < variable.pagination['totalPages']) : !response.hasMoreItems;\n        }\n    }\n\n    /**\n     * Resolves the expression given in pagination metadata's output\n     * @param item has value of each key which is inside output pagination metadata\n     * @param response has data of the api call's response\n     * @param resHeaders has data of the api call's response headers\n     * @param res holds the information of pagination which has to be stored on the variable\n     * @param key has key name against which data has to be stored in pagination\n     * @returns {void} This method does not return anything\n     */\n    static setPaginationItems(item, response, res, key, resHeaders) {\n        // if the item has body, resolve the expression against the response\n        if (startsWith(item, '$body')) {\n            const bodyKey = item.replace('$body.', '');\n            try {\n                res[key] = jmespath.search(response, bodyKey);\n            } catch {\n                console.warn(`${item} expression needs to be corrected as per JMES guidelines`);\n            }\n        } else if (startsWith(item, '$header')) { // if the item has header, resolve the expression against the response headers\n            const headerKey = item.replace('$header.', '');\n            const headers =  (<any>Object).fromEntries(resHeaders.headers);\n            const headerParams = headerKey.split('.');\n            try {\n                res[key] = jmespath.search(headers, headerParams[0].toLowerCase());\n            } catch {\n                console.warn(`${item} expression needs to be corrected as per JMES guidelines`);\n            }\n            if (res[key]?.length) {\n                let headerVal = res[key].join();\n                if (headerParams.length === 1) {\n                    /**\n                     * If the headerParams has only 1 key (which is not an object) name assing headerVal to the res[key]\n                     */\n                    res[key] = headerVal;\n                } else {\n                    /**\n                     * If the headerParams has more than 1 key (an object), parse the stringified headerVal which is an object\n                     * Resolve the expression against headerVal object amd assign it to res[key]\n                     */\n                    let keyName = headerParams.slice(1).join('.');\n                    const headerResp = JSON.parse(headerVal);\n                    const specialChar = /[!@#$%^&*()+\\=\\[\\]{};':\"\\\\|,<>\\/?]+/;\n                    if (specialChar.test(keyName)) {\n                        // If key name has expression (ex: comparission expression)\n                        // add root key name to keyName for JMES to resolve the expression\n                        keyName = 'headerResp.' + keyName;\n                    }\n                    try {\n                        res[key] = jmespath.search(headerResp, keyName);\n                    } catch {\n                        console.warn(`${item} expression needs to be corrected as per JMES guidelines`);\n                    }\n                }\n            }\n        }\n    }\n\n    /**\n     * Return the pagination information of the service based on its existence on swagger or on the variable\n     * @param variable withholds variable information\n     * @param operationInfo has metadata of the variable\n     * @returns {object} This method return pagination metadata\n     */\n    static getPaginationInfo(operationInfo, variable) {\n        if (operationInfo?.paginationInfo) {\n            return operationInfo.paginationInfo;\n        } else {\n            return variable._paginationConfig;\n        }\n    }\n\n    /**\n     * Set query params with the pagination info, if pagination metadata is present in query params\n     * @param variable withholds variable information\n     * @param operationInfo has metadata of the variable\n     * @param options has info of the api's query params\n     * @returns {void} This method does not return anything\n     */\n    static checkPaginationAtQuery(operationInfo, variable, options) {\n        const paginationInfo = this.getPaginationInfo(operationInfo, variable);\n        // If page is not first, pagination is present on the variable and paginationInfo's input meta has size set pagination in query params\n        const hasPagination = options && options['page'] && paginationInfo?.input.size && variable.pagination;\n        if (!hasPagination) {\n            return;\n        }\n\n        let inputParam;\n        // if pagination type is offset, asssign inputParam to offset else page\n        if (paginationInfo.type === 'offset' || paginationInfo.input.offset) {\n            inputParam = 'offset';\n        } else {\n            inputParam = 'page';\n        }\n        const paramName = paginationInfo.input[inputParam].split('.')[0];\n        const paramObj = find(operationInfo.parameters, function (obj) {\n            return obj.name === paramName\n        });\n        // check if the variable has query params and they are not empty\n        if (!isEmpty(variable.dataBinding) && paramObj && paramObj.parameterType === 'query') {\n            /**\n             * For pagination type other than offset, assign page which is recieved from options\n             * For offset type, calculate page from size and options[page]\n             */\n            if (!paginationInfo.output?.page && paginationInfo.type !== 'offset') {\n                variable.pagination['page'] = options['page'];\n            } else {\n                variable.pagination['page'] = this.getOffsetInfo(variable, options);\n            }\n            this.setPaginationQueryParams(variable, operationInfo, paginationInfo);\n        }\n    }\n\n    /**\n     * Deduces the offset information from the size and page params\n     * @param variable withholds variable information\n     * @param options has info of the api's query params\n     * @returns {object} Returns the next offset number\n     */\n    static getOffsetInfo(variable, options) {\n        return variable.pagination['size'] * (options['page'] ? (options['page'] - 1) : 1);\n    }\n\n    /**\n     * Sets Pagination data on the request information\n     * @param variable withholds variable information\n     * @param operationInfo has metadata of the variable\n     * @param options has info of the api's query params\n     * @param paginationInfo has pagination information of the variable\n     * @param headers has request headers\n     * @param requestBody has request body\n     * @param url has request url\n     * @returns {object} Returns the request object which has pagination info\n     */\n    static setPaginationAtReq(paginationInfo, operationInfo, variable, headers, requestBody, url, options) {\n        let reqObj = {};\n        let inputParam;\n        let resObj = {};\n        // pagination input information varies based on the type\n        if (paginationInfo.type === 'offset' || paginationInfo.input.offset) {\n            inputParam = 'offset';\n        } else {\n            inputParam = 'page';\n        }\n        const paramName = paginationInfo.input[inputParam].split('.')[0];\n        // check if paramName is present in parameters of operation info\n        const paramObj = find(operationInfo.parameters, function (obj) {\n            return obj.name === paramName\n        });\n        // set page/offset and size from pagination if matched parameter's type is header\n        if (paramObj?.parameterType === 'header') {\n            set(reqObj, paginationInfo.input[inputParam], variable.pagination['page']);\n            set(reqObj, paginationInfo.input.size, variable.pagination['size']);\n            headers[paramName] = JSON.stringify(reqObj[paramName]);\n            resObj['headers'] = headers;\n        } else if (paramObj?.parameterType === 'body') {\n            // set page/offset and size from pagination if matched parameter's type is body\n            // assign bodyVal to updated pagination info object\n            const bodyVal = JSON.parse(paramObj.sampleValue);\n            const bodyParam = paginationInfo.input[inputParam].split('.')[1]\n            if (bodyVal && bodyVal[bodyParam]) {\n                const inputBodyParam = paginationInfo.input[inputParam].split('.').splice(1).join('.');\n                if (inputParam !== 'offset') {\n                    set(reqObj, inputBodyParam, variable.pagination['page']);\n                } else {\n                    set(reqObj, inputBodyParam, this.getOffsetInfo(variable, options));\n                }\n                set(reqObj, paginationInfo.input.size.split('.').splice(1).join('.'), variable.pagination['size']);\n                bodyVal[bodyParam] =  reqObj[bodyParam];\n                requestBody = JSON.stringify(bodyVal);\n                resObj['requestBody'] = requestBody;\n            }\n        } else if (variable.pagination.next && paramObj) {\n            /**\n             * For cursor type pagination, if pagination info is present in the path\n             * Based on whether user clicks on the next or prev button modify the url\n             */\n\n            if (paramObj.parameterType === 'path') {\n                const urlParams = operationInfo.relativePath.split('/'),\n                paramConfig = '{' + paramObj.name + '}',\n                paramIndex = urlParams.indexOf(paramConfig);\n                let invokeUrl;\n                if (variable.pagination.isNext) {\n                    invokeUrl = variable.pagination.next.split('/');\n                } else {\n                    invokeUrl = variable.pagination.prev.split('/');\n                }\n\n                let urlPathParmas;\n                let urlPath;\n                if (operationInfo.directPath) { // For direct path, as url has hostname, derivate pathname using URL object\n                    urlPath = new URL(url);\n                    urlPathParmas = urlPath.pathname.split('/');\n                    urlPathParmas[paramIndex] = invokeUrl[paramIndex];\n                    urlPath.pathname = urlPathParmas.join('/');\n                    url = urlPath.href;\n                    resObj['url'] = url;\n                } else { // Else modify the url with index as +1 (following proxy pattern)\n                    urlPathParmas = url.split('/');\n                    urlPathParmas[paramIndex + 1] = invokeUrl[paramIndex];\n                    url = urlPathParmas.join('/');\n                    resObj['url'] = url;\n                }\n\n            } else if (paramObj.parameterType === 'query') {\n            /**\n             * For cursor type pagination, if pagination info is present in the query\n             * Based on whether user clicks on the next or prev button modify the url's query params\n             */\n                const urlParams = url.split('?');\n                let invokeUrl;\n                if (variable.pagination.isNext) {\n                    invokeUrl = variable.pagination.next.split('?');\n                } else {\n                    invokeUrl = variable.pagination.prev.split('?');\n                }\n                urlParams[1] = invokeUrl[1];\n                url = urlParams.join('?');\n                resObj['url'] = url;\n            }\n        }\n        return resObj;\n    }\n\n    /**\n     * Sets the pagination info recieved from api's response in the res object\n     * @param operationInfo has metadata of the variable\n     * @param res holds the information of pagination which has to be stored on the variable\n     * @param paramName has key name against which data has to be stored in pagination\n     * @param variable withholds variable information\n     * @returns {void} This method does not return anything\n     */\n    static setParameterVal(paramName, res, operationInfo, variable) {\n        const paginationInfo = this.getPaginationInfo(operationInfo, variable);\n        const param = paginationInfo.input[paramName].split('.')[0];\n        const sizeObj = find(operationInfo.parameters, function (obj) {\n            return obj.name === param\n        });\n        res[paramName] = result(sizeObj, 'sampleValue');\n    }\n\n    /**\n     * Creates res object from the response recieved from the api triggered\n     * @param variable withholds variable information\n     * @param operationInfo has metadata of the variable\n     * @param paginationInfo has metadata of the variable's pagination\n     * @param response has data of the api call's response\n     * @param options has info of the api's query params\n     * @param resHeaders has data of the api call's response headers\n     * @returns {object} An object which holds the information of pagination which has to be stored on the variable\n     */\n    static generatePaginationRes(operationInfo, paginationInfo, response, resHeaders, options, variable) {\n        let res = {};\n        const resOutput = paginationInfo.output;\n        // If pagination type is not cursor, create the following metadata\n        if (!resOutput?.next) {\n            /**\n             * If size is present in the pagination's output metadata deduce size from api's response\n             * Else deduce size from the pagination's input metadata size key\n             */\n            if (resOutput?.size) {\n                this.setPaginationItems(resOutput.size, response, res, 'size', resHeaders);\n            } else {\n                this.setParameterVal('size', res, operationInfo, variable);\n            }\n            /**\n             * If page is present in the pagination's output metadata deduce page from api's response\n             * Else deduce page from the pagination's input metadata page key\n             */\n            if (resOutput?.page) {\n                this.setPaginationItems(resOutput.page, response, res, 'page', resHeaders);\n            } else if (paginationInfo.type !== 'offset') {\n                this.setParameterVal('page', res, operationInfo, variable);\n            }\n            /**\n             * If totalElements has $minValue in it, set totalElements as $minValue\n             * If the rendered elements are greater than $minValue, set totalElements as Number of elements rendered + 1\n\n             * If totalElements is present in the pagination's output metadata deduce totalElements from api's response\n\n             * If Pagination type is offset, deduce totalElements from size and options[page] else deduce from size and res[page]\n                */\n            if (startsWith(resOutput?.totalElements, '$minValue')) {\n                const totalEl = resOutput.totalElements.replace('$minValue=', '');\n                const pageParam = res['page'] ? res['page'] : options['page']\n                const elRendered = res['size'] * pageParam;\n                if (!variable.pagination || variable.pagination['totalElements'] > elRendered) {\n                    res['totalElements'] = parseInt(totalEl);\n                } else {\n                    res['totalElements'] = elRendered + 1;\n                }\n            } else if (resOutput?.totalElements) {\n                this.setPaginationItems(resOutput.totalElements, response, res, 'totalElements', resHeaders);\n            } else {\n                if (paginationInfo.type === 'offset' || paginationInfo.input.offset) {\n                    res['totalElements'] = (res['size'] * (options['page'] ? options['page'] : 1)) + 1;\n                } else {\n                    res['totalElements'] = (res['size'] * res['page']) + 1;\n                }\n            }\n            /**\n             * If hasMoreItems is present in the pagination's output metadata deduce hasMoreItems from api's response\n             * Else assign it as empty which will be calculated at pagination object generation\n             */\n            if (resOutput?.hasMoreItems) {\n                this.setPaginationItems(resOutput.hasMoreItems, response, res, 'hasMoreItems', resHeaders);\n            } else {\n                res['hasMoreItems'] = '';\n            }\n        } else if (resOutput) { // For cursor type pagination set next and prev keys in res object\n            this.setPaginationItems(resOutput.next, response, res, 'next', resHeaders);\n            this.setPaginationItems(resOutput.prev, response, res, 'prev', resHeaders);\n        }\n        return res;\n    }\n}\n"]}