@echovisionlab/geul-event 0.1.0

package/src/campaign-create-target-contract.test.ts

@@ -0,0 +1,36 @@
+import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
+import { describe, expect, it } from "vitest";
+import { CreateCampaignRequestSchema } from "@echovisionlab/geul-proto/secure/campaign_pb.ts";
+
+describe("CreateCampaignRequest target wire contract", () => {
+  it.each([
+    {
+      name: "all recipients",
+      target: { case: "all" as const, value: {} },
+    },
+    {
+      name: "one exact audience segment",
+      target: { case: "segmentId" as const, value: "segment-1" },
+    },
+  ])("round-trips the explicit $name target", ({ target }) => {
+    const request = create(CreateCampaignRequestSchema, {
+      subject: "Subject",
+      name: "Campaign",
+      target,
+    });
+    const decoded = fromBinary(
+      CreateCampaignRequestSchema,
+      toBinary(CreateCampaignRequestSchema, request),
+    );
+
+    expect(decoded.target.case).toBe(target.case);
+    if (target.case === "all") {
+      expect(decoded.target).toMatchObject({
+        case: "all",
+        value: { $typeName: "google.protobuf.Empty" },
+      });
+    } else {
+      expect(decoded.target).toEqual(target);
+    }
+  });
+});

package/src/collaboration-locale-value-changes.test.ts

@@ -0,0 +1,51 @@
+import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
+import { describe, expect, it } from "vitest";
+import {
+  AIDocumentFieldPathSegmentSchema,
+  AIDocumentFieldTargetSchema,
+} from "@echovisionlab/geul-proto/secure/ai_pb.ts";
+import { ApplyPageBlockBatchRequestSchema } from "@echovisionlab/geul-proto/intra/page_pb.ts";
+
+function fieldPath(fieldHandle: string) {
+  return create(AIDocumentFieldPathSegmentSchema, {
+    selector: { case: "fieldHandle", value: fieldHandle },
+  });
+}
+
+function itemPath(itemHandle: string) {
+  return create(AIDocumentFieldPathSegmentSchema, {
+    selector: { case: "itemHandle", value: itemHandle },
+  });
+}
+
+describe("resident collaboration affected locale values", () => {
+  it("round-trips explicit-empty and exact table-cell leaf targets", () => {
+    const explicitEmpty = create(AIDocumentFieldTargetSchema, {
+      owner: { case: "blockHandle", value: "paragraph-1" },
+      fieldHandle: "content",
+    });
+    const tableCell = create(AIDocumentFieldTargetSchema, {
+      owner: { case: "blockHandle", value: "table-1" },
+      fieldHandle: "tableContent",
+      path: [
+        fieldPath("rows"),
+        itemPath("row-1"),
+        fieldPath("cells"),
+        itemPath("cell-1"),
+        fieldPath("content"),
+      ],
+    });
+    const request = create(ApplyPageBlockBatchRequestSchema, {
+      pageId: "page-1",
+      locale: "en",
+      affectedLocaleValues: [explicitEmpty, tableCell],
+    });
+
+    const decoded = fromBinary(
+      ApplyPageBlockBatchRequestSchema,
+      toBinary(ApplyPageBlockBatchRequestSchema, request),
+    );
+
+    expect(decoded.affectedLocaleValues).toEqual([explicitEmpty, tableCell]);
+  });
+});

package/src/content-entity-type.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from "vitest";
+import { AIDocumentDomain } from "@echovisionlab/geul-proto/secure/ai_pb.ts";
+import { ContentEntityType } from "@echovisionlab/geul-proto/secure/events_pb.ts";
+
+describe("ContentEntityType interactive document parity", () => {
+  it("covers every registered AI document domain with one exact typed value", () => {
+    const pairs = [
+      [AIDocumentDomain.AI_DOCUMENT_DOMAIN_POST, ContentEntityType.POST],
+      [AIDocumentDomain.AI_DOCUMENT_DOMAIN_PAGE, ContentEntityType.PAGE],
+      [AIDocumentDomain.AI_DOCUMENT_DOMAIN_WORK, ContentEntityType.WORK],
+      [
+        AIDocumentDomain.AI_DOCUMENT_DOMAIN_PROGRAM_EVENT,
+        ContentEntityType.PROGRAM_EVENT,
+      ],
+      [AIDocumentDomain.AI_DOCUMENT_DOMAIN_RELEASE, ContentEntityType.RELEASE],
+      [AIDocumentDomain.AI_DOCUMENT_DOMAIN_ARTIST, ContentEntityType.ARTIST],
+      [AIDocumentDomain.AI_DOCUMENT_DOMAIN_LABEL, ContentEntityType.LABEL],
+      [AIDocumentDomain.AI_DOCUMENT_DOMAIN_MENU, ContentEntityType.MENU],
+      [
+        AIDocumentDomain.AI_DOCUMENT_DOMAIN_EMAIL_TEMPLATE,
+        ContentEntityType.EMAIL_TEMPLATE,
+      ],
+      [
+        AIDocumentDomain.AI_DOCUMENT_DOMAIN_EMAIL_LAYOUT,
+        ContentEntityType.EMAIL_LAYOUT,
+      ],
+      [
+        AIDocumentDomain.AI_DOCUMENT_DOMAIN_CAMPAIGN,
+        ContentEntityType.CAMPAIGN,
+      ],
+      [AIDocumentDomain.AI_DOCUMENT_DOMAIN_FORM, ContentEntityType.FORM],
+      [AIDocumentDomain.AI_DOCUMENT_DOMAIN_PRIVACY, ContentEntityType.PRIVACY],
+      [AIDocumentDomain.AI_DOCUMENT_DOMAIN_TERMS, ContentEntityType.TERMS],
+      [
+        AIDocumentDomain.AI_DOCUMENT_DOMAIN_POST_SERIES,
+        ContentEntityType.POST_SERIES,
+      ],
+    ] as const;
+
+    expect(new Set(pairs.map(([domain]) => domain)).size).toBe(15);
+    expect(new Set(pairs.map(([, content]) => content)).size).toBe(15);
+    expect(
+      Object.values(AIDocumentDomain).filter(
+        (value): value is number =>
+          typeof value === "number" &&
+          value !== AIDocumentDomain.AI_DOCUMENT_DOMAIN_UNSPECIFIED,
+      ),
+    ).toHaveLength(15);
+    expect(
+      Object.values(ContentEntityType).filter(
+        (value): value is number =>
+          typeof value === "number" && value !== ContentEntityType.UNSPECIFIED,
+      ),
+    ).toHaveLength(15);
+  });
+
+  it("preserves existing numbers and allocates the six additive values", () => {
+    expect(ContentEntityType.POST).toBe(1);
+    expect(ContentEntityType.PAGE).toBe(2);
+    expect(ContentEntityType.WORK).toBe(3);
+    expect(ContentEntityType.ARTIST).toBe(4);
+    expect(ContentEntityType.LABEL).toBe(5);
+    expect(ContentEntityType.RELEASE).toBe(6);
+    expect(ContentEntityType.FORM).toBe(7);
+    expect(ContentEntityType.PROGRAM_EVENT).toBe(8);
+    expect(ContentEntityType.POST_SERIES).toBe(9);
+    expect(ContentEntityType.MENU).toBe(10);
+    expect(ContentEntityType.EMAIL_TEMPLATE).toBe(11);
+    expect(ContentEntityType.EMAIL_LAYOUT).toBe(12);
+    expect(ContentEntityType.CAMPAIGN).toBe(13);
+    expect(ContentEntityType.PRIVACY).toBe(14);
+    expect(ContentEntityType.TERMS).toBe(15);
+  });
+});

package/src/event-model.test.ts

@@ -0,0 +1,125 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { parse } from "yaml";
+import { describe, expect, it } from "vitest";
+import { Queues } from "./index.ts";
+
+type AsyncAPIChannel = {
+  address?: string;
+  messages?: Record<string, { $ref?: string }>;
+  "x-channel-kind"?: "durable_queue" | "signal";
+  "x-signal-types"?: string[];
+};
+
+const spec = parse(
+  readFileSync(resolve(process.cwd(), "asyncapi/asyncapi.yaml"), "utf8"),
+) as {
+  channels: Record<string, AsyncAPIChannel>;
+  components: { messages: Record<string, unknown> };
+};
+
+describe("durable asynchronous event model", () => {
+  it("exports the authoritative result and projection queues", () => {
+    expect(Queues).toMatchObject({
+      transcodeResult: "transcode.result",
+      waveformResult: "waveform.result",
+      meshOptimizationResult: "mesh.optimization.result",
+      releaseTrackOriginalAudioProjection:
+        "release.track_original_audio.projection",
+      emailCampaign: "email.campaign",
+      userDeleteIdentity: "user.delete.identity",
+      userDeleteAvatar: "user.delete.avatar",
+    });
+
+    for (const [channelName, expected] of Object.entries({
+      transcodeResult: {
+        queueName: "transcode.result",
+        messageName: "transcodeCompleteEvent",
+        messageRef: "#/components/messages/TranscodeCompleteEvent",
+      },
+      waveformResult: {
+        queueName: "waveform.result",
+        messageName: "waveformResultEvent",
+        messageRef: "#/components/messages/WaveformResultEvent",
+      },
+      meshOptimizationResult: {
+        queueName: "mesh.optimization.result",
+        messageName: "meshOptimizationResultEvent",
+        messageRef: "#/components/messages/MeshOptimizationResultEvent",
+      },
+      releaseTrackOriginalAudioProjection: {
+        queueName: "release.track_original_audio.projection",
+        messageName: "fileIngestAttachedEvent",
+        messageRef: "#/components/messages/FileIngestAttachedEvent",
+      },
+      emailCampaign: {
+        queueName: "email.campaign",
+        messageName: "sendBulkEmailBatchEvent",
+        messageRef: "#/components/messages/SendBulkEmailBatchEvent",
+      },
+      userDeleteIdentity: {
+        queueName: "user.delete.identity",
+        messageName: "userDeleteIdentityCommand",
+        messageRef: "#/components/messages/UserDeleteIdentityCommand",
+      },
+      userDeleteAvatar: {
+        queueName: "user.delete.avatar",
+        messageName: "userDeleteAvatarCommand",
+        messageRef: "#/components/messages/UserDeleteAvatarCommand",
+      },
+    })) {
+      const channel = spec.channels[channelName];
+      expect(channel?.address).toBe(expected.queueName);
+      expect(channel?.messages).toEqual({
+        [expected.messageName]: { $ref: expected.messageRef },
+      });
+      expect(channel?.["x-channel-kind"]).toBe("durable_queue");
+    }
+  });
+
+  it("keeps file-ingest signals reconstructable and projection work durable", () => {
+    expect(spec.channels.releaseTrackOriginalAudioProjection).toMatchObject({
+      "x-channel-kind": "durable_queue",
+    });
+    expect(spec.channels.fileIngest).toMatchObject({
+      "x-channel-kind": "signal",
+      "x-signal-types": [
+        "upload",
+        "download",
+        "finalized",
+        "attached",
+        "failed",
+      ],
+    });
+  });
+
+  it("keeps the retired generic render queues and messages absent", () => {
+    for (const queue of [
+      "post.render",
+      "work.render",
+      "program_event.render",
+      "privacy.render",
+      "terms.render",
+    ]) {
+      expect(Object.values(Queues)).not.toContain(queue);
+    }
+    for (const channel of [
+      "postRender",
+      "workRender",
+      "programEventRender",
+      "privacyRender",
+      "termsRender",
+    ]) {
+      expect(Object.keys(spec.channels)).not.toContain(channel);
+    }
+    for (const message of [
+      "PostRenderRequest",
+      "WorkRenderRequest",
+      "ProgramEventRenderRequest",
+      "PrivacyRenderRequest",
+      "TermsRenderRequest",
+    ]) {
+      expect(Object.keys(spec.components.messages)).not.toContain(message);
+    }
+  });
+});

package/src/form-locale-catalog.test.ts

@@ -0,0 +1,67 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import {
+  assertFormLocaleStableID,
+  formFieldBlockHandle,
+  formFieldCheckboxLabelTarget,
+  formOptionBlockHandle,
+  formOptionLabelTarget,
+  formRootBlockHandle,
+  formRootTitleTarget,
+  formStepBlockHandle,
+  formStepDescriptionTarget,
+  formValidatorBlockHandle,
+  formValidatorMessageTarget,
+} from "@echovisionlab/geul-proto/intra/form_locale_catalog.ts";
+
+interface FormLocaleParityFixture {
+  readonly valid: Record<string, string>;
+  readonly ids: Record<string, string>;
+  readonly invalidIds: readonly string[];
+}
+
+const fixture = JSON.parse(
+  readFileSync(
+    new URL(
+      "../../proto/gen/api/intra/v1/form_locale_catalog_parity.json",
+      import.meta.url,
+    ),
+    "utf8",
+  ),
+) as FormLocaleParityFixture;
+
+describe("generated Form locale catalog", () => {
+  it("matches the shared cross-language block-handle fixtures", () => {
+    expect({
+      root: formRootBlockHandle,
+      step: formStepBlockHandle(fixture.ids.step),
+      field: formFieldBlockHandle(fixture.ids.field),
+      option: formOptionBlockHandle(fixture.ids.option),
+      validator: formValidatorBlockHandle(fixture.ids.validator),
+    }).toEqual(fixture.valid);
+  });
+
+  it("rejects non-canonical and all-digit stable IDs", () => {
+    for (const id of fixture.invalidIds) {
+      expect(() => assertFormLocaleStableID(id)).toThrow();
+    }
+  });
+
+  it("constructs only block-owned leaf targets without paths", () => {
+    const targets = [
+      formRootTitleTarget(),
+      formStepDescriptionTarget(fixture.ids.step),
+      formFieldCheckboxLabelTarget(fixture.ids.field),
+      formOptionLabelTarget(fixture.ids.option),
+      formValidatorMessageTarget(fixture.ids.validator),
+    ];
+    for (const target of targets) {
+      expect(target.owner.case).toBe("blockHandle");
+      expect(target.owner.value).toMatch(
+        /^(document|form:(step|field|option|validator):)/,
+      );
+      expect(target.fieldHandle).not.toBe("");
+      expect(target.path).toEqual([]);
+    }
+  });
+});

package/src/generated.ts

@@ -0,0 +1,59 @@
+// Code generated by AsyncAPI. DO NOT EDIT.
+// Source: asyncapi/asyncapi.yaml
+
+/**
+ * PostgreSQL NOTIFY names for reconstructable realtime signals
+ */
+export const Signals = {
+  transcodeProgress: "transcode.progress",
+  transcodeCancel: "transcode.cancel",
+  waveformProgress: "waveform.progress",
+  waveformCancel: "waveform.cancel",
+  meshOptimizationProgress: "mesh.optimization.progress",
+  mediaProcessingLifecycle: "media.processing.lifecycle",
+  ogLifecycle: "og.lifecycle",
+  mailAdapterChanged: "mail_adapter.changed",
+  contentUpdated: "content.updated",
+  fileIngest: "file.ingest",
+  translationLifecycle: "translation.lifecycle",
+} as const;
+
+/**
+ * Queue names for direct work and durable consumer queues
+ */
+export const Queues = {
+  ogGenerate: "og.generate",
+  transcoderAudio: "transcoder.audio",
+  transcoderVideo: "transcoder.video",
+  waveformGenerate: "waveform.generate",
+  assetOptimizerMesh: "asset_optimizer.mesh",
+  fileDelete: "file.delete",
+  emailSend: "email.send",
+  emailAuth: "email.auth",
+  emailCampaign: "email.campaign",
+  userDeleteIdentity: "user.delete.identity",
+  userDeleteAvatar: "user.delete.avatar",
+  aiMetadataGenerate: "ai.metadata.generate",
+  translationGenerate: "translation.generate",
+  transcodeResult: "transcode.result",
+  waveformResult: "waveform.result",
+  meshOptimizationResult: "mesh.optimization.result",
+  releaseTrackOriginalAudioProjection:
+    "release.track_original_audio.projection",
+} as const;
+
+export const FileIngestSignalTypes = {
+  upload: "upload",
+  download: "download",
+  finalized: "finalized",
+  attached: "attached",
+  failed: "failed",
+} as const;
+
+/**
+ * Content type constants
+ */
+export const ContentType = {
+  protobuf: "application/x-protobuf",
+  json: "application/json",
+} as const;

package/src/index.ts

@@ -0,0 +1,86 @@
+export {
+  ContentType,
+  FileIngestSignalTypes,
+  Queues,
+  Signals,
+} from "./generated.ts";
+
+export {
+  assertPgmqEnvelope,
+  createPgmqEnvelope,
+  pgmqEnvelopePayload,
+  PGMQ_ENVELOPE_SCHEMA_VERSION,
+  PgmqClient,
+} from "./pgmq.ts";
+export type {
+  PgmqEnvelope,
+  PgmqExecutor,
+  PgmqHeaders,
+  PgmqMessage,
+} from "./pgmq.ts";
+
+export { assertRelayInteractiveAIDocumentMutationRequest } from "./interactive-mutation.ts";
+
+export {
+  InternalOgService,
+  OgGenerationClaimResult,
+} from "@echovisionlab/geul-proto/intra/og_pb.ts";
+export type {
+  ClaimOgGenerationRequest,
+  ClaimOgGenerationResponse,
+  CompleteOgGenerationRequest,
+  CompleteOgGenerationResponse,
+  FailOgGenerationRequest,
+  FailOgGenerationResponse,
+  OgRenderConfigSnapshot,
+} from "@echovisionlab/geul-proto/intra/og_pb.ts";
+
+export {
+  AssetDisposition,
+  deserializeProto,
+  FileIngestAttachedEventSchema,
+  FileIngestDownloadEventSchema,
+  FileIngestFailedEventSchema,
+  FileIngestFailureReason,
+  FileIngestFinalizedEventSchema,
+  FileIngestIdentitySchema,
+  FileIngestMediaKind,
+  FileIngestSource,
+  FileIngestUploadEventSchema,
+  MediaProcessingLifecycleEventSchema,
+  MediaProcessingStatus,
+  MeshOptimizationResultEventSchema,
+  OgEntityType,
+  OgGenerationJobSchema,
+  OgGenerationLifecycleEventSchema,
+  OgGenerationStatus,
+  OgGenerationTargetSchema,
+  TranscodeCompleteEventSchema,
+  TranscodeEntityType,
+  TranslationLifecycleEventSchema,
+  WaveformResultEventSchema,
+} from "./proto-helpers.ts";
+
+export { assertTranslationJobRequestArtifact } from "./translation-source.ts";
+
+export type {
+  AssetRef,
+  AssetWriteResult,
+  AssetWriteTarget,
+  FileIngestAttachedEvent,
+  FileIngestDownloadEvent,
+  FileIngestFailedEvent,
+  FileIngestFinalizedEvent,
+  FileIngestIdentity,
+  FileIngestProgress,
+  FileIngestUploadEvent,
+  MediaProcessingLifecycleEvent,
+  MediaProcessingLifecycleOutputs,
+  MeshOptimizationResultEvent,
+  OgGenerationJob,
+  OgGenerationLifecycleEvent,
+  OgGenerationTarget,
+  TranscodeCompleteEvent,
+  TranslationLifecycleEvent,
+  WaveformResultEvent,
+} from "./proto-helpers.ts";