Limitation for the use of Infinite Scrolling in Constellation

[GuiValino1984 (Guilherme Valino)]

We are carrying out a procedure for a client to improve the performance of a screen where they need to retrieve workbasket information for their operation.

Using Constellation, a landing page (TemplateList page) was structured to obtain the data from the work table.

This data was designed to be retrieved through a data page that reads a report definition to obtain the information to be displayed on the screen.

When using the feature in its standard form, we have no limitations when applying filters, sorting, or grouping on the screen. However, due to performance limitations—since the data load times were very high—we decided to implement Infinite Scrolling to enable pagination when loading the information and improve the response time.

We found that the filtering functionality stops working, as well as sorting. Since some fields do not come directly from the work table but rather from the use of indexes in the report and joins with the workbasket table, we believe there may be a limitation in using Infinite Scrolling. Using the debug tool, we verified that for fields not directly from the work table, they are identified as page objects and not as fields, as shown in the evidence below:

Any action or modification needed so that we can use infinite scrolling properly? Will we need to create a single table structure to address this point?

[GuiValino1984 (Guilherme Valino)]

Constellation UI Issue in Pega Platform 24.1.3 – Assessment, Root Cause & Recommendations (INC‑D313)

This post summarizes the findings and recommendations related to INC‑D313, a known issue affecting sorting, filtering, and infinite scrolling when using Constellation UI tables in Pega Platform 24.1.3. The goal is to help community members understand the behavior, why it happens, and what steps can mitigate the problem.

Assessment & Summary

This incident relates to a known limitation in Constellation UI when table fields are not sourced directly from the work table.
In version 24.1.3, Constellation processes sorting and filtering on the client side, which becomes problematic if:

• fields come from complex joins,
• fields are embedded properties, or
• the data structure is not flat.

As a result, users may experience incorrect or inconsistent sorting, filtering, and infinite scrolling behavior.

Detailed Analysis

Based on multiple support cases and internal documentation, the issue occurs because:

1. Constellation tables rely on client‑side logic for sorting and filtering.
2. When data is derived from complex data pages, joins, or response data transforms, the client cannot reliably determine order or filter conditions.
3. Infinite scrolling magnifies the impact, since pagination requires a consistent, stable sort from the source.

This combination leads to the behavior described in INC‑D313.

Proposed Solution & Recommended Actions

Below are the best practices to mitigate or fully resolve the issue:

1) Verify Data Page Configuration

Ensure the Data Page used as the table’s source is correctly set up to support sorting and filtering.

• Validate the Advanced Search Data Transform.
• Confirm that sorting and filter parameters are correctly mapped.
• Review the guidance on filtering and searching on complex properties.

2) Simplify the Data Structure (If Possible)

To avoid issues caused by complex joins or deeply embedded fields:

• Consolidate required fields into a single, flat table (denormalization when appropriate).
• Remove unnecessary nesting/dependencies.
• Pre‑calculate complex fields server‑side.

3) Enable Infinite Scrolling Correctly

If infinite scrolling is required:

• Ensure your REST API or Report Definition supports server‑side pagination.
• Return limit/offset (or equivalent) consistently.
• Follow Constellation recommendations for infinite scrolling with REST sources.

4) Validate Client‑Side Sorting

Test sorting first with a simplified model:

• If sorting works with a flat structure, the root cause is confirmed.
• If issues persist, raise or update a Pega Support Incident with logs and network traces.

What We Did in Our Case (Refactoring Implemented)

For the specific problem reported under INC‑D313, we performed a targeted refactoring to align the implementation with Constellation’s expected behavior:

• Flattened the data model used by the Constellation table by consolidating key attributes into a single table/source to reduce reliance on complex joins and embedded properties.
• Adjusted the Data Page and Advanced Search Data Transform so that sort and filter inputs are explicitly mapped and consistently interpreted in the client.
• Verified pagination at the source (REST/Report Definition) to support stable infinite scrolling.
• Re‑tested client‑side sorting and filtering with the simplified structure, confirming correct behavior.

This refactoring brought the feature back into alignment with the expected Constellation behavior, restoring reliable infinite scrolling, sorting, and filtering.

Root Cause

The root cause lies in a Constellation UI limitation in 24.1.3:

• Sorting and filtering are handled on the client side.
• Complex joins, embedded properties, and advanced transforms interfere with client‑side evaluation.
• Pagination/infinite scrolling expects a stable, deterministic order from the source, which complex structures often disrupt.

Conclusion

To ensure consistent behavior in Constellation tables:

• Configure Data Pages (and Advanced Search DT) to make sorting/filtering unambiguous.
• Prefer flat data structures for tabular UI use cases.
• Implement proper server‑side pagination for infinite scrolling.
• Validate with a simplified data model before layering complexity.

In our case, refactoring the data structure and configurations resolved the issue and aligned the feature with Constellation’s expected behavior. If similar problems persist in your environment, consider logging a Support Incident with detailed traces for deeper analysis.