fix: polygon-parts-process request (#66)

Author: almog8k

src/common/interfaces.ts

@@ -7,6 +7,7 @@ import {
   type IngestionUpdateFinalizeTaskParams,
   type InputFiles,
   type LayerName,
+  PolygonPartsPayload,
   type RasterLayerMetadata,
   type TileFormatStrategy,
   type TileOutputFormat,
@@ -342,6 +343,10 @@ export type CatalogUpdateMetadata = Partial<RasterLayerMetadata>;
 
 //#endregion catalogClient
 
+//#region PolygonPartsManagerClient
+export type PolygonPartsProcessPayload = Pick<PolygonPartsPayload, 'productId' | 'productType' | 'jobType'>;
+//#endregion PolygonPartsManagerClient
+
 //#region seedingJobCreator
 
 export interface SeedJobParams {

src/httpClients/polygonPartsMangerClient.ts

@@ -1,13 +1,13 @@
 import type { IConfig } from 'config';
 import type { Logger } from '@map-colonies/js-logger';
-import type { AggregationFeature, RasterProductTypes, RoiFeatureCollection } from '@map-colonies/raster-shared';
+import type { AggregationFeature, RoiFeatureCollection } from '@map-colonies/raster-shared';
 import type { IHttpRetryConfig } from '@map-colonies/mc-utils';
 import { HttpClient } from '@map-colonies/mc-utils';
 import { inject, injectable } from 'tsyringe';
 import { POLYGON_PARTS_MANAGER_SERVICE_NAME, SERVICES } from '../common/constants';
 import { requiredAggregationFeatureSchema } from '../utils/zod/schemas/aggregation.schema';
 import { LayerMetadataAggregationError, PolygonPartsProcessingError } from '../common/errors';
-import { AggregationLayerMetadata } from '../common/interfaces';
+import { AggregationLayerMetadata, PolygonPartsProcessPayload } from '../common/interfaces';
 
 @injectable()
 export class PolygonPartsMangerClient extends HttpClient {
@@ -19,18 +19,15 @@ export class PolygonPartsMangerClient extends HttpClient {
     super(logger, baseUrl, serviceName, httpRetryConfig, disableHttpClientLogs);
   }
 
-  public async process(productName: string, productType: RasterProductTypes): Promise<void> {
+  public async process(payload: PolygonPartsProcessPayload): Promise<void> {
     try {
       const url = '/polygonParts/process';
 
-      const body = {
-        productName,
-        productType,
-      };
+      this.logger.info({ msg: 'process polygon parts', url, payload });
 
-      await this.put<void>(url, body);
+      await this.put<void>(url, payload);
     } catch (err) {
-      const processError = new PolygonPartsProcessingError(err, productName, productType);
+      const processError = new PolygonPartsProcessingError(err, payload.productId, payload.productType);
       throw processError;
     }
   }

src/job/models/ingestion/newJobHandler.ts

@@ -120,14 +120,12 @@ export class NewJobHandler
         activeSpan?.addEvent('layerNames.valid', { layerName });
 
         if (!processedParts) {
-          const { productName, productType } = job;
-          logger.info({ msg: 'processing polygon parts', productName, productType });
-
-          await this.polygonPartsMangerClient.process(productName, productType);
+          const { type, resourceId, productType } = job;
+          await this.polygonPartsMangerClient.process({ jobType: type, productId: resourceId, productType });
           finalizeTaskParams = await this.markFinalizeStepAsCompleted(job.id, task.id, finalizeTaskParams, 'processedParts');
 
           activeSpan?.addEvent('processPolygonParts.success', { ...finalizeTaskParams });
-          logger.info({ msg: 'polygon parts processed successfully', productName, productType });
+          logger.info({ msg: 'polygon parts processed successfully', productId: resourceId, productType });
         }
 
         if (!insertedToMapproxy) {

src/job/models/ingestion/swapJobHandler.ts

@@ -117,14 +117,13 @@ export class SwapJobHandler
         const { tileOutputFormat, displayPath } = job.parameters.additionalParams;
 
         if (!processedParts) {
-          const { productName, productType } = job;
-          logger.info({ msg: 'processing polygon parts', productName, productType });
+          const { type, resourceId, productType } = job;
 
-          await this.polygonPartsMangerClient.process(productName, productType);
+          await this.polygonPartsMangerClient.process({ jobType: type, productId: resourceId, productType });
           finalizeTaskParams = await this.markFinalizeStepAsCompleted(job.id, task.id, finalizeTaskParams, 'processedParts');
 
           activeSpan?.addEvent('processPolygonParts.success', { ...finalizeTaskParams });
-          logger.info({ msg: 'polygon parts processed successfully', productName, productType });
+          logger.info({ msg: 'polygon parts processed successfully', productId: resourceId, productType });
         }
 
         if (!updatedInMapproxy) {

src/job/models/ingestion/updateJobHandler.ts

@@ -106,14 +106,13 @@ export class UpdateJobHandler
           activeSpan?.addEvent('layerNameFormat.valid', { layerName: layerNameFormats.layerName });
 
           if (!processedParts) {
-            const { productName, productType } = job;
-            logger.info({ msg: 'processing polygon parts', productName, productType });
+            const { type, resourceId, productType } = job;
 
-            await this.polygonPartsMangerClient.process(productName, productType);
+            await this.polygonPartsMangerClient.process({ jobType: type, productId: resourceId, productType });
             finalizeTaskParams = await this.markFinalizeStepAsCompleted(job.id, task.id, finalizeTaskParams, 'processedParts');
 
             activeSpan?.addEvent('processPolygonParts.success', { ...finalizeTaskParams });
-            logger.info({ msg: 'polygon parts processed successfully', productName, productType });
+            logger.info({ msg: 'polygon parts processed successfully', productId: resourceId, productType });
           }
 
           if (!updatedInCatalog) {

tests/unit/httpClients/polygonPartMangerClient.spec.ts

@@ -1,10 +1,11 @@
 import jsLogger from '@map-colonies/js-logger';
 import { faker } from '@faker-js/faker';
-import { AggregationFeature, RoiFeatureCollection } from '@map-colonies/raster-shared';
+import { AggregationFeature, RasterProductTypes, RoiFeatureCollection } from '@map-colonies/raster-shared';
 import nock from 'nock';
 import { PolygonPartsMangerClient } from '../../../src/httpClients/polygonPartsMangerClient';
 import { createFakeRoiFeatureCollection } from '../mocks/exportMockData';
-import { LayerMetadataAggregationError } from '../../../src/common/errors';
+import { LayerMetadataAggregationError, PolygonPartsProcessingError } from '../../../src/common/errors';
+import { PolygonPartsProcessPayload } from '../../../src/common/interfaces';
 import { configMock, registerDefaultConfig } from '../mocks/configMock';
 import { createFakeAggregatedFeature } from './catalogClientSetup';
 
@@ -18,6 +19,44 @@ describe('polygonPartsManagerClient', () => {
     jest.resetAllMocks();
   });
 
+  describe('process', () => {
+    it('should process polygon parts successfully', async () => {
+      polygonPartsManagerClient = new PolygonPartsMangerClient(configMock, jsLogger({ enabled: false }));
+
+      const baseUrl = configMock.get<string>('servicesUrl.polygonPartsManager');
+      const payload: PolygonPartsProcessPayload = {
+        jobType: 'Ingestion_New',
+        productId: 'test_layer',
+        productType: RasterProductTypes.ORTHOPHOTO,
+      };
+      const url = '/polygonParts/process';
+      nock(baseUrl).put(url, payload).reply(200);
+
+      const action = polygonPartsManagerClient.process(payload);
+
+      await expect(action).resolves.toBeUndefined();
+      expect(nock.isDone()).toBe(true);
+    });
+
+    it('should throw PolygonPartsProcessingError when the request fails', async () => {
+      polygonPartsManagerClient = new PolygonPartsMangerClient(configMock, jsLogger({ enabled: false }));
+
+      const baseUrl = configMock.get<string>('servicesUrl.polygonPartsManager');
+      const payload: PolygonPartsProcessPayload = {
+        jobType: 'Ingestion_New',
+        productId: 'test_layer',
+        productType: RasterProductTypes.ORTHOPHOTO,
+      };
+      const url = '/polygonParts/process';
+      nock(baseUrl).put(url, payload).reply(500);
+
+      const action = polygonPartsManagerClient.process(payload);
+
+      await expect(action).rejects.toThrow(PolygonPartsProcessingError);
+      expect(nock.isDone()).toBe(true);
+    });
+  });
+
   describe('getAggregatedLayerMetadata', () => {
     it('should return aggregated part data based on polygonPartsEntityName', async () => {
       polygonPartsManagerClient = new PolygonPartsMangerClient(configMock, jsLogger({ enabled: false }));