@pagopa/interop-outbound-models 1.8.20 → 1.8.21

package/src/tenant/eventsV2.ts

@@ -19,6 +19,11 @@ import {
   TenantDelegatedProducerFeatureRemovedV2,
   TenantDelegatedConsumerFeatureAddedV2,
   TenantDelegatedConsumerFeatureRemovedV2,
+  TenantCertifiedDiscreteAttributeAssignedV2,
+  TenantCertifiedDiscreteAttributeRevokedV2,
+  TenantCertifiedDiscreteAttributeUpdatedV2,
+  TenantRemoteIdAssignedV2,
+  MaintenanceTenantRemoteIdDeletedV2,
 } from "../gen/v2/tenant/events.js";
 import { protobufDecoder } from "../utils.js";
 
@@ -78,6 +83,21 @@ export function tenantEventToBinaryDataV2(event: TenantEventV2): Uint8Array {
     .with({ type: "TenantDelegatedConsumerFeatureRemoved" }, ({ data }) =>
       TenantDelegatedConsumerFeatureRemovedV2.toBinary(data)
     )
+    .with({ type: "TenantCertifiedDiscreteAttributeAssigned" }, ({ data }) =>
+      TenantCertifiedDiscreteAttributeAssignedV2.toBinary(data)
+    )
+    .with({ type: "TenantCertifiedDiscreteAttributeRevoked" }, ({ data }) =>
+      TenantCertifiedDiscreteAttributeRevokedV2.toBinary(data)
+    )
+    .with({ type: "TenantCertifiedDiscreteAttributeUpdated" }, ({ data }) =>
+      TenantCertifiedDiscreteAttributeUpdatedV2.toBinary(data)
+    )
+    .with({ type: "TenantRemoteIdAssigned" }, ({ data }) =>
+      TenantRemoteIdAssignedV2.toBinary(data)
+    )
+    .with({ type: "MaintenanceTenantRemoteIdDeleted" }, ({ data }) =>
+      MaintenanceTenantRemoteIdDeletedV2.toBinary(data)
+    )
     .exhaustive();
 }
 
@@ -226,6 +246,46 @@ export const TenantEventV2 = z.discriminatedUnion("type", [
     version: z.number(),
     timestamp: z.coerce.date(),
   }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("TenantCertifiedDiscreteAttributeAssigned"),
+    data: protobufDecoder(TenantCertifiedDiscreteAttributeAssignedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("TenantCertifiedDiscreteAttributeRevoked"),
+    data: protobufDecoder(TenantCertifiedDiscreteAttributeRevokedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("TenantCertifiedDiscreteAttributeUpdated"),
+    data: protobufDecoder(TenantCertifiedDiscreteAttributeUpdatedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("TenantRemoteIdAssigned"),
+    data: protobufDecoder(TenantRemoteIdAssignedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("MaintenanceTenantRemoteIdDeleted"),
+    data: protobufDecoder(MaintenanceTenantRemoteIdDeletedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
 ]);
 
 export type TenantEventV2 = z.infer<typeof TenantEventV2>;

package/tests/agreement.test.ts

@@ -24,5 +24,34 @@ describe("agreement", () => {
     expect(decoded).toEqual(event);
   });
 
-  // TODO: Add more tests for other event types
+  it("should correctly encode and decode AgreementAdded V2 event with certified discrete attributes", () => {
+    const event: AgreementEvent = {
+      event_version: 2,
+      type: "AgreementAdded",
+      data: {
+        agreement: {
+          id: "agreement-id",
+          eserviceId: "eservice-id",
+          descriptorId: "descriptor-id",
+          producerId: "producer-id",
+          consumerId: "consumer-id",
+          state: 1,
+          verifiedAttributes: [],
+          certifiedAttributes: [{ id: "certified-id" }],
+          declaredAttributes: [],
+          consumerDocuments: [],
+          createdAt: 1n,
+          certifiedDiscreteAttributes: [{ id: "certified-discrete-id" }],
+        },
+      },
+      stream_id: "agreement-stream",
+      timestamp: new Date(),
+      version: 1,
+    };
+
+    const encoded = encodeOutboundAgreementEvent(event);
+    const decoded = decodeOutboundAgreementEvent(encoded);
+
+    expect(decoded).toEqual(event);
+  });
 });

package/tests/eservice.test.ts

@@ -8,6 +8,7 @@ import {
   EServiceTechnologyV2,
   EServiceDescriptorStateV2,
   AgreementApprovalPolicyV2,
+  AttributeCertifiedDiscreteComparatorV2,
 } from "../src/index.js";
 
 describe("eservice", () => {
@@ -46,6 +47,11 @@ describe("eservice", () => {
                         id: "test",
                         explicitAttributeVerification: true,
                         dailyCallsPerConsumer: 10,
+                        discreteConfig: {
+                          threshold: 50,
+                          comparator:
+                            AttributeCertifiedDiscreteComparatorV2.GTE,
+                        },
                       },
                     ],
                   },

package/tests/template.test.ts

@@ -8,6 +8,7 @@ import {
   EServiceModeV2,
   EServiceTechnologyV2,
   AgreementApprovalPolicyV2,
+  AttributeCertifiedDiscreteComparatorV2,
 } from "../src/index.js";
 
 describe("eservice-template", () => {
@@ -43,6 +44,11 @@ describe("eservice-template", () => {
                       {
                         id: "attr-id",
                         explicitAttributeVerification: false,
+                        discreteConfig: {
+                          threshold: 75,
+                          comparator:
+                            AttributeCertifiedDiscreteComparatorV2.LTE,
+                        },
                       },
                     ],
                   },

package/tests/tenant.test.ts

@@ -3,6 +3,7 @@ import {
   encodeOutboundTenantEvent,
   decodeOutboundTenantEvent,
   TenantEvent,
+  TenantKindV2,
 } from "../src/index.js";
 
 describe("tenant", () => {
@@ -24,5 +25,52 @@ describe("tenant", () => {
     expect(decoded).toEqual(event);
   });
 
-  // TODO: Add more tests for other event types
+  it("should correctly encode and decode TenantOnboarded event with remote ids and certified discrete attributes", () => {
+    const event: TenantEvent = {
+      event_version: 2,
+      type: "TenantOnboarded",
+      data: {
+        tenant: {
+          id: "tenant-id",
+          selfcareId: "selfcare-id",
+          externalId: {
+            origin: "IPA",
+            value: "tenant-code",
+          },
+          features: [],
+          attributes: [
+            {
+              sealedValue: {
+                oneofKind: "certifiedDiscreteAttribute",
+                certifiedDiscreteAttribute: {
+                  id: "attribute-id",
+                  assignmentTimestamp: 1n,
+                  discreteValue: 42,
+                },
+              },
+            },
+          ],
+          createdAt: 1n,
+          name: "Tenant name",
+          kind: TenantKindV2.PA,
+          onboardedAt: 1n,
+          remoteIds: [
+            {
+              origin: "ANAC",
+              value: "remote-code",
+              assignmentTimestamp: 1n,
+            },
+          ],
+        },
+      },
+      stream_id: "tenant-stream",
+      timestamp: new Date(),
+      version: 1,
+    };
+
+    const encoded = encodeOutboundTenantEvent(event);
+    const decoded = decodeOutboundTenantEvent(encoded);
+
+    expect(decoded).toEqual(event);
+  });
 });