feat(bulk-import-backend): include pagination info in the `GET /impor…

…ts` response structure (#2246)

* feat(bulk-import-backend)!: include pagination info in the `GET /imports` response structure

Change the response structure of 'GET /imports' in the OpenAPI definition

Regenerate type defs and API docs off openapi.yaml spec

Implement the findAllImports API accordingly

Rename the pagePerIntegration and sizePerIntegration query params into page and size

This makes it more clear, and also because the number of imports does not depend on the number of GH integrations

Fix and update tests

Reduce code duplication issues reported by SonarCloud

* Do not break the API as a general rule of thumb

Instead, this allows consumers to specify an 'api-version' field in
the request header (either undefined, `v1` or `v2`, default being `v1` as before).
When `v2` is specified, the `GET /imports` response structure is changed accordingly.

* Mark the `*PerIntegration` query params as deprecated in the OpenAPI spec

Co-authored-by: Dominika Zemanovicova <36102317+dzemanov@users.noreply.github.com>
Signed-off-by: Armel Soro <asoro@redhat.com>

* Fix parameters descriptions and API version changelog in OpenAPI spec

Signed-off-by: Armel Soro <asoro@redhat.com>

---------

Signed-off-by: Armel Soro <asoro@redhat.com>
Co-authored-by: Dominika Zemanovicova <36102317+dzemanov@users.noreply.github.com>

plugins/bulk-import-backend/scripts/openapi.sh

@@ -41,7 +41,7 @@ echo '`' >> "${OPENAPI_DOC_JS_FILE}"
 echo "export const openApiDocument = JSON.parse(OPENAPI);" >> "${OPENAPI_DOC_JS_FILE}"
 rm -f ./src/schema/openapi.json
 
-# Generate doc
-#npx --yes --package=openapicmd@2.3.2 -- openapi redoc src/schema/openapi.yaml --bundle docs
+# Re-generate doc
+rm -rf ./api-docs/
 npx --yes --package=@openapitools/openapi-generator-cli@2.13.4 -- \
   openapi-generator-cli generate -i ./src/schema/openapi.yaml -g markdown -o ./api-docs/

plugins/bulk-import-backend/src/helpers/catalogInfoGenerator.ts

@@ -125,37 +125,54 @@ ${jsYaml.dump(generatedEntity.entity)}`,
     search?: string,
     pageNumber: number = DefaultPageNumber,
     pageSize: number = DefaultPageSize,
-  ): Promise<string[]> {
-    const list = await this.listCatalogUrlLocationsById(
+  ): Promise<{ targetUrls: string[]; totalCount?: number }> {
+    const byId = await this.listCatalogUrlLocationsById(
       config,
       search,
       pageNumber,
       pageSize,
     );
     const result = new Set<string>();
-    for (const l of list) {
+    for (const l of byId.locations) {
       result.add(l.target);
     }
-    return Array.from(result.values());
+    return {
+      targetUrls: Array.from(result.values()),
+      totalCount: byId.totalCount,
+    };
   }
 
   async listCatalogUrlLocationsById(
     config: Config,
     search?: string,
     pageNumber: number = DefaultPageNumber,
     pageSize: number = DefaultPageSize,
-  ): Promise<{ id?: string; target: string }[]> {
+  ): Promise<{
+    locations: { id?: string; target: string }[];
+    totalCount?: number;
+  }> {
     const result = await Promise.all([
       this.listCatalogUrlLocationsFromConfig(config, search),
       this.listCatalogUrlLocationsByIdFromLocationsEndpoint(search),
       this.listCatalogUrlLocationEntitiesById(search, pageNumber, pageSize),
     ]);
-    return result.flat();
+    const locations = result.flatMap(u => u.locations);
+    // we might have duplicate elements here
+    const totalCount = result
+      .map(l => l.totalCount ?? 0)
+      .reduce((accumulator, currentValue) => accumulator + currentValue, 0);
+    return {
+      locations,
+      totalCount,
+    };
   }
 
   async listCatalogUrlLocationsByIdFromLocationsEndpoint(
     search?: string,
-  ): Promise<{ id?: string; target: string }[]> {
+  ): Promise<{
+    locations: { id?: string; target: string }[];
+    totalCount?: number;
+  }> {
     const url = `${await this.discovery.getBaseUrl('catalog')}/locations`;
     const response = await fetch(url, {
       headers: {
@@ -168,7 +185,7 @@ ${jsYaml.dump(generatedEntity.entity)}`,
       data: { id: string; target: string; type: string };
     }[];
     if (!Array.isArray(locations)) {
-      return [];
+      return { locations: [] };
     }
     const res = locations
       .filter(
@@ -180,13 +197,14 @@ ${jsYaml.dump(generatedEntity.entity)}`,
           target: location.data.target,
         };
       });
-    return this.filterLocations(res, search);
+    const filtered = this.filterLocations(res, search);
+    return { locations: filtered, totalCount: filtered.length };
   }
 
   listCatalogUrlLocationsFromConfig(
     config: Config,
     search?: string,
-  ): { id?: string; target: string }[] {
+  ): { locations: { id?: string; target: string }[]; totalCount?: number } {
     const locationConfigs =
       config.getOptionalConfigArray('catalog.locations') ?? [];
     const res = locationConfigs
@@ -202,23 +220,28 @@ ${jsYaml.dump(generatedEntity.entity)}`,
           target,
         };
       });
-    return this.filterLocations(res, search);
+    const filtered = this.filterLocations(res, search);
+    return { locations: filtered, totalCount: filtered.length };
   }
 
   async listCatalogUrlLocationEntitiesById(
     search?: string,
     _pageNumber: number = DefaultPageNumber,
     _pageSize: number = DefaultPageSize,
-  ): Promise<{ id?: string; target: string }[]> {
+  ): Promise<{
+    locations: { id?: string; target: string }[];
+    totalCount?: number;
+  }> {
     const result = await this.catalogApi.getEntities(
       {
         filter: {
           kind: 'Location',
         },
         // There is no query parameter to find entities with target URLs containing a string.
         // The existing filter does an exact matching. That's why we are retrieving this hard-coded high number of Locations.
-        limit: 1000,
+        limit: 9999,
         offset: 0,
+        order: { field: 'metadata.name', order: 'desc' },
       },
       {
         token: await getTokenForPlugin(this.auth, 'catalog'),
@@ -235,7 +258,8 @@ ${jsYaml.dump(generatedEntity.entity)}`,
           target: location.spec.target!,
         };
       });
-    return this.filterLocations(res, search);
+    const filtered = this.filterLocations(res, search);
+    return { locations: filtered, totalCount: filtered.length };
   }
 
   private filterLocations(