refactor(schema): extract public event definitions (#33579)

packages/schema/test/event-manifest.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, test } from "bun:test"
+import { FileSystem, Integration, Permission, Project, Reference, Session, Workspace } from "../src"
+import { EventManifest } from "../src/event-manifest"
+import { IdeEvent } from "../src/ide-event"
+import { SessionEvent } from "../src/session-event"
+import { SessionTodo } from "../src/session-todo"
+import { SessionV1 } from "../src/session-v1"
+import { WorkspaceEvent } from "../src/workspace-event"
+
+describe("public event manifest", () => {
+  test("owns the complete public event surface", () => {
+    expect(EventManifest.ServerDefinitions.length).toBe(55)
+    expect(EventManifest.Definitions.length).toBe(85)
+    expect(SessionV1.Event.Definitions).toEqual([
+      SessionV1.Event.Created,
+      SessionV1.Event.Updated,
+      SessionV1.Event.Deleted,
+      SessionV1.Event.MessageUpdated,
+      SessionV1.Event.MessageRemoved,
+      SessionV1.Event.PartUpdated,
+      SessionV1.Event.PartRemoved,
+      SessionV1.Event.PartDelta,
+      SessionV1.Event.Diff,
+      SessionV1.Event.Error,
+    ])
+    expect(EventManifest.Latest.size).toBe(85)
+    expect(EventManifest.Durable.size).toBe(32)
+  })
+
+  test("uses canonical definitions for current public events", () => {
+    expect(Session.Event).toBe(SessionEvent)
+    expect(Session.Event.Definitions).toBe(SessionEvent.Definitions)
+    expect(Workspace.Event).toBe(WorkspaceEvent)
+    expect(Workspace.Event.Definitions).toBe(WorkspaceEvent.Definitions)
+    expect(EventManifest.Latest.get("session.next.step.ended")).toBe(SessionEvent.Step.Ended)
+    expect(EventManifest.Latest.get("todo.updated")).toBe(SessionTodo.Event.Updated)
+    expect(EventManifest.Latest.get("project.updated")).toBe(Project.Event.Updated)
+    expect(Project.Event.Definitions).toEqual([Project.Event.Updated])
+    expect(FileSystem.Event.Definitions).toEqual([FileSystem.Event.Edited])
+    expect(Integration.Event.Definitions).toEqual([Integration.Event.Updated, Integration.Event.ConnectionUpdated])
+    expect(Permission.Event.Definitions).toEqual([Permission.Event.Asked, Permission.Event.Replied])
+    expect(Reference.Event.Definitions).toEqual([Reference.Event.Updated])
+    expect(EventManifest.Latest.has("ide.installed")).toBe(false)
+    expect(IdeEvent.Definitions).toEqual([IdeEvent.Installed])
+    expect(EventManifest.Definitions.slice(40, 43)).toEqual([
+      SessionV1.Event.PartDelta,
+      SessionV1.Event.Diff,
+      SessionV1.Event.Error,
+    ])
+    expect(EventManifest.Durable.has("session.next.step.ended.1")).toBe(false)
+    expect(EventManifest.Durable.get("session.next.step.ended.2")).toBe(SessionEvent.Step.Ended)
+  })
+})

packages/schema/test/event.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test"
+import { Schema } from "effect"
+import { Event } from "../src/event"
+
+describe("public event schemas", () => {
+  test("definition is pure", () => {
+    const definitions = Event.inventory()
+    Event.define({ type: "test.pure", schema: { value: Schema.String } })
+    expect(definitions).toEqual([])
+  })
+
+  test("latest selection is independent of declaration order", () => {
+    const historical = Event.define({
+      type: "test.versioned",
+      durable: { aggregate: "id", version: 1 },
+      schema: { id: Schema.String },
+    })
+    const current = Event.define({
+      type: "test.versioned",
+      durable: { aggregate: "id", version: 2 },
+      schema: { id: Schema.String, value: Schema.String },
+    })
+
+    expect(Event.latest([historical, current]).get(current.type)).toBe(current)
+    expect(Event.latest([current, historical]).get(current.type)).toBe(current)
+  })
+
+  test("durable definitions are indexed by type and version", () => {
+    const definition = Event.define({
+      type: "test.durable",
+      durable: { aggregate: "id", version: 1 },
+      schema: { id: Schema.String },
+    })
+
+    expect(Event.durable([definition]).get("test.durable.1")).toBe(definition)
+  })
+})

packages/schema/test/legacy-event.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, test } from "bun:test"
+import { LegacyEvent } from "../src/legacy-event"
+import { PermissionV1 } from "../src/permission-v1"
+import { QuestionV1 } from "../src/question-v1"
+import { Project } from "../src/project"
+import { SessionV1 } from "../src/session-v1"
+
+describe("legacy public event schemas", () => {
+  test("owns all SessionV1 definitions", () => {
+    expect(SessionV1.Event.Definitions.map((event) => event.type)).toEqual([
+      "session.created",
+      "session.updated",
+      "session.deleted",
+      "message.updated",
+      "message.removed",
+      "message.part.updated",
+      "message.part.removed",
+      "message.part.delta",
+      "session.diff",
+      "session.error",
+    ])
+    const durable = SessionV1.Event.Definitions.filter((event) => event.durable !== undefined)
+    expect(durable).toHaveLength(7)
+    expect(durable.every((event) => event.durable?.aggregate === "sessionID")).toBe(true)
+    expect(durable.every((event) => event.durable?.version === 1)).toBe(true)
+  })
+
+  test("owns the legacy transient public definitions", () => {
+    expect([
+      SessionV1.PartDelta.type,
+      SessionV1.Diff.type,
+      SessionV1.Error.type,
+      PermissionV1.Event.Asked.type,
+      PermissionV1.Event.Replied.type,
+      QuestionV1.Event.Asked.type,
+      QuestionV1.Event.Replied.type,
+      QuestionV1.Event.Rejected.type,
+      Project.Event.Updated.type,
+      LegacyEvent.CommandExecuted.type,
+    ]).toEqual([
+      "message.part.delta",
+      "session.diff",
+      "session.error",
+      "permission.asked",
+      "permission.replied",
+      "question.asked",
+      "question.replied",
+      "question.rejected",
+      "project.updated",
+      "command.executed",
+    ])
+  })
+})