@pagopa/interop-outbound-models 1.0.0

package/src/eservice/eventsV1.ts

@@ -0,0 +1,149 @@
+import { match } from "ts-pattern";
+import { z } from "zod";
+import {
+  ClonedEServiceAddedV1,
+  EServiceAddedV1,
+  EServiceDeletedV1,
+  EServiceDescriptorAddedV1,
+  EServiceDescriptorUpdatedV1,
+  EServiceDocumentAddedV1,
+  EServiceDocumentDeletedV1,
+  EServiceDocumentUpdatedV1,
+  EServiceUpdatedV1,
+  EServiceWithDescriptorsDeletedV1,
+  MovedAttributesFromEserviceToDescriptorsV1,
+} from "../gen/v1/eservice/events.js";
+import { protobufDecoder } from "../utils.js";
+
+export function eServiceEventToBinaryDataV1(
+  event: EServiceEventV1
+): Uint8Array {
+  return match(event)
+    .with({ type: "EServiceAdded" }, ({ data }) =>
+      EServiceAddedV1.toBinary(data)
+    )
+    .with({ type: "ClonedEServiceAdded" }, ({ data }) =>
+      ClonedEServiceAddedV1.toBinary(data)
+    )
+    .with({ type: "EServiceUpdated" }, ({ data }) =>
+      EServiceUpdatedV1.toBinary(data)
+    )
+    .with({ type: "EServiceWithDescriptorsDeleted" }, ({ data }) =>
+      EServiceWithDescriptorsDeletedV1.toBinary(data)
+    )
+    .with({ type: "EServiceDocumentUpdated" }, ({ data }) =>
+      EServiceDocumentUpdatedV1.toBinary(data)
+    )
+    .with({ type: "EServiceDeleted" }, ({ data }) =>
+      EServiceDeletedV1.toBinary(data)
+    )
+    .with({ type: "EServiceDocumentAdded" }, ({ data }) =>
+      EServiceDocumentAddedV1.toBinary(data)
+    )
+    .with({ type: "EServiceDocumentDeleted" }, ({ data }) =>
+      EServiceDocumentDeletedV1.toBinary(data)
+    )
+    .with({ type: "EServiceDescriptorAdded" }, ({ data }) =>
+      EServiceDescriptorAddedV1.toBinary(data)
+    )
+    .with({ type: "EServiceDescriptorUpdated" }, ({ data }) =>
+      EServiceDescriptorUpdatedV1.toBinary(data)
+    )
+    .with({ type: "MovedAttributesFromEserviceToDescriptors" }, ({ data }) =>
+      MovedAttributesFromEserviceToDescriptorsV1.toBinary(data)
+    )
+    .exhaustive();
+}
+
+export const EServiceEventV1 = z.discriminatedUnion("type", [
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("EServiceAdded"),
+    data: protobufDecoder(EServiceAddedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("ClonedEServiceAdded"),
+    data: protobufDecoder(ClonedEServiceAddedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("EServiceUpdated"),
+    data: protobufDecoder(EServiceUpdatedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("EServiceWithDescriptorsDeleted"),
+    data: protobufDecoder(EServiceWithDescriptorsDeletedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("EServiceDocumentUpdated"),
+    data: protobufDecoder(EServiceDocumentUpdatedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("EServiceDeleted"),
+    data: protobufDecoder(EServiceDeletedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("EServiceDocumentAdded"),
+    data: protobufDecoder(EServiceDocumentAddedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("EServiceDocumentDeleted"),
+    data: protobufDecoder(EServiceDocumentDeletedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("EServiceDescriptorAdded"),
+    data: protobufDecoder(EServiceDescriptorAddedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("EServiceDescriptorUpdated"),
+    data: protobufDecoder(EServiceDescriptorUpdatedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("MovedAttributesFromEserviceToDescriptors"),
+    data: protobufDecoder(MovedAttributesFromEserviceToDescriptorsV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+]);
+
+export type EServiceEventV1 = z.infer<typeof EServiceEventV1>;

package/src/eservice/eventsV2.ts

@@ -0,0 +1,245 @@
+import { match } from "ts-pattern";
+import { z } from "zod";
+import { protobufDecoder } from "../utils.js";
+import {
+  DraftEServiceUpdatedV2,
+  EServiceAddedV2,
+  EServiceClonedV2,
+  EServiceDeletedV2,
+  EServiceDescriptorActivatedV2,
+  EServiceDescriptorAddedV2,
+  EServiceDescriptorArchivedV2,
+  EServiceDescriptorDocumentAddedV2,
+  EServiceDescriptorDocumentDeletedV2,
+  EServiceDescriptorDocumentUpdatedV2,
+  EServiceDescriptorInterfaceAddedV2,
+  EServiceDescriptorInterfaceDeletedV2,
+  EServiceDescriptorInterfaceUpdatedV2,
+  EServiceDescriptorPublishedV2,
+  EServiceDescriptorSuspendedV2,
+  EServiceDraftDescriptorDeletedV2,
+  EServiceDraftDescriptorUpdatedV2,
+  EServiceDescriptorQuotasUpdatedV2,
+  EServiceDescriptionUpdatedV2,
+} from "../gen/v2/eservice/events.js";
+
+export function eServiceEventToBinaryDataV2(
+  event: EServiceEventV2
+): Uint8Array {
+  return match(event)
+    .with({ type: "EServiceAdded" }, ({ data }) =>
+      EServiceAddedV2.toBinary(data)
+    )
+    .with({ type: "DraftEServiceUpdated" }, ({ data }) =>
+      DraftEServiceUpdatedV2.toBinary(data)
+    )
+    .with({ type: "EServiceDeleted" }, ({ data }) =>
+      EServiceDeletedV2.toBinary(data)
+    )
+    .with({ type: "EServiceCloned" }, ({ data }) =>
+      EServiceClonedV2.toBinary(data)
+    )
+    .with({ type: "EServiceDescriptorAdded" }, ({ data }) =>
+      EServiceDescriptorAddedV2.toBinary(data)
+    )
+    .with({ type: "EServiceDraftDescriptorUpdated" }, ({ data }) =>
+      EServiceDraftDescriptorUpdatedV2.toBinary(data)
+    )
+    .with({ type: "EServiceDescriptorQuotasUpdated" }, ({ data }) =>
+      EServiceDescriptorQuotasUpdatedV2.toBinary(data)
+    )
+    .with({ type: "EServiceDescriptorActivated" }, ({ data }) =>
+      EServiceDescriptorActivatedV2.toBinary(data)
+    )
+    .with({ type: "EServiceDescriptorArchived" }, ({ data }) =>
+      EServiceDescriptorArchivedV2.toBinary(data)
+    )
+    .with({ type: "EServiceDescriptorPublished" }, ({ data }) =>
+      EServiceDescriptorPublishedV2.toBinary(data)
+    )
+    .with({ type: "EServiceDescriptorSuspended" }, ({ data }) =>
+      EServiceDescriptorSuspendedV2.toBinary(data)
+    )
+    .with({ type: "EServiceDraftDescriptorDeleted" }, ({ data }) =>
+      EServiceDraftDescriptorDeletedV2.toBinary(data)
+    )
+    .with({ type: "EServiceDescriptorInterfaceAdded" }, ({ data }) =>
+      EServiceDescriptorInterfaceAddedV2.toBinary(data)
+    )
+    .with({ type: "EServiceDescriptorDocumentAdded" }, ({ data }) =>
+      EServiceDescriptorDocumentAddedV2.toBinary(data)
+    )
+    .with({ type: "EServiceDescriptorInterfaceUpdated" }, ({ data }) =>
+      EServiceDescriptorInterfaceUpdatedV2.toBinary(data)
+    )
+    .with({ type: "EServiceDescriptorDocumentUpdated" }, ({ data }) =>
+      EServiceDescriptorDocumentUpdatedV2.toBinary(data)
+    )
+    .with({ type: "EServiceDescriptorInterfaceDeleted" }, ({ data }) =>
+      EServiceDescriptorInterfaceDeletedV2.toBinary(data)
+    )
+    .with({ type: "EServiceDescriptorDocumentDeleted" }, ({ data }) =>
+      EServiceDescriptorDocumentDeletedV2.toBinary(data)
+    )
+    .with({ type: "EServiceDescriptionUpdated" }, ({ data }) =>
+      EServiceDescriptionUpdatedV2.toBinary(data)
+    )
+    .exhaustive();
+}
+
+export const EServiceEventV2 = z.discriminatedUnion("type", [
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("EServiceAdded"),
+    data: protobufDecoder(EServiceAddedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("DraftEServiceUpdated"),
+    data: protobufDecoder(DraftEServiceUpdatedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("EServiceDeleted"),
+    data: protobufDecoder(EServiceDeletedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("EServiceCloned"),
+    data: protobufDecoder(EServiceClonedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("EServiceDescriptorAdded"),
+    data: protobufDecoder(EServiceDescriptorAddedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("EServiceDraftDescriptorUpdated"),
+    data: protobufDecoder(EServiceDraftDescriptorUpdatedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("EServiceDescriptorQuotasUpdated"),
+    data: protobufDecoder(EServiceDescriptorQuotasUpdatedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("EServiceDescriptorActivated"),
+    data: protobufDecoder(EServiceDescriptorActivatedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("EServiceDescriptorArchived"),
+    data: protobufDecoder(EServiceDescriptorArchivedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("EServiceDescriptorPublished"),
+    data: protobufDecoder(EServiceDescriptorPublishedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("EServiceDescriptorSuspended"),
+    data: protobufDecoder(EServiceDescriptorSuspendedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("EServiceDraftDescriptorDeleted"),
+    data: protobufDecoder(EServiceDraftDescriptorDeletedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("EServiceDescriptorInterfaceAdded"),
+    data: protobufDecoder(EServiceDescriptorInterfaceAddedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("EServiceDescriptorDocumentAdded"),
+    data: protobufDecoder(EServiceDescriptorDocumentAddedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("EServiceDescriptorInterfaceUpdated"),
+    data: protobufDecoder(EServiceDescriptorInterfaceUpdatedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("EServiceDescriptorDocumentUpdated"),
+    data: protobufDecoder(EServiceDescriptorDocumentUpdatedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("EServiceDescriptorInterfaceDeleted"),
+    data: protobufDecoder(EServiceDescriptorInterfaceDeletedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("EServiceDescriptorDocumentDeleted"),
+    data: protobufDecoder(EServiceDescriptorDocumentDeletedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("EServiceDescriptionUpdated"),
+    data: protobufDecoder(EServiceDescriptionUpdatedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+]);
+
+export type EServiceEventV2 = z.infer<typeof EServiceEventV2>;

package/src/eservice/index.ts

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

package/src/index.ts

@@ -0,0 +1,22 @@
+export * from "./eservice/index.js";
+export * from "./agreement/index.js";
+export * from "./purpose/index.js";
+export * from "./tenant/index.js";
+
+export * from "./gen/v1/agreement/agreement.js";
+export * from "./gen/v1/agreement/events.js";
+export * from "./gen/v1/eservice/eservice.js";
+export * from "./gen/v1/eservice/events.js";
+export * from "./gen/v1/purpose/purpose.js";
+export * from "./gen/v1/purpose/events.js";
+export * from "./gen/v1/tenant/tenant.js";
+export * from "./gen/v1/tenant/events.js";
+
+export * from "./gen/v2/agreement/agreement.js";
+export * from "./gen/v2/agreement/events.js";
+export * from "./gen/v2/eservice/eservice.js";
+export * from "./gen/v2/eservice/events.js";
+export * from "./gen/v2/purpose/purpose.js";
+export * from "./gen/v2/purpose/events.js";
+export * from "./gen/v2/tenant/tenant.js";
+export * from "./gen/v2/tenant/events.js";

package/src/purpose/eventsV1.ts

@@ -0,0 +1,146 @@
+import { match } from "ts-pattern";
+import { z } from "zod";
+import {
+  PurposeCreatedV1,
+  PurposeDeletedV1,
+  PurposeUpdatedV1,
+  PurposeVersionActivatedV1,
+  PurposeVersionArchivedV1,
+  PurposeVersionCreatedV1,
+  PurposeVersionDeletedV1,
+  PurposeVersionRejectedV1,
+  PurposeVersionSuspendedV1,
+  PurposeVersionUpdatedV1,
+  PurposeVersionWaitedForApprovalV1,
+} from "../gen/v1/purpose/events.js";
+import { protobufDecoder } from "../utils.js";
+
+export function purposeEventToBinaryDataV1(event: PurposeEventV1): Uint8Array {
+  return match(event)
+    .with({ type: "PurposeCreated" }, ({ data }) =>
+      PurposeCreatedV1.toBinary(data)
+    )
+    .with({ type: "PurposeVersionCreated" }, ({ data }) =>
+      PurposeVersionCreatedV1.toBinary(data)
+    )
+    .with({ type: "PurposeUpdated" }, ({ data }) =>
+      PurposeUpdatedV1.toBinary(data)
+    )
+    .with({ type: "PurposeVersionUpdated" }, ({ data }) =>
+      PurposeVersionUpdatedV1.toBinary(data)
+    )
+    .with({ type: "PurposeVersionActivated" }, ({ data }) =>
+      PurposeVersionActivatedV1.toBinary(data)
+    )
+    .with({ type: "PurposeVersionRejected" }, ({ data }) =>
+      PurposeVersionRejectedV1.toBinary(data)
+    )
+    .with({ type: "PurposeVersionSuspended" }, ({ data }) =>
+      PurposeVersionSuspendedV1.toBinary(data)
+    )
+    .with({ type: "PurposeVersionArchived" }, ({ data }) =>
+      PurposeVersionArchivedV1.toBinary(data)
+    )
+    .with({ type: "PurposeVersionWaitedForApproval" }, ({ data }) =>
+      PurposeVersionWaitedForApprovalV1.toBinary(data)
+    )
+    .with({ type: "PurposeDeleted" }, ({ data }) =>
+      PurposeDeletedV1.toBinary(data)
+    )
+    .with({ type: "PurposeVersionDeleted" }, ({ data }) =>
+      PurposeVersionDeletedV1.toBinary(data)
+    )
+    .exhaustive();
+}
+
+export const PurposeEventV1 = z.discriminatedUnion("type", [
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("PurposeCreated"),
+    data: protobufDecoder(PurposeCreatedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("PurposeUpdated"),
+    data: protobufDecoder(PurposeUpdatedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("PurposeVersionWaitedForApproval"),
+    data: protobufDecoder(PurposeVersionWaitedForApprovalV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("PurposeVersionActivated"),
+    data: protobufDecoder(PurposeVersionActivatedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("PurposeVersionCreated"),
+    data: protobufDecoder(PurposeVersionCreatedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("PurposeVersionSuspended"),
+    data: protobufDecoder(PurposeVersionSuspendedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("PurposeVersionArchived"),
+    data: protobufDecoder(PurposeVersionArchivedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("PurposeVersionUpdated"),
+    data: protobufDecoder(PurposeVersionUpdatedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("PurposeVersionDeleted"),
+    data: protobufDecoder(PurposeVersionDeletedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("PurposeDeleted"),
+    data: protobufDecoder(PurposeDeletedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("PurposeVersionRejected"),
+    data: protobufDecoder(PurposeVersionRejectedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+]);
+export type PurposeEventV1 = z.infer<typeof PurposeEventV1>;