@pagopa/interop-outbound-models 1.0.0

package/proto/v2/tenant/events.proto

@@ -0,0 +1,63 @@
+syntax = "proto3";
+
+package tenant.v2;
+
+import "v2/tenant/tenant.proto";
+
+message TenantOnboardedV2 {
+  TenantV2 tenant = 1;
+}
+
+message TenantOnboardDetailsUpdatedV2 {
+  TenantV2 tenant = 1;
+}
+
+message TenantCertifiedAttributeAssignedV2 {
+  string attributeId = 1;
+  TenantV2 tenant = 2;
+}
+
+message TenantCertifiedAttributeRevokedV2 {
+  string attributeId = 1;
+  TenantV2 tenant = 2;
+}
+
+message TenantDeclaredAttributeAssignedV2 {
+  string attributeId = 1;
+  TenantV2 tenant = 2;
+}
+
+message TenantDeclaredAttributeRevokedV2 {
+  string attributeId = 1;
+  TenantV2 tenant = 2;
+}
+
+message TenantVerifiedAttributeAssignedV2 {
+  string attributeId = 1;
+  TenantV2 tenant = 2;
+}
+
+message TenantVerifiedAttributeRevokedV2 {
+  string attributeId = 1;
+  TenantV2 tenant = 2;
+}
+
+message TenantVerifiedAttributeExpirationUpdatedV2 {
+  string attributeId = 1;
+  TenantV2 tenant = 2;
+}
+
+message TenantVerifiedAttributeExtensionUpdatedV2 {
+  string attributeId = 1;
+  TenantV2 tenant = 2;
+}
+
+message MaintenanceTenantDeletedV2 {
+  string tenantId = 1;
+  TenantV2 tenant = 2;
+}
+
+message TenantKindUpdatedV2 {
+  TenantKindV2 oldKind = 1;
+  TenantV2 tenant = 2;
+}

package/proto/v2/tenant/tenant.proto

@@ -0,0 +1,85 @@
+syntax = "proto3";
+
+package tenant.v2;
+
+message TenantV2 {
+  string id = 1;
+  string selfcareId = 2;
+  ExternalIdV2 externalId = 3;
+  repeated TenantFeatureV2 features = 4;
+  repeated TenantAttributeV2 attributes = 5;
+  int64 createdAt = 6;
+  optional int64 updatedAt = 7;
+  string name = 8;
+  optional TenantKindV2 kind = 9;
+  int64 onboardedAt = 10;
+  optional TenantUnitTypeV2 subUnitType = 11;
+}
+
+enum TenantKindV2 {
+  PA = 0;
+  GSP = 1;
+  PRIVATE = 2;
+}
+
+enum TenantUnitTypeV2 {
+  AOO = 0;
+  UO = 1;
+}
+
+message TenantFeatureV2 {
+  oneof sealed_value {
+    CertifierV2 certifier = 1;
+  }
+}
+
+message CertifierV2 {
+  string certifierId = 1;
+}
+
+message TenantVerifierV2 {
+  string id = 1;
+  int64 verificationDate = 2;
+  optional int64 expirationDate = 3;
+  optional int64 extensionDate = 4;
+}
+
+message TenantRevokerV2 {
+  string id = 1;
+  int64 verificationDate = 2;
+  optional int64 expirationDate = 3;
+  optional int64 extensionDate = 4;
+  int64 revocationDate = 5;
+}
+
+message ExternalIdV2 {
+  string origin = 1;
+  string value = 2;
+}
+
+message TenantCertifiedAttributeV2 {
+  string id = 1;
+  int64 assignmentTimestamp = 2;
+  optional int64 revocationTimestamp = 3;
+}
+
+message TenantDeclaredAttributeV2 {
+  string id = 1;
+  int64 assignmentTimestamp = 2;
+  optional int64 revocationTimestamp = 3;
+}
+
+message TenantVerifiedAttributeV2 {
+  string id = 1;
+  int64 assignmentTimestamp = 2;
+  repeated TenantVerifierV2 verifiedBy = 3;
+  repeated TenantRevokerV2 revokedBy = 4;
+}
+
+message TenantAttributeV2 {
+  oneof sealed_value {
+    TenantCertifiedAttributeV2 certifiedAttribute = 1;
+    TenantDeclaredAttributeV2 declaredAttribute = 2;
+    TenantVerifiedAttributeV2 verifiedAttribute = 3;
+  }
+}

package/src/agreement/eventsV1.ts

@@ -0,0 +1,136 @@
+import { match } from "ts-pattern";
+import { z } from "zod";
+import {
+  AgreementAddedV1,
+  AgreementDeletedV1,
+  AgreementUpdatedV1,
+  AgreementContractAddedV1,
+  AgreementConsumerDocumentAddedV1,
+  AgreementConsumerDocumentRemovedV1,
+  AgreementActivatedV1,
+  AgreementSuspendedV1,
+  AgreementDeactivatedV1,
+  VerifiedAttributeUpdatedV1,
+} from "../gen/v1/agreement/events.js";
+import { protobufDecoder } from "../utils.js";
+
+export function agreementEventToBinaryDataV1(
+  event: AgreementEventV1
+): Uint8Array {
+  return match(event)
+    .with({ type: "AgreementDeleted" }, ({ data }) =>
+      AgreementDeletedV1.toBinary(data)
+    )
+    .with({ type: "AgreementAdded" }, ({ data }) =>
+      AgreementAddedV1.toBinary(data)
+    )
+    .with({ type: "AgreementActivated" }, ({ data }) =>
+      AgreementActivatedV1.toBinary(data)
+    )
+    .with({ type: "AgreementSuspended" }, ({ data }) =>
+      AgreementSuspendedV1.toBinary(data)
+    )
+    .with({ type: "AgreementDeactivated" }, ({ data }) =>
+      AgreementDeactivatedV1.toBinary(data)
+    )
+    .with({ type: "VerifiedAttributeUpdated" }, ({ data }) =>
+      VerifiedAttributeUpdatedV1.toBinary(data)
+    )
+    .with({ type: "AgreementUpdated" }, ({ data }) =>
+      AgreementUpdatedV1.toBinary(data)
+    )
+    .with({ type: "AgreementContractAdded" }, ({ data }) =>
+      AgreementContractAddedV1.toBinary(data)
+    )
+    .with({ type: "AgreementConsumerDocumentAdded" }, ({ data }) =>
+      AgreementConsumerDocumentAddedV1.toBinary(data)
+    )
+    .with({ type: "AgreementConsumerDocumentRemoved" }, ({ data }) =>
+      AgreementConsumerDocumentRemovedV1.toBinary(data)
+    )
+    .exhaustive();
+}
+
+export const AgreementEventV1 = z.discriminatedUnion("type", [
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("AgreementAdded"),
+    data: protobufDecoder(AgreementAddedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("AgreementActivated"),
+    data: protobufDecoder(AgreementActivatedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("AgreementSuspended"),
+    data: protobufDecoder(AgreementSuspendedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("AgreementDeactivated"),
+    data: protobufDecoder(AgreementDeactivatedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("AgreementDeleted"),
+    data: protobufDecoder(AgreementDeletedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("VerifiedAttributeUpdated"),
+    data: protobufDecoder(VerifiedAttributeUpdatedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("AgreementUpdated"),
+    data: protobufDecoder(AgreementUpdatedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("AgreementConsumerDocumentAdded"),
+    data: protobufDecoder(AgreementConsumerDocumentAddedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("AgreementConsumerDocumentRemoved"),
+    data: protobufDecoder(AgreementConsumerDocumentRemovedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("AgreementContractAdded"),
+    data: protobufDecoder(AgreementContractAddedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+]);
+export type AgreementEventV1 = z.infer<typeof AgreementEventV1>;

package/src/agreement/eventsV2.ts

@@ -0,0 +1,246 @@
+import { match } from "ts-pattern";
+import { z } from "zod";
+import {
+  AgreementActivatedV2,
+  AgreementAddedV2,
+  AgreementArchivedByUpgradeV2,
+  AgreementArchivedByConsumerV2,
+  AgreementConsumerDocumentAddedV2,
+  AgreementConsumerDocumentRemovedV2,
+  AgreementDeletedV2,
+  AgreementRejectedV2,
+  AgreementSubmittedV2,
+  AgreementSuspendedByConsumerV2,
+  AgreementSuspendedByPlatformV2,
+  AgreementSuspendedByProducerV2,
+  AgreementUnsuspendedByConsumerV2,
+  AgreementUnsuspendedByPlatformV2,
+  AgreementUnsuspendedByProducerV2,
+  AgreementUpgradedV2,
+  DraftAgreementUpdatedV2,
+  AgreementSetDraftByPlatformV2,
+  AgreementSetMissingCertifiedAttributesByPlatformV2,
+} from "../gen/v2/agreement/events.js";
+import { protobufDecoder } from "../utils.js";
+
+export function agreementEventToBinaryDataV2(
+  event: AgreementEventV2
+): Uint8Array {
+  return match(event)
+    .with({ type: "AgreementAdded" }, ({ data }) =>
+      AgreementAddedV2.toBinary(data)
+    )
+    .with({ type: "AgreementDeleted" }, ({ data }) =>
+      AgreementDeletedV2.toBinary(data)
+    )
+    .with({ type: "DraftAgreementUpdated" }, ({ data }) =>
+      DraftAgreementUpdatedV2.toBinary(data)
+    )
+    .with({ type: "AgreementSubmitted" }, ({ data }) =>
+      AgreementSubmittedV2.toBinary(data)
+    )
+    .with({ type: "AgreementActivated" }, ({ data }) =>
+      AgreementActivatedV2.toBinary(data)
+    )
+    .with({ type: "AgreementUnsuspendedByProducer" }, ({ data }) =>
+      AgreementUnsuspendedByProducerV2.toBinary(data)
+    )
+    .with({ type: "AgreementUnsuspendedByConsumer" }, ({ data }) =>
+      AgreementUnsuspendedByConsumerV2.toBinary(data)
+    )
+    .with({ type: "AgreementUnsuspendedByPlatform" }, ({ data }) =>
+      AgreementUnsuspendedByPlatformV2.toBinary(data)
+    )
+    .with({ type: "AgreementArchivedByConsumer" }, ({ data }) =>
+      AgreementArchivedByConsumerV2.toBinary(data)
+    )
+    .with({ type: "AgreementArchivedByUpgrade" }, ({ data }) =>
+      AgreementArchivedByUpgradeV2.toBinary(data)
+    )
+    .with({ type: "AgreementUpgraded" }, ({ data }) =>
+      AgreementUpgradedV2.toBinary(data)
+    )
+    .with({ type: "AgreementSuspendedByProducer" }, ({ data }) =>
+      AgreementSuspendedByProducerV2.toBinary(data)
+    )
+    .with({ type: "AgreementSuspendedByConsumer" }, ({ data }) =>
+      AgreementSuspendedByConsumerV2.toBinary(data)
+    )
+    .with({ type: "AgreementSuspendedByPlatform" }, ({ data }) =>
+      AgreementSuspendedByPlatformV2.toBinary(data)
+    )
+    .with({ type: "AgreementRejected" }, ({ data }) =>
+      AgreementRejectedV2.toBinary(data)
+    )
+    .with({ type: "AgreementConsumerDocumentAdded" }, ({ data }) =>
+      AgreementConsumerDocumentAddedV2.toBinary(data)
+    )
+    .with({ type: "AgreementConsumerDocumentRemoved" }, ({ data }) =>
+      AgreementConsumerDocumentRemovedV2.toBinary(data)
+    )
+    .with({ type: "AgreementSetDraftByPlatform" }, ({ data }) =>
+      AgreementSetDraftByPlatformV2.toBinary(data)
+    )
+    .with(
+      { type: "AgreementSetMissingCertifiedAttributesByPlatform" },
+      ({ data }) =>
+        AgreementSetMissingCertifiedAttributesByPlatformV2.toBinary(data)
+    )
+    .exhaustive();
+}
+
+export const AgreementEventV2 = z.discriminatedUnion("type", [
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("AgreementAdded"),
+    data: protobufDecoder(AgreementAddedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("AgreementDeleted"),
+    data: protobufDecoder(AgreementDeletedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("DraftAgreementUpdated"),
+    data: protobufDecoder(DraftAgreementUpdatedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("AgreementSubmitted"),
+    data: protobufDecoder(AgreementSubmittedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("AgreementActivated"),
+    data: protobufDecoder(AgreementActivatedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("AgreementUnsuspendedByProducer"),
+    data: protobufDecoder(AgreementUnsuspendedByProducerV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("AgreementUnsuspendedByConsumer"),
+    data: protobufDecoder(AgreementUnsuspendedByConsumerV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("AgreementUnsuspendedByPlatform"),
+    data: protobufDecoder(AgreementUnsuspendedByPlatformV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("AgreementArchivedByConsumer"),
+    data: protobufDecoder(AgreementArchivedByConsumerV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("AgreementArchivedByUpgrade"),
+    data: protobufDecoder(AgreementArchivedByUpgradeV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("AgreementUpgraded"),
+    data: protobufDecoder(AgreementUpgradedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("AgreementSuspendedByProducer"),
+    data: protobufDecoder(AgreementSuspendedByProducerV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("AgreementSuspendedByConsumer"),
+    data: protobufDecoder(AgreementSuspendedByConsumerV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("AgreementSuspendedByPlatform"),
+    data: protobufDecoder(AgreementSuspendedByPlatformV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("AgreementRejected"),
+    data: protobufDecoder(AgreementRejectedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("AgreementConsumerDocumentAdded"),
+    data: protobufDecoder(AgreementConsumerDocumentAddedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("AgreementConsumerDocumentRemoved"),
+    data: protobufDecoder(AgreementConsumerDocumentRemovedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("AgreementSetDraftByPlatform"),
+    data: protobufDecoder(AgreementSetDraftByPlatformV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("AgreementSetMissingCertifiedAttributesByPlatform"),
+    data: protobufDecoder(AgreementSetMissingCertifiedAttributesByPlatformV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+]);
+export type AgreementEventV2 = z.infer<typeof AgreementEventV2>;

package/src/agreement/index.ts

@@ -0,0 +1,45 @@
+import { match } from "ts-pattern";
+import { z } from "zod";
+import { VersionedEvent } from "../utils.js";
+import { AgreementEventV1, agreementEventToBinaryDataV1 } from "./eventsV1.js";
+import { AgreementEventV2, agreementEventToBinaryDataV2 } from "./eventsV2.js";
+
+function agreementEventToBinaryData(event: AgreementEvent): Uint8Array {
+  return match(event)
+    .with({ event_version: 1 }, agreementEventToBinaryDataV1)
+    .with({ event_version: 2 }, agreementEventToBinaryDataV2)
+    .exhaustive();
+}
+
+export function encodeOutboundAgreementEvent(event: AgreementEvent): string {
+  return JSON.stringify({
+    event_version: event.event_version,
+    type: event.type,
+    data: agreementEventToBinaryData(event),
+    stream_id: event.stream_id,
+    version: event.version,
+    timestamp: event.timestamp,
+  });
+}
+
+export function decodeOutboundAgreementEvent(
+  encodedEvent: string
+): AgreementEvent {
+  return AgreementEvent.parse(JSON.parse(encodedEvent));
+}
+
+export const AgreementEvent = VersionedEvent.transform((obj, ctx) => {
+  const res = match(obj)
+    .with({ event_version: 1 }, () => AgreementEventV1.safeParse(obj))
+    .with({ event_version: 2 }, () => AgreementEventV2.safeParse(obj))
+    .exhaustive();
+
+  if (!res.success) {
+    res.error.issues.forEach(ctx.addIssue);
+    return z.NEVER;
+  }
+  return res.data;
+});
+
+export type AgreementEvent = z.infer<typeof AgreementEvent>;
+export { AgreementEventV1, AgreementEventV2 };