Querying Liferay Data Efficiently

Liferay's headless APIs offer powerful data retrieval capabilities for resources like web content, blog posts, users, and custom objects. To optimize data retrieval, bandwidth usage, and user experience (UX), Liferay employs service parameters within both GET methods and GraphQL queries. These parameters are essential for crafting efficient and scalable data retrieval strategies, crucial for applications like Clarity's dashboards.

This article explores how to tailor queries for efficient, scalable data retrieval.

Understanding Service Parameter Importance

Liferay's headless APIs include a range of service parameters that empower consumers to retrieve only needed data. Consider the following benefits from effectively leveraging service parameters:

Enhanced User Experiences: Parameters like pageSize, fields, and filter empower data delivery that aligns perfectly with UI requirements, improving UX.
Improved System Efficiency: Sorting, filtering, and flattening data at the API level reduces processing loads on consuming applications or other APIs.
Resource Optimization: Focused payloads save bandwidth and reduce costs, which is especially important for mobile devices or high-volume integrations.
Interoperability: Pre-processing responses lowers integration complexities and reduces resources needed for systems consuming Liferay's APIs.

Service parameters provide avenues to optimize performance and enhance interoperability, ensuring your team’s integration processes are efficient and scalable.

Modifying GET Requests with Service Parameters

To effectively leverage REST service parameters in GET requests, it’s important to understand the available parameters and potential impact each one can provide.

Parameter	Purpose	Impact
`page` and `pageSize`	Specifies page numbers and number of items per page	Prevents excessive data transfer and improves performance; critical for managing data size and aligning with UX requirements
`sort`	Sorts results at the database level	Minimizes processing load on consuming systems by reducing client-side sorting
`search`	Refines datasets by sending requests to the database or search engine to return only matching keyword results	Returns only relevant results, improving UX and eliminating additional filtering needed by consumers
`filter`	Refines datasets by returning all entries before filtering results through precise conditions	Returns only relevant results, improving UX and eliminating additional filtering needed by consumers
`fields` and `restrictedFields`	Specifies included or excluded response fields	Reduces payload size, minimizes bandwidth usage, and simplifies client-side processing by retrieving only relevant data
`flatten`	Flattens hierarchical structures in responses	Simplifies data retrieval across nested fields or relationships, reducing development effort by simplifying navigation of nested data structures
`aggregationTerm`	Specifies data as facet criteria in a single facets block, aggregating custom, default, or relationship fields	Simplifies client implementations and creates better UX

See API Query Parameters for usage examples and more information.

NOTE
Though both search and filter refine datasets to only return desired entries, search can provide improved system performance and is generally recommended.

Leveraging GraphQL for Data Retrieval

Liferay also supports GraphQL for retrieving data, providing flexibility and efficiency in querying specific datasets. While many parameters are similar to REST counterparts (e.g., page, pageSize, filter, search, aggregation, sort), some REST-specific parameters like fields, restrictedFields, and nestedFields are not applicable. Instead, you define retrieved fields directly in the query syntax, reducing payload sizes to exactly what data is needed.

For example, this query retrieves Clarity’s ticket information, sorted by priority and includes only the specified fields for open tickets:

query{
    c {
        tickets(
        filter: "ticketStatus eq 'Open'",
        page: 1,
        pageSize: 10,
        search: "",
        sort: "priority:desc",
        ) {
        items {
                subject
            ticketStatus {
            key
            }
        }
        }
    }
}

Conclusion

Service parameters provide powerful modifiers for retrieving data with Liferay’s Headless APIs. By leveraging these parameters effectively, you can ensure API requests are efficient and user-friendly, contributing to robust and scalable integrations.

Next, you’ll practice executing efficient requests with REST and GraphQL endpoints.