Added changes for attribute metadata in Query and Pagination for the search API

legend-engine-application-query/src/main/java/org/finos/legend/engine/application/query/api/ApplicationQuery.java

@@ -22,6 +22,7 @@
 import io.swagger.annotations.ApiParam;
 import org.eclipse.collections.api.list.MutableList;
 import org.finos.legend.engine.application.query.model.DataCubeQuery;
+import org.finos.legend.engine.application.query.model.PaginatedQuerySearchSpecification;
 import org.finos.legend.engine.application.query.model.Query;
 import org.finos.legend.engine.application.query.model.QueryEvent;
 import org.finos.legend.engine.application.query.model.QuerySearchSpecification;
@@ -58,11 +59,32 @@ private static String getCurrentUser(ProfileManager<CommonProfile> profileManage
         return profile != null ? profile.getId() : null;
     }
 
+    @Deprecated
     @POST
     @Path("search")
     @ApiOperation(value = "Search queries")
     @Consumes({MediaType.APPLICATION_JSON})
     public Response searchQueries(QuerySearchSpecification searchSpecification, @ApiParam(hidden = true) @Pac4JProfileManager ProfileManager<CommonProfile> profileManager)
+    {
+        try
+        {
+            return Response.ok().entity(this.queryStoreManager.searchQueries(searchSpecification, getCurrentUser(profileManager)).queries).build();
+        }
+        catch (Exception e)
+        {
+            if (e instanceof ApplicationQueryException)
+            {
+                return ((ApplicationQueryException) e).toResponse();
+            }
+            return ExceptionTool.exceptionManager(e, LoggingEventType.SEARCH_QUERIES_ERROR, null);
+        }
+    }
+
+    @POST
+    @Path("search/paginated")
+    @ApiOperation(value = "Search queries with pagination")
+    @Consumes({MediaType.APPLICATION_JSON})
+    public Response searchQueriesPaginated(PaginatedQuerySearchSpecification searchSpecification, @ApiParam(hidden = true) @Pac4JProfileManager ProfileManager<CommonProfile> profileManager)
     {
         try
         {
@@ -98,6 +120,7 @@ public Response getQueries(@QueryParam("queryIds") @ApiParam("The list of query
         }
     }
 
+
     @GET
     @Path("{queryId}")
     @ApiOperation(value = "Get the query with specified ID")

legend-engine-application-query/src/main/java/org/finos/legend/engine/application/query/api/QueryStoreManager.java

@@ -39,7 +39,9 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
@@ -51,6 +53,7 @@ public class QueryStoreManager
     private static final int MAX_NUMBER_OF_QUERIES = 100;
     private static final int MAX_NUMBER_OF_EVENTS = 1000;
     private static final int QUERY_BATCH_SIZE = 1000;
+    private static final int MAX_PAGE_SIZE = 100;
 
     private final ObjectMapper objectMapper = new ObjectMapper();
     private static final Document EMPTY_FILTER = Document.parse("{}");
@@ -207,7 +210,7 @@ else if (query.executionContext instanceof DataProductLakehouseAccessExecutionCo
         // TODO: we can potentially create a pattern check for version
     }
 
-    public List<Query> searchQueries(QuerySearchSpecification searchSpecification, String currentUser)
+    public PaginatedResult searchQueries(QuerySearchSpecification searchSpecification, String currentUser)
     {
         List<Bson> filters = new ArrayList<>();
         if (searchSpecification.searchTermSpecification != null)
@@ -303,17 +306,58 @@ public List<Query> searchQueries(QuerySearchSpecification searchSpecification, S
         {
             builder.sortDesc(getSortByField(searchSpecification.sortByOption));
         }
+        else
+        {
+            builder.sortDesc(getSortByField(QuerySearchSortBy.SORT_BY_VIEW));
+        }
         builder.withExcludeFields(EXCLUDED_PROJECTION_FIELDS);
-        if (searchSpecification.limit != null && searchSpecification.limit <= 0)
+
+        // Check if pagination is requested (spec is a PaginatedQuerySearchSpecification with pageSize specified)
+        boolean isPaginated = searchSpecification instanceof PaginatedQuerySearchSpecification
+                && ((PaginatedQuerySearchSpecification) searchSpecification).pageSize != null;
+
+        if (isPaginated)
         {
-            throw new ApplicationQueryException("Limit should be greater than 0", Response.Status.BAD_REQUEST);
+            PaginatedQuerySearchSpecification paginatedSpec = (PaginatedQuerySearchSpecification) searchSpecification;
+            int pageSize = Math.min(paginatedSpec.pageSize, MAX_PAGE_SIZE);
+            int offset = paginatedSpec.cursor != null ? paginatedSpec.cursor : 0;
+            int pageNumber = (offset / pageSize) + 1;
+
+            builder.withSkip(offset);
+            // Fetch one extra to determine if there's a next page
+            builder.withLimit(pageSize + 1);
+
+            List<Query> queries = getQueryDao().find(filters.isEmpty() ? EMPTY_FILTER : Filters.and(filters), false, builder.build())
+                    .map(this::convertFromStoredQuery)
+                    .sorted(Comparator.comparing(query -> query.owner != null && query.owner.equals(currentUser) ? 0 : 1))
+                    .collect(Collectors.toList());
+
+            boolean hasNextPage = queries.size() > pageSize;
+            if (hasNextPage)
+            {
+                queries = queries.subList(0, pageSize);
+            }
+
+            Integer cursor = hasNextPage ? offset + pageSize : null;
+
+            return new PaginatedResult(queries, hasNextPage, cursor, pageNumber);
         }
-        builder.withLimit(Math.min(MAX_NUMBER_OF_QUERIES, searchSpecification.limit == null ? Integer.MAX_VALUE : searchSpecification.limit));
+        else
+        {
+            // Non-paginated: use limit parameter (backward compatible behavior)
+            if (searchSpecification.limit != null && searchSpecification.limit <= 0)
+            {
+                throw new ApplicationQueryException("Limit should be greater than 0", Response.Status.BAD_REQUEST);
+            }
+            builder.withLimit(Math.min(MAX_NUMBER_OF_QUERIES, searchSpecification.limit == null ? Integer.MAX_VALUE : searchSpecification.limit));
 
-        return getQueryDao().find(filters.isEmpty() ? EMPTY_FILTER : Filters.and(filters), false, builder.build())
-                .map(this::convertFromStoredQuery)
-                .sorted(Comparator.comparing(query -> query.owner != null && query.owner.equals(currentUser) ? 0 : 1))
-                .collect(Collectors.toList());
+            List<Query> queries = getQueryDao().find(filters.isEmpty() ? EMPTY_FILTER : Filters.and(filters), false, builder.build())
+                    .map(this::convertFromStoredQuery)
+                    .sorted(Comparator.comparing(query -> query.owner != null && query.owner.equals(currentUser) ? 0 : 1))
+                    .collect(Collectors.toList());
+
+            return new PaginatedResult(queries, false, null, 1);
+        }
     }
 
     public String getSortByField(QuerySearchSortBy sortBy)
@@ -559,4 +603,5 @@ public QueryStoreStats getQueryStoreStats()
                 .countDocuments(dataSpaceFilter));
         return storeStats;
     }
+
 }

legend-engine-application-query/src/main/java/org/finos/legend/engine/application/query/model/ApplicationStoredQuery.java

@@ -41,6 +41,7 @@ public class ApplicationStoredQuery implements StoredVersionedAssetContent<Strin
     public List<StereotypePtr> stereotypes;
     public List<QueryParameterValue> defaultParameterValues;
     public Map<String, ?> gridConfig;
+    public List<AttributeMetadata> attributeMetadata;
     public Long lastOpenAt;
     public StoredAuditInformation audit;
 

legend-engine-application-query/src/main/java/org/finos/legend/engine/application/query/model/AttributeMetadata.java

@@ -0,0 +1,22 @@
+// Copyright 2026 Goldman Sachs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package org.finos.legend.engine.application.query.model;
+
+public class AttributeMetadata
+{
+    public String path;
+    public String alias;
+    public String description;
+}

legend-engine-application-query/src/main/java/org/finos/legend/engine/application/query/model/PaginatedQuerySearchSpecification.java

@@ -0,0 +1,22 @@
+//  Copyright 2026 Goldman Sachs
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+
+package org.finos.legend.engine.application.query.model;
+
+public class PaginatedQuerySearchSpecification extends QuerySearchSpecification
+{
+    public Integer pageSize;
+    public Integer cursor;
+}
+

legend-engine-application-query/src/main/java/org/finos/legend/engine/application/query/model/PaginatedResult.java

@@ -0,0 +1,34 @@
+//  Copyright 2026 Goldman Sachs
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+
+package org.finos.legend.engine.application.query.model;
+
+import java.util.List;
+
+public class PaginatedResult
+{
+    public List<Query> queries;
+    public boolean hasNextPage;
+    public Integer cursor;
+    public int pageNumber;
+
+    public PaginatedResult(List<Query> queries, boolean hasNextPage, Integer cursor, int pageNumber)
+    {
+        this.queries = queries;
+        this.hasNextPage = hasNextPage;
+        this.cursor = cursor;
+        this.pageNumber = pageNumber;
+    }
+
+}

legend-engine-application-query/src/main/java/org/finos/legend/engine/application/query/model/Query.java

@@ -56,4 +56,6 @@ public class Query
     public String owner;
 
     public Map<String, ?> gridConfig;
+    public List<AttributeMetadata> attributeMetadata;
+
 }

legend-engine-application-query/src/main/java/org/finos/legend/engine/application/query/model/QueryModelConverter.java

@@ -91,6 +91,7 @@ public static ApplicationStoredQuery toStoredQuery(Query query)
         stored.stereotypes = query.stereotypes;
         stored.defaultParameterValues = query.defaultParameterValues;
         stored.gridConfig = query.gridConfig;
+        stored.attributeMetadata = query.attributeMetadata;
         stored.lastOpenAt = Instant.now().toEpochMilli();
 
         // Initialize audit with info from query