@pagopa/interop-outbound-models 1.0.0

package/src/purpose/eventsV2.ts

@@ -0,0 +1,228 @@
+import { match } from "ts-pattern";
+import { z } from "zod";
+import {
+  PurposeAddedV2,
+  DraftPurposeUpdatedV2,
+  PurposeWaitingForApprovalV2,
+  PurposeActivatedV2,
+  DraftPurposeDeletedV2,
+  WaitingForApprovalPurposeDeletedV2,
+  NewPurposeVersionActivatedV2,
+  PurposeVersionActivatedV2,
+  PurposeVersionUnsuspendedByProducerV2,
+  PurposeVersionUnsuspendedByConsumerV2,
+  PurposeVersionSuspendedByProducerV2,
+  PurposeVersionSuspendedByConsumerV2,
+  NewPurposeVersionWaitingForApprovalV2,
+  PurposeVersionOverQuotaUnsuspendedV2,
+  PurposeArchivedV2,
+  WaitingForApprovalPurposeVersionDeletedV2,
+  PurposeVersionRejectedV2,
+  PurposeClonedV2,
+} from "../gen/v2/purpose/events.js";
+import { protobufDecoder } from "../utils.js";
+
+export function purposeEventToBinaryDataV2(event: PurposeEventV2): Uint8Array {
+  return match(event)
+    .with({ type: "PurposeAdded" }, ({ data }) => PurposeAddedV2.toBinary(data))
+    .with({ type: "DraftPurposeUpdated" }, ({ data }) =>
+      DraftPurposeUpdatedV2.toBinary(data)
+    )
+    .with({ type: "PurposeWaitingForApproval" }, ({ data }) =>
+      PurposeWaitingForApprovalV2.toBinary(data)
+    )
+    .with({ type: "PurposeActivated" }, ({ data }) =>
+      PurposeActivatedV2.toBinary(data)
+    )
+    .with({ type: "DraftPurposeDeleted" }, ({ data }) =>
+      DraftPurposeDeletedV2.toBinary(data)
+    )
+    .with({ type: "WaitingForApprovalPurposeDeleted" }, ({ data }) =>
+      WaitingForApprovalPurposeDeletedV2.toBinary(data)
+    )
+    .with({ type: "NewPurposeVersionActivated" }, ({ data }) =>
+      NewPurposeVersionActivatedV2.toBinary(data)
+    )
+    .with({ type: "PurposeVersionActivated" }, ({ data }) =>
+      PurposeVersionActivatedV2.toBinary(data)
+    )
+    .with({ type: "PurposeVersionUnsuspendedByProducer" }, ({ data }) =>
+      PurposeVersionUnsuspendedByProducerV2.toBinary(data)
+    )
+    .with({ type: "PurposeVersionUnsuspendedByConsumer" }, ({ data }) =>
+      PurposeVersionUnsuspendedByConsumerV2.toBinary(data)
+    )
+    .with({ type: "PurposeVersionSuspendedByProducer" }, ({ data }) =>
+      PurposeVersionSuspendedByProducerV2.toBinary(data)
+    )
+    .with({ type: "PurposeVersionSuspendedByConsumer" }, ({ data }) =>
+      PurposeVersionSuspendedByConsumerV2.toBinary(data)
+    )
+    .with({ type: "NewPurposeVersionWaitingForApproval" }, ({ data }) =>
+      NewPurposeVersionWaitingForApprovalV2.toBinary(data)
+    )
+    .with({ type: "PurposeVersionOverQuotaUnsuspended" }, ({ data }) =>
+      PurposeVersionOverQuotaUnsuspendedV2.toBinary(data)
+    )
+    .with({ type: "PurposeArchived" }, ({ data }) =>
+      PurposeArchivedV2.toBinary(data)
+    )
+    .with({ type: "WaitingForApprovalPurposeVersionDeleted" }, ({ data }) =>
+      WaitingForApprovalPurposeVersionDeletedV2.toBinary(data)
+    )
+    .with({ type: "PurposeVersionRejected" }, ({ data }) =>
+      PurposeVersionRejectedV2.toBinary(data)
+    )
+    .with({ type: "PurposeCloned" }, ({ data }) =>
+      PurposeClonedV2.toBinary(data)
+    )
+    .exhaustive();
+}
+
+export const PurposeEventV2 = z.discriminatedUnion("type", [
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeAdded"),
+    data: protobufDecoder(PurposeAddedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("DraftPurposeUpdated"),
+    data: protobufDecoder(DraftPurposeUpdatedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeWaitingForApproval"),
+    data: protobufDecoder(PurposeWaitingForApprovalV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeActivated"),
+    data: protobufDecoder(PurposeActivatedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("DraftPurposeDeleted"),
+    data: protobufDecoder(DraftPurposeDeletedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("WaitingForApprovalPurposeDeleted"),
+    data: protobufDecoder(WaitingForApprovalPurposeDeletedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("NewPurposeVersionActivated"),
+    data: protobufDecoder(NewPurposeVersionActivatedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeVersionActivated"),
+    data: protobufDecoder(PurposeVersionActivatedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeVersionUnsuspendedByProducer"),
+    data: protobufDecoder(PurposeVersionUnsuspendedByProducerV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeVersionUnsuspendedByConsumer"),
+    data: protobufDecoder(PurposeVersionUnsuspendedByConsumerV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeVersionSuspendedByProducer"),
+    data: protobufDecoder(PurposeVersionSuspendedByProducerV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeVersionSuspendedByConsumer"),
+    data: protobufDecoder(PurposeVersionSuspendedByConsumerV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("NewPurposeVersionWaitingForApproval"),
+    data: protobufDecoder(NewPurposeVersionWaitingForApprovalV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeVersionOverQuotaUnsuspended"),
+    data: protobufDecoder(PurposeVersionOverQuotaUnsuspendedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeArchived"),
+    data: protobufDecoder(PurposeArchivedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("WaitingForApprovalPurposeVersionDeleted"),
+    data: protobufDecoder(WaitingForApprovalPurposeVersionDeletedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeVersionRejected"),
+    data: protobufDecoder(PurposeVersionRejectedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("PurposeCloned"),
+    data: protobufDecoder(PurposeClonedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+]);
+export type PurposeEventV2 = z.infer<typeof PurposeEventV2>;

package/src/purpose/index.ts

@@ -0,0 +1,42 @@
+import { match } from "ts-pattern";
+import { z } from "zod";
+import { VersionedEvent } from "../utils.js";
+import { PurposeEventV1, purposeEventToBinaryDataV1 } from "./eventsV1.js";
+import { PurposeEventV2, purposeEventToBinaryDataV2 } from "./eventsV2.js";
+
+function purposeEventToBinaryData(event: PurposeEvent): Uint8Array {
+  return match(event)
+    .with({ event_version: 1 }, purposeEventToBinaryDataV1)
+    .with({ event_version: 2 }, purposeEventToBinaryDataV2)
+    .exhaustive();
+}
+
+export function encodeOutboundPurposeEvent(event: PurposeEvent): string {
+  return JSON.stringify({
+    event_version: event.event_version,
+    type: event.type,
+    data: purposeEventToBinaryData(event),
+    stream_id: event.stream_id,
+    version: event.version,
+    timestamp: event.timestamp,
+  });
+}
+
+export function decodeOutboundPurposeEvent(encodedEvent: string): PurposeEvent {
+  return PurposeEvent.parse(JSON.parse(encodedEvent));
+}
+
+export const PurposeEvent = VersionedEvent.transform((obj, ctx) => {
+  const res = match(obj)
+    .with({ event_version: 1 }, () => PurposeEventV1.safeParse(obj))
+    .with({ event_version: 2 }, () => PurposeEventV2.safeParse(obj))
+    .exhaustive();
+
+  if (!res.success) {
+    res.error.issues.forEach(ctx.addIssue);
+    return z.NEVER;
+  }
+  return res.data;
+});
+export type PurposeEvent = z.infer<typeof PurposeEvent>;
+export { PurposeEventV1, PurposeEventV2 };

package/src/tenant/eventsV1.ts

@@ -0,0 +1,51 @@
+import { match } from "ts-pattern";
+import { z } from "zod";
+import {
+  TenantCreatedV1,
+  TenantUpdatedV1,
+  TenantDeletedV1,
+} from "../gen/v1/tenant/events.js";
+import { protobufDecoder } from "../utils.js";
+
+export function tenantEventToBinaryDataV1(event: TenantEventV1): Uint8Array {
+  return match(event)
+    .with({ type: "TenantCreated" }, ({ data }) =>
+      TenantCreatedV1.toBinary(data)
+    )
+    .with({ type: "TenantUpdated" }, ({ data }) =>
+      TenantUpdatedV1.toBinary(data)
+    )
+    .with({ type: "TenantDeleted" }, ({ data }) =>
+      TenantDeletedV1.toBinary(data)
+    )
+    .exhaustive();
+}
+
+export const TenantEventV1 = z.discriminatedUnion("type", [
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("TenantCreated"),
+    data: protobufDecoder(TenantCreatedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("TenantUpdated"),
+    data: protobufDecoder(TenantUpdatedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(1),
+    type: z.literal("TenantDeleted"),
+    data: protobufDecoder(TenantDeletedV1),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+]);
+
+export type TenantEventV1 = z.infer<typeof TenantEventV1>;

package/src/tenant/eventsV2.ts

@@ -0,0 +1,159 @@
+import { match } from "ts-pattern";
+import { z } from "zod";
+import {
+  TenantOnboardedV2,
+  TenantOnboardDetailsUpdatedV2,
+  TenantCertifiedAttributeAssignedV2,
+  TenantCertifiedAttributeRevokedV2,
+  TenantDeclaredAttributeAssignedV2,
+  TenantDeclaredAttributeRevokedV2,
+  TenantVerifiedAttributeAssignedV2,
+  TenantVerifiedAttributeRevokedV2,
+  TenantVerifiedAttributeExpirationUpdatedV2,
+  MaintenanceTenantDeletedV2,
+  TenantVerifiedAttributeExtensionUpdatedV2,
+  TenantKindUpdatedV2,
+} from "../gen/v2/tenant/events.js";
+import { protobufDecoder } from "../utils.js";
+
+export function tenantEventToBinaryDataV2(event: TenantEventV2): Uint8Array {
+  return match(event)
+    .with({ type: "TenantOnboarded" }, ({ data }) =>
+      TenantOnboardedV2.toBinary(data)
+    )
+    .with({ type: "TenantOnboardDetailsUpdated" }, ({ data }) =>
+      TenantOnboardDetailsUpdatedV2.toBinary(data)
+    )
+    .with({ type: "TenantCertifiedAttributeAssigned" }, ({ data }) =>
+      TenantCertifiedAttributeAssignedV2.toBinary(data)
+    )
+    .with({ type: "TenantCertifiedAttributeRevoked" }, ({ data }) =>
+      TenantCertifiedAttributeRevokedV2.toBinary(data)
+    )
+    .with({ type: "TenantDeclaredAttributeAssigned" }, ({ data }) =>
+      TenantDeclaredAttributeAssignedV2.toBinary(data)
+    )
+    .with({ type: "TenantDeclaredAttributeRevoked" }, ({ data }) =>
+      TenantDeclaredAttributeRevokedV2.toBinary(data)
+    )
+    .with({ type: "TenantVerifiedAttributeAssigned" }, ({ data }) =>
+      TenantVerifiedAttributeAssignedV2.toBinary(data)
+    )
+    .with({ type: "TenantVerifiedAttributeRevoked" }, ({ data }) =>
+      TenantVerifiedAttributeRevokedV2.toBinary(data)
+    )
+    .with({ type: "TenantVerifiedAttributeExpirationUpdated" }, ({ data }) =>
+      TenantVerifiedAttributeExpirationUpdatedV2.toBinary(data)
+    )
+    .with({ type: "TenantVerifiedAttributeExtensionUpdated" }, ({ data }) =>
+      TenantVerifiedAttributeExtensionUpdatedV2.toBinary(data)
+    )
+    .with({ type: "MaintenanceTenantDeleted" }, ({ data }) =>
+      MaintenanceTenantDeletedV2.toBinary(data)
+    )
+    .with({ type: "TenantKindUpdated" }, ({ data }) =>
+      TenantKindUpdatedV2.toBinary(data)
+    )
+    .exhaustive();
+}
+
+export const TenantEventV2 = z.discriminatedUnion("type", [
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("TenantOnboarded"),
+    data: protobufDecoder(TenantOnboardedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("TenantOnboardDetailsUpdated"),
+    data: protobufDecoder(TenantOnboardDetailsUpdatedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("TenantCertifiedAttributeAssigned"),
+    data: protobufDecoder(TenantCertifiedAttributeAssignedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("TenantCertifiedAttributeRevoked"),
+    data: protobufDecoder(TenantCertifiedAttributeRevokedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("TenantDeclaredAttributeAssigned"),
+    data: protobufDecoder(TenantDeclaredAttributeAssignedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("TenantDeclaredAttributeRevoked"),
+    data: protobufDecoder(TenantDeclaredAttributeRevokedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("TenantVerifiedAttributeAssigned"),
+    data: protobufDecoder(TenantVerifiedAttributeAssignedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("TenantVerifiedAttributeRevoked"),
+    data: protobufDecoder(TenantVerifiedAttributeRevokedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("TenantVerifiedAttributeExpirationUpdated"),
+    data: protobufDecoder(TenantVerifiedAttributeExpirationUpdatedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("TenantVerifiedAttributeExtensionUpdated"),
+    data: protobufDecoder(TenantVerifiedAttributeExtensionUpdatedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("MaintenanceTenantDeleted"),
+    data: protobufDecoder(MaintenanceTenantDeletedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+  z.object({
+    event_version: z.literal(2),
+    type: z.literal("TenantKindUpdated"),
+    data: protobufDecoder(TenantKindUpdatedV2),
+    stream_id: z.string(),
+    version: z.number(),
+    timestamp: z.coerce.date(),
+  }),
+]);
+
+export type TenantEventV2 = z.infer<typeof TenantEventV2>;

package/src/tenant/index.ts

@@ -0,0 +1,43 @@
+import { match } from "ts-pattern";
+import { z } from "zod";
+import { VersionedEvent } from "../utils.js";
+import { TenantEventV1, tenantEventToBinaryDataV1 } from "./eventsV1.js";
+import { TenantEventV2, tenantEventToBinaryDataV2 } from "./eventsV2.js";
+
+function tenantEventToBinaryData(event: TenantEvent): Uint8Array {
+  return match(event)
+    .with({ event_version: 1 }, tenantEventToBinaryDataV1)
+    .with({ event_version: 2 }, tenantEventToBinaryDataV2)
+    .exhaustive();
+}
+
+export function encodeOutboundTenantEvent(event: TenantEvent): string {
+  return JSON.stringify({
+    event_version: event.event_version,
+    type: event.type,
+    data: tenantEventToBinaryData(event),
+    stream_id: event.stream_id,
+    version: event.version,
+    timestamp: event.timestamp,
+  });
+}
+
+export function decodeOutboundTenantEvent(encodedEvent: string): TenantEvent {
+  return TenantEvent.parse(JSON.parse(encodedEvent));
+}
+
+export const TenantEvent = VersionedEvent.transform((obj, ctx) => {
+  const res = match(obj)
+    .with({ event_version: 1 }, () => TenantEventV1.safeParse(obj))
+    .with({ event_version: 2 }, () => TenantEventV2.safeParse(obj))
+    .exhaustive();
+
+  if (!res.success) {
+    res.error.issues.forEach(ctx.addIssue);
+    return z.NEVER;
+  }
+  return res.data;
+});
+
+export type TenantEvent = z.infer<typeof TenantEvent>;
+export { TenantEventV1, TenantEventV2 };

package/src/utils.ts

@@ -0,0 +1,25 @@
+import { MessageType } from "@protobuf-ts/runtime";
+import { ZodAny, ZodTransformer, z } from "zod";
+
+export const VersionedEvent = z.discriminatedUnion("event_version", [
+  z
+    .object({
+      event_version: z.literal(1),
+    })
+    .passthrough(),
+  z
+    .object({
+      event_version: z.literal(2),
+    })
+    .passthrough(),
+]);
+
+export function protobufDecoder<I extends object>(
+  decoder: MessageType<I>
+): ZodTransformer<ZodAny, I> {
+  return z
+    .any()
+    .transform((v) =>
+      decoder.fromBinary(Buffer.from(Object.values(v) as never, "hex"))
+    );
+}

package/tests/agreement.test.ts

@@ -0,0 +1,28 @@
+import { describe, it, expect } from "vitest";
+import {
+  encodeOutboundAgreementEvent,
+  decodeOutboundAgreementEvent,
+  AgreementEvent,
+} from "../src/index.js";
+
+describe("agreement", () => {
+  it("should correctly encode and decode AgreementDeleted event", () => {
+    const event: AgreementEvent = {
+      event_version: 1,
+      type: "AgreementDeleted",
+      data: {
+        agreementId: "123",
+      },
+      stream_id: "123",
+      timestamp: new Date(),
+      version: 1,
+    };
+
+    const encoded = encodeOutboundAgreementEvent(event);
+    const decoded = decodeOutboundAgreementEvent(encoded);
+
+    expect(decoded).toEqual(event);
+  });
+
+  // TODO: Add more tests for other event types
+});

package/tests/eservice.test.ts

@@ -0,0 +1,28 @@
+import { describe, it, expect } from "vitest";
+import {
+  encodeOutboundEServiceEvent,
+  decodeOutboundEServiceEvent,
+  EServiceEvent,
+} from "../src/index.js";
+
+describe("eservice", () => {
+  it("should correctly encode and decode EServiceDeleted event", () => {
+    const event: EServiceEvent = {
+      event_version: 1,
+      type: "EServiceDeleted",
+      data: {
+        eserviceId: "123",
+      },
+      stream_id: "123",
+      timestamp: new Date(),
+      version: 1,
+    };
+
+    const encoded = encodeOutboundEServiceEvent(event);
+    const decoded = decodeOutboundEServiceEvent(encoded);
+
+    expect(decoded).toEqual(event);
+  });
+
+  // TODO: Add more tests for other event types
+});

package/tests/purpose.test.ts

@@ -0,0 +1,28 @@
+import { describe, it, expect } from "vitest";
+import {
+  encodeOutboundPurposeEvent,
+  decodeOutboundPurposeEvent,
+  PurposeEvent,
+} from "../src/index.js";
+
+describe("purpose", () => {
+  it("should correctly encode and decode PurposeDeleted event", () => {
+    const event: PurposeEvent = {
+      event_version: 1,
+      type: "PurposeDeleted",
+      data: {
+        purposeId: "123",
+      },
+      stream_id: "123",
+      timestamp: new Date(),
+      version: 1,
+    };
+
+    const encoded = encodeOutboundPurposeEvent(event);
+    const decoded = decodeOutboundPurposeEvent(encoded);
+
+    expect(decoded).toEqual(event);
+  });
+
+  // TODO: Add more tests for other event types
+});

package/tests/tenant.test.ts

@@ -0,0 +1,28 @@
+import { describe, it, expect } from "vitest";
+import {
+  encodeOutboundTenantEvent,
+  decodeOutboundTenantEvent,
+  TenantEvent,
+} from "../src/index.js";
+
+describe("tenant", () => {
+  it("should correctly encode and decode TenantDeleted event", () => {
+    const event: TenantEvent = {
+      event_version: 1,
+      type: "TenantDeleted",
+      data: {
+        tenantId: "123",
+      },
+      stream_id: "123",
+      timestamp: new Date(),
+      version: 1,
+    };
+
+    const encoded = encodeOutboundTenantEvent(event);
+    const decoded = decodeOutboundTenantEvent(encoded);
+
+    expect(decoded).toEqual(event);
+  });
+
+  // TODO: Add more tests for other event types
+});

package/tsconfig.check.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true,
+  },
+  "include": ["src", "tests"]
+}

package/tsconfig.eslint.json

@@ -0,0 +1,11 @@
+// Root tsconfig for typescript-eslint
+// See: https://typescript-eslint.io/getting-started/typed-linting/monorepos#important-note-regarding-large--10-multi-package-monorepos
+// Choosing the root tsconfig approach because of: https://typescript-eslint.io/getting-started/typed-linting/monorepos#important-note-regarding-large--10-multi-package-monorepos
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    // ensure that nobody can accidentally use this config for a build
+    "noEmit": true,
+  },
+  "include": ["src", "tests"]
+}