@pagopa/interop-outbound-models 1.7.1 → 1.8.0

package/src/purpose-template/eventsV2.ts

@@ -0,0 +1,161 @@
+import { z } from "zod";
+import { match } from "ts-pattern";
+import {
+  PurposeTemplateAddedV2,
+  PurposeTemplateAnnotationDocumentAddedV2,
+  PurposeTemplateAnnotationDocumentDeletedV2,
+  PurposeTemplateAnnotationDocumentUpdatedV2,
+  PurposeTemplateArchivedV2,
+  PurposeTemplateDraftDeletedV2,
+  PurposeTemplateDraftUpdatedV2,
+  PurposeTemplateEServiceLinkedV2,
+  PurposeTemplateEServiceUnlinkedV2,
+  PurposeTemplatePublishedV2,
+  PurposeTemplateSuspendedV2,
+  PurposeTemplateUnsuspendedV2,
+} from "../gen/v2/purpose-template/events.js";
+import { protobufDecoder } from "../utils.js";
+
+export function purposeTemplateEventToBinaryDataV2(
+  event: PurposeTemplateEventV2
+): Uint8Array {
+  return match(event)
+    .with({ type: "PurposeTemplateAdded" }, ({ data }) =>
+      PurposeTemplateAddedV2.toBinary(data)
+    )
+    .with({ type: "PurposeTemplateEServiceLinked" }, ({ data }) =>
+      PurposeTemplateEServiceLinkedV2.toBinary(data)
+    )
+    .with({ type: "PurposeTemplateEServiceUnlinked" }, ({ data }) =>
+      PurposeTemplateEServiceUnlinkedV2.toBinary(data)
+    )
+    .with({ type: "PurposeTemplateDraftUpdated" }, ({ data }) =>
+      PurposeTemplateDraftUpdatedV2.toBinary(data)
+    )
+    .with({ type: "PurposeTemplateDraftDeleted" }, ({ data }) =>
+      PurposeTemplateDraftDeletedV2.toBinary(data)
+    )
+    .with({ type: "PurposeTemplatePublished" }, ({ data }) =>
+      PurposeTemplatePublishedV2.toBinary(data)
+    )
+    .with({ type: "PurposeTemplateUnsuspended" }, ({ data }) =>
+      PurposeTemplateUnsuspendedV2.toBinary(data)
+    )
+    .with({ type: "PurposeTemplateSuspended" }, ({ data }) =>
+      PurposeTemplateSuspendedV2.toBinary(data)
+    )
+    .with({ type: "PurposeTemplateArchived" }, ({ data }) =>
+      PurposeTemplateArchivedV2.toBinary(data)
+    )
+    .with({ type: "PurposeTemplateAnnotationDocumentAdded" }, ({ data }) =>
+      PurposeTemplateAnnotationDocumentAddedV2.toBinary(data)
+    )
+    .with({ type: "PurposeTemplateAnnotationDocumentDeleted" }, ({ data }) =>
+      PurposeTemplateAnnotationDocumentDeletedV2.toBinary(data)
+    )
+    .with({ type: "PurposeTemplateAnnotationDocumentUpdated" }, ({ data }) =>
+      PurposeTemplateAnnotationDocumentUpdatedV2.toBinary(data)
+    )
+    .exhaustive();
+}
+
+export const PurposeTemplateEventV2 = z.discriminatedUnion("type", [
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeTemplateAdded"),
+    data: protobufDecoder(PurposeTemplateAddedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.string(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeTemplateEServiceLinked"),
+    data: protobufDecoder(PurposeTemplateEServiceLinkedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.string(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeTemplateEServiceUnlinked"),
+    data: protobufDecoder(PurposeTemplateEServiceUnlinkedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.string(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeTemplateDraftUpdated"),
+    data: protobufDecoder(PurposeTemplateDraftUpdatedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.string(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeTemplateDraftDeleted"),
+    data: protobufDecoder(PurposeTemplateDraftDeletedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.string(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeTemplatePublished"),
+    data: protobufDecoder(PurposeTemplatePublishedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.string(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeTemplateUnsuspended"),
+    data: protobufDecoder(PurposeTemplateUnsuspendedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.string(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeTemplateSuspended"),
+    data: protobufDecoder(PurposeTemplateSuspendedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.string(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeTemplateArchived"),
+    data: protobufDecoder(PurposeTemplateArchivedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.string(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeTemplateAnnotationDocumentAdded"),
+    data: protobufDecoder(PurposeTemplateAnnotationDocumentAddedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.string(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeTemplateAnnotationDocumentDeleted"),
+    data: protobufDecoder(PurposeTemplateAnnotationDocumentDeletedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.string(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeTemplateAnnotationDocumentUpdated"),
+    data: protobufDecoder(PurposeTemplateAnnotationDocumentUpdatedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.string(),
+  }),
+]);
+
+export type PurposeTemplateEventV2 = z.infer<typeof PurposeTemplateEventV2>;

package/src/purpose-template/index.ts

@@ -0,0 +1,53 @@
+import { match } from "ts-pattern";
+import { z } from "zod";
+import { VersionedEvent } from "../utils.js";
+import {
+  PurposeTemplateEventV2,
+  purposeTemplateEventToBinaryDataV2,
+} from "./eventsV2.js";
+
+export function purposeTemplateEventToBinaryData(
+  event: PurposeTemplateEvent
+): Uint8Array {
+  return match(event)
+    .with({ event_version: 2 }, purposeTemplateEventToBinaryDataV2)
+    .exhaustive();
+}
+
+export function encodeOutboundPurposeTemplateEvent(
+  event: PurposeTemplateEvent
+): string {
+  return JSON.stringify({
+    event_version: event.event_version,
+    type: event.type,
+    data: Buffer.from(purposeTemplateEventToBinaryData(event)).toString("hex"),
+    stream_id: event.stream_id,
+    version: event.version,
+    timestamp: event.timestamp,
+  });
+}
+
+export function decodeOutboundPurposeTemplateEvent(
+  encodedEvent: string
+): PurposeTemplateEvent {
+  return PurposeTemplateEvent.parse(JSON.parse(encodedEvent));
+}
+
+export const PurposeTemplateEvent = VersionedEvent.transform((obj, ctx) => {
+  const res = match(obj)
+    .with({ event_version: 1 }, () => {
+      throw new Error("Unsupported event version");
+    })
+    .with({ event_version: 2 }, () => PurposeTemplateEventV2.safeParse(obj))
+    .exhaustive();
+
+  if (!res.success) {
+    res.error.issues.forEach(ctx.addIssue);
+    return z.NEVER;
+  }
+  return res.data;
+});
+
+export type PurposeTemplateEventType = PurposeTemplateEvent["type"];
+export type PurposeTemplateEvent = z.infer<typeof PurposeTemplateEvent>;
+export { PurposeTemplateEventV2 };