PIN-5776 descriptor state waiting for approval changes and analysis

packages/api-gateway/src/api/catalogApiConverter.ts

@@ -5,12 +5,15 @@ import {
 } from "pagopa-interop-api-clients";
 import { Logger } from "pagopa-interop-commons";
 import {
-  assertNonDraftDescriptor,
+  assertNotValidDescriptor,
   assertRegistryAttributeExists,
 } from "../services/validators.js";
 
-export type NonDraftCatalogApiDescriptor = catalogApi.EServiceDescriptor & {
-  state: Exclude<catalogApi.EServiceDescriptorState, "DRAFT">;
+export type validCatalogApiDescriptor = catalogApi.EServiceDescriptor & {
+  state: Exclude<
+    catalogApi.EServiceDescriptorState,
+    "DRAFT" | "WAITING_FOR_APPROVAL"
+  >;
 };
 
 export function toApiGatewayCatalogEservice(
@@ -94,12 +97,12 @@ export function toApiGatewayDescriptorDocument(
   };
 }
 
-export function toApiGatewayDescriptorIfNotDraft(
+export function toApiGatewayDescriptorIfIsValid(
   descriptor: catalogApi.EServiceDescriptor,
   eserviceId: catalogApi.EService["id"],
   logger: Logger
 ): apiGatewayApi.EServiceDescriptor {
-  assertNonDraftDescriptor(descriptor, descriptor.id, eserviceId, logger);
+  assertNotValidDescriptor(descriptor, eserviceId, logger);
 
   return {
     id: descriptor.id,

packages/api-gateway/src/services/catalogService.ts

@@ -5,29 +5,30 @@ import {
   removeDuplicates,
   WithLogger,
 } from "pagopa-interop-commons";
+import {
+  toApiGatewayCatalogEservice,
+  toApiGatewayDescriptorIfIsValid,
+  toApiGatewayEserviceAttributes,
+  validCatalogApiDescriptor,
+} from "../api/catalogApiConverter.js";
+import { clientStatusCodeToError } from "../clients/catchClientError.js";
 import {
   AttributeProcessClient,
   CatalogProcessClient,
   TenantProcessClient,
 } from "../clients/clientsProvider.js";
-import { ApiGatewayAppContext } from "../utilities/context.js";
-import {
-  NonDraftCatalogApiDescriptor,
-  toApiGatewayCatalogEservice,
-  toApiGatewayDescriptorIfNotDraft,
-  toApiGatewayEserviceAttributes,
-} from "../api/catalogApiConverter.js";
 import {
   eserviceDescriptorNotFound,
   eserviceNotFound,
 } from "../models/errors.js";
-import { clientStatusCodeToError } from "../clients/catchClientError.js";
+import { ApiGatewayAppContext } from "../utilities/context.js";
+import { getAllBulkAttributes } from "./attributeService.js";
+import { getOrganization } from "./tenantService.js";
 import {
   assertAvailableDescriptorExists,
-  assertNonDraftDescriptor,
+  assertNotValidDescriptor,
+  validDescriptorStates,
 } from "./validators.js";
-import { getAllBulkAttributes } from "./attributeService.js";
-import { getOrganization } from "./tenantService.js";
 
 export function getAllEservices(
   catalogProcessClient: CatalogProcessClient,
@@ -132,7 +133,7 @@ export function catalogServiceBuilder(
 
       const descriptor = retrieveEserviceDescriptor(eservice, descriptorId);
 
-      return toApiGatewayDescriptorIfNotDraft(descriptor, eserviceId, logger);
+      return toApiGatewayDescriptorIfIsValid(descriptor, eserviceId, logger);
     },
     getEserviceDescriptors: async (
       { logger, headers }: WithLogger<ApiGatewayAppContext>,
@@ -147,16 +148,16 @@ export function catalogServiceBuilder(
       );
 
       const descriptors = eservice.descriptors
-        .filter(isNonDraft)
-        .map((d) => toApiGatewayDescriptorIfNotDraft(d, eserviceId, logger));
+        .filter(isValidDescriptorState)
+        .map((d) => toApiGatewayDescriptorIfIsValid(d, eserviceId, logger));
 
       return { descriptors };
     },
   };
 }
 
-const isNonDraft = (d: catalogApi.EServiceDescriptor): boolean =>
-  d.state !== catalogApi.EServiceDescriptorState.Values.DRAFT;
+const isValidDescriptorState = (d: catalogApi.EServiceDescriptor): boolean =>
+  validDescriptorStates.includes(d.state);
 
 function retrieveEserviceDescriptor(
   eservice: catalogApi.EService,
@@ -171,34 +172,25 @@ function retrieveEserviceDescriptor(
   return descriptor;
 }
 
-function getLatestNonDraftDescriptor(
+function getLatestValidDescriptor(
   eservice: catalogApi.EService,
   logger: Logger
-): NonDraftCatalogApiDescriptor {
-  const latestNonDraftDescriptor = eservice.descriptors
-    .filter(isNonDraft)
+): validCatalogApiDescriptor {
+  const latestValidDescriptor = eservice.descriptors
+    .filter(isValidDescriptorState)
     .sort((a, b) => Number(a.version) - Number(b.version))
     .at(-1);
 
-  assertAvailableDescriptorExists(
-    latestNonDraftDescriptor,
-    eservice.id,
-    logger
-  );
-  assertNonDraftDescriptor(
-    latestNonDraftDescriptor,
-    latestNonDraftDescriptor.id,
-    eservice.id,
-    logger
-  );
+  assertAvailableDescriptorExists(latestValidDescriptor, eservice.id, logger);
+  assertNotValidDescriptor(latestValidDescriptor, eservice.id, logger);
 
-  return latestNonDraftDescriptor;
+  return latestValidDescriptor;
 }
 
 async function getDescriptorAttributes(
   attributeProcessClient: AttributeProcessClient,
   headers: ApiGatewayAppContext["headers"],
-  descriptor: NonDraftCatalogApiDescriptor
+  descriptor: validCatalogApiDescriptor
 ): Promise<apiGatewayApi.EServiceAttributes> {
   const allDescriptorAttributesIds = removeDuplicates(
     [
@@ -227,14 +219,11 @@ export async function enhanceEservice(
   eservice: catalogApi.EService,
   logger: Logger
 ): Promise<apiGatewayApi.EService> {
-  const latestNonDraftDescriptor = getLatestNonDraftDescriptor(
-    eservice,
-    logger
-  );
+  const latestValidDescriptor = getLatestValidDescriptor(eservice, logger);
   const descriptorAttributes = await getDescriptorAttributes(
     attributeProcessClient,
     headers,
-    latestNonDraftDescriptor
+    latestValidDescriptor
   );
 
   const producerOrganization = await getOrganization(
@@ -249,10 +238,10 @@ export async function enhanceEservice(
     name: eservice.name,
     description: eservice.description,
     technology: eservice.technology,
-    version: latestNonDraftDescriptor.version,
+    version: latestValidDescriptor.version,
     attributes: descriptorAttributes,
-    state: latestNonDraftDescriptor.state,
-    serverUrls: latestNonDraftDescriptor.serverUrls,
+    state: latestValidDescriptor.state,
+    serverUrls: latestValidDescriptor.serverUrls,
     producer: producerOrganization,
     isSignalHubEnabled: eservice.isSignalHubEnabled,
   };

packages/api-gateway/src/services/validators.ts

@@ -6,19 +6,31 @@ import {
   delegationApi,
   purposeApi,
 } from "pagopa-interop-api-clients";
-import { operationForbidden, TenantId } from "pagopa-interop-models";
 import { Logger } from "pagopa-interop-commons";
+import { operationForbidden, TenantId } from "pagopa-interop-models";
+import { validCatalogApiDescriptor } from "../api/catalogApiConverter.js";
 import {
   activeAgreementByEserviceAndConsumerNotFound,
   attributeNotFoundInRegistry,
   invalidAgreementState,
   missingActivePurposeVersion,
   missingAvailableDescriptor,
+  multipleActiveProducerDelegationsForEservice,
   multipleAgreementForEserviceAndConsumer,
   unexpectedDescriptorState,
-  multipleActiveProducerDelegationsForEservice,
 } from "../models/errors.js";
-import { NonDraftCatalogApiDescriptor } from "../api/catalogApiConverter.js";
+
+export const invalidDescriptorStates: catalogApi.EServiceDescriptorState[] = [
+  catalogApi.EServiceDescriptorState.Values.DRAFT,
+  catalogApi.EServiceDescriptorState.Values.WAITING_FOR_APPROVAL,
+];
+
+export const validDescriptorStates: catalogApi.EServiceDescriptorState[] = [
+  catalogApi.EServiceDescriptorState.Values.ARCHIVED,
+  catalogApi.EServiceDescriptorState.Values.DEPRECATED,
+  catalogApi.EServiceDescriptorState.Values.PUBLISHED,
+  catalogApi.EServiceDescriptorState.Values.SUSPENDED,
+];
 
 export function assertAgreementStateNotDraft(
   agreementState: agreementApi.AgreementState,
@@ -71,17 +83,16 @@ export function assertAvailableDescriptorExists(
   }
 }
 
-export function assertNonDraftDescriptor(
+export function assertNotValidDescriptor(
   descriptor: catalogApi.EServiceDescriptor,
-  descriptorId: catalogApi.EServiceDescriptor["id"],
   eserviceId: catalogApi.EService["id"],
   logger: Logger
-): asserts descriptor is NonDraftCatalogApiDescriptor {
-  if (descriptor.state === catalogApi.EServiceDescriptorState.Values.DRAFT) {
+): asserts descriptor is validCatalogApiDescriptor {
+  if (invalidDescriptorStates.includes(descriptor.state)) {
     throw unexpectedDescriptorState(
       descriptor.state,
       eserviceId,
-      descriptorId,
+      descriptor.id,
       logger
     );
   }

packages/backend-for-frontend/src/api/catalogApiConverter.ts

@@ -15,19 +15,18 @@ import {
 import { attributeNotExists } from "../model/errors.js";
 import {
   getLatestActiveDescriptor,
-  getNotDraftDescriptor,
   getLatestTenantContactEmail,
+  getValidDescriptor,
 } from "../model/modelMappingUtils.js";
+import { ConfigurationRiskAnalysis } from "../model/types.js";
 import {
-  isRequesterEserviceProducer,
+  hasCertifiedAttributes,
   isAgreementSubscribed,
   isAgreementUpgradable,
-  hasCertifiedAttributes,
+  isInvalidDescriptor,
+  isRequesterEserviceProducer,
+  isValidDescriptor,
 } from "../services/validators.js";
-import {
-  ConfigurationRiskAnalysis,
-  catalogApiDescriptorState,
-} from "../model/types.js";
 import { toBffCompactAgreement } from "./agreementApiConverter.js";
 
 export function toEserviceCatalogProcessQueryParams(
@@ -105,7 +104,7 @@ export function toBffCatalogDescriptorEService(
     },
     description: eservice.description,
     technology: eservice.technology,
-    descriptors: getNotDraftDescriptor(eservice).map(toCompactDescriptor),
+    descriptors: getValidDescriptor(eservice).map(toCompactDescriptor),
     agreement: agreement && toBffCompactAgreement(agreement, eservice),
     isMine: isRequesterEserviceProducer(requesterTenant.id, eservice),
     hasCertifiedAttributes: hasCertifiedAttributes(descriptor, requesterTenant),
@@ -240,14 +239,10 @@ export function toBffCatalogApiProducerDescriptorEService(
   const producerMail = getLatestTenantContactEmail(producer);
 
   const notDraftDecriptors = eservice.descriptors
-    .filter((d) => d.state !== catalogApiDescriptorState.DRAFT)
+    .filter(isValidDescriptor)
     .map(toCompactDescriptor);
 
-  const draftDescriptor = eservice.descriptors.find(
-    (d) =>
-      d.state === catalogApiDescriptorState.DRAFT ||
-      d.state === catalogApiDescriptorState.WAITING_FOR_APPROVAL
-  );
+  const draftDescriptor = eservice.descriptors.find(isInvalidDescriptor);
 
   return {
     id: eservice.id,
@@ -378,6 +373,8 @@ export function toCompactProducerDescriptor(
     version: descriptor.version,
     requireCorrections:
       isRequesterProducerDelegate &&
+      // The WAITING_FOR_APPROVAL state is not relevant for the producer descriptor's requireCorrections field,
+      // so we don't consider it when determining whether corrections are required.
       descriptor.state === catalogApi.EServiceDescriptorState.Values.DRAFT &&
       descriptor.rejectionReasons &&
       descriptor.rejectionReasons.length > 0,

packages/backend-for-frontend/src/model/modelMappingUtils.ts

@@ -17,6 +17,11 @@ const activeDescriptorStatesFilter: catalogApi.EServiceDescriptorState[] = [
   catalogApiDescriptorState.DEPRECATED,
 ];
 
+const invalidDescriptorState: catalogApi.EServiceDescriptorState[] = [
+  catalogApiDescriptorState.DRAFT,
+  catalogApiDescriptorState.WAITING_FOR_APPROVAL,
+];
+
 export function getLatestActiveDescriptor(
   eservice: catalogApi.EService
 ): catalogApi.EServiceDescriptor | undefined {
@@ -26,11 +31,11 @@ export function getLatestActiveDescriptor(
     .at(-1);
 }
 
-export function getNotDraftDescriptor(
+export function getValidDescriptor(
   eservice: catalogApi.EService
 ): catalogApi.EServiceDescriptor[] {
   return eservice.descriptors.filter(
-    (d) => d.state !== catalogApiDescriptorState.DRAFT
+    (d) => !invalidDescriptorState.includes(d.state)
   );
 }
 

packages/backend-for-frontend/src/services/catalogService.ts

@@ -52,16 +52,14 @@ import {
   toBffCatalogApiEserviceRiskAnalysisSeed,
   toCompactProducerDescriptor,
 } from "../api/catalogApiConverter.js";
-import {
-  catalogApiDescriptorState,
-  ConfigurationEservice,
-} from "../model/types.js";
+import { ConfigurationEservice } from "../model/types.js";
 import { getAllAgreements, getLatestAgreement } from "./agreementService.js";
 import { getAllBulkAttributes } from "./attributeService.js";
 import {
   assertNotDelegatedEservice,
   assertRequesterIsProducer,
   assertRequesterCanActAsProducer,
+  isInvalidDescriptor,
 } from "./validators.js";
 
 export type CatalogService = ReturnType<typeof catalogServiceBuilder>;
@@ -117,11 +115,7 @@ const enhanceProducerEService = (
   requesterId: TenantId
 ): bffApi.ProducerEService => {
   const activeDescriptor = getLatestActiveDescriptor(eservice);
-  const draftDescriptor = eservice.descriptors.find(
-    (d) =>
-      d.state === catalogApiDescriptorState.DRAFT ||
-      d.state === catalogApiDescriptorState.WAITING_FOR_APPROVAL
-  );
+  const draftDescriptor = eservice.descriptors.find(isInvalidDescriptor);
 
   const isRequesterDelegateProducer = requesterId !== eservice.producerId;
 

packages/backend-for-frontend/src/services/validators.ts

@@ -29,6 +29,30 @@ import {
 import { BffAppContext } from "../utilities/context.js";
 import { getAllDelegations } from "./delegationService.js";
 
+export const invalidDescriptorStates: catalogApi.EServiceDescriptorState[] = [
+  catalogApi.EServiceDescriptorState.Values.DRAFT,
+  catalogApi.EServiceDescriptorState.Values.WAITING_FOR_APPROVAL,
+];
+
+export const validDescriptorStates: catalogApi.EServiceDescriptorState[] = [
+  catalogApi.EServiceDescriptorState.Values.PUBLISHED,
+  catalogApi.EServiceDescriptorState.Values.DEPRECATED,
+  catalogApi.EServiceDescriptorState.Values.SUSPENDED,
+  catalogApi.EServiceDescriptorState.Values.ARCHIVED,
+];
+
+export function isValidDescriptor(
+  descriptor: catalogApi.EServiceDescriptor
+): boolean {
+  return validDescriptorStates.includes(descriptor.state);
+}
+
+export function isInvalidDescriptor(
+  descriptor: catalogApi.EServiceDescriptor
+): boolean {
+  return invalidDescriptorStates.includes(descriptor.state);
+}
+
 export function isRequesterEserviceProducer(
   requesterId: string,
   eservice: catalogApi.EService
@@ -145,7 +169,7 @@ export function hasCertifiedAttributes(
 export function verifyExportEligibility(
   descriptor: catalogApi.EServiceDescriptor
 ): void {
-  if (descriptor.state === catalogApiDescriptorState.DRAFT) {
+  if (isValidDescriptor(descriptor)) {
     throw notValidDescriptor(descriptor.id, descriptor.state);
   }
 }