@kronos-ts/axon-server 0.3.1 → 0.4.0

package/src/axon-server-event-store.ts

@@ -3,15 +3,15 @@ import {
   qualifiedNameFromString,
   type Tag,
   type Serializer,
-} from "@kronos-ts/common"
+} from "@kronos-ts/core"
 import type {
   EventCriteria,
   EventMessage,
   MessageStream,
   SequencedEvent,
   StreamingCondition,
-} from "@kronos-ts/messaging"
-import { messageStream } from "@kronos-ts/messaging"
+} from "@kronos-ts/core"
+import { messageStream, compileQuery } from "@kronos-ts/core"
 import type {
   EventStore,
   SourcingResult,
@@ -19,11 +19,12 @@ import type {
   AppendCondition,
   ConsistencyMarker,
   AppendTransaction,
-} from "@kronos-ts/eventsourcing"
-import type { TrackingToken } from "@kronos-ts/messaging"
-import { globalSequenceToken, FIRST_TOKEN } from "@kronos-ts/messaging"
-import { markerAt, noMarker } from "@kronos-ts/eventsourcing"
-import type { AxonServerConnection } from "./connection.js"
+} from "@kronos-ts/core"
+import type { TrackingToken } from "@kronos-ts/core"
+import { globalSequenceToken, FIRST_TOKEN } from "@kronos-ts/core"
+import { markerAt, noMarker } from "@kronos-ts/core"
+import type { AxonServerStoreSource } from "./connection.js"
+import { contextView } from "./context-view.js"
 import type {
   Criterion,
   TagsAndNamesCriterion,
@@ -32,7 +33,6 @@ import type {
   Event as ProtoEvent,
   SourceEventsResponse,
 } from "./generated/dcb.js"
-import { Metadata } from "nice-grpc"
 
 // ---------------------------------------------------------------------------
 // Criteria conversion — framework EventCriteria → proto Criterion[]
@@ -57,24 +57,26 @@ function tagFromProto(tag: ProtoTag): Tag {
 function criteriaToCriterions(criteria: EventCriteria): Criterion[] {
   switch (criteria.kind) {
     case "tags":
-      return [{
-        tagsAndNames: {
-          name: [],
-          tag: criteria.tags.map(tagToProto),
+      return [
+        {
+          tagsAndNames: {
+            name: [],
+            tag: criteria.tags.map(tagToProto),
+          },
         },
-      }]
+      ]
 
     case "type-restricted":
       // Inner must be tags or any-tag
-      const innerTags = criteria.inner.kind === "tags"
-        ? criteria.inner.tags.map(tagToProto)
-        : []
-      return [{
-        tagsAndNames: {
-          name: [...criteria.types],
-          tag: innerTags,
+      const innerTags = criteria.inner.kind === "tags" ? criteria.inner.tags.map(tagToProto) : []
+      return [
+        {
+          tagsAndNames: {
+            name: [...criteria.types],
+            tag: innerTags,
+          },
         },
-      }]
+      ]
 
     case "either":
       // Flatten all sub-criteria into a list of criterions (OR semantics)
@@ -111,9 +113,14 @@ function createEventConverters(serializer: Serializer) {
     },
 
     eventFromProto(protoEvent: ProtoEvent, tags: ProtoTag[]): EventMessage {
-      const payload = protoEvent.payload.length > 0
-        ? serializer.deserialize({ data: protoEvent.payload, type: protoEvent.name, revision: protoEvent.version })
-        : {}
+      const payload =
+        protoEvent.payload.length > 0
+          ? serializer.deserialize({
+              data: protoEvent.payload,
+              type: protoEvent.name,
+              revision: protoEvent.version,
+            })
+          : {}
 
       const metadata: Record<string, unknown> = {}
       for (const [k, v] of Object.entries(protoEvent.metadata)) {
@@ -139,28 +146,25 @@ function createEventConverters(serializer: Serializer) {
 // ---------------------------------------------------------------------------
 
 /**
- * Creates an EventStore implementation backed by Axon Server's DCB event store.
+ * An EventStore over Axon Server's DCB event store, in one context.
  *
  * This bridges the framework's EventStore interface to the gRPC
  * DcbEventStore service, handling conversion between framework types
  * and proto messages.
  *
+ * `context` is Axon Server's tenancy boundary and is a per-call header, so
+ * several contexts share the one channel `conn` holds — see `contextView`. The
+ * serializer is the connection's: one codec for everything this client puts on
+ * the wire.
+ *
  * The {@link open} method returns a persistent {@link MessageStream} backed by
  * a single gRPC Stream RPC call that stays open indefinitely, aligned with
  * Java's infinite {@code ResultStream}.
  */
-export function axonServerEventStore(connection: AxonServerConnection, serializer: Serializer): EventStore {
+export function axonServerEventStore(conn: AxonServerStoreSource, context: string): EventStore {
+  const { connection, serializer, metadata: createAxonMetadata } = contextView(conn, context)
   const { eventToProto, eventFromProto } = createEventConverters(serializer)
 
-  function createAxonMetadata(): Metadata {
-    const axonMetadata = new Metadata()
-    axonMetadata.set("AxonIQ-Context", connection.config.context)
-    if (connection.config.token) {
-      axonMetadata.set("AxonIQ-Access-Token", connection.config.token)
-    }
-    return axonMetadata
-  }
-
   // Push-based subscriber registry (EventBus.subscribe contract). Axon Server's
   // own distribution is the server-side Stream RPC (see open()); these in-process
   // subscribers are notified best-effort on every successful local append.
@@ -177,7 +181,7 @@ export function axonServerEventStore(connection: AxonServerConnection, serialize
 
   return {
     async source(condition: SourcingCondition): Promise<SourcingResult> {
-      const criterions = criteriaToCriterions(condition.criteria)
+      const criterions = criteriaToCriterions(compileQuery(condition.query))
 
       const request = {
         fromSequence: condition.start ?? 0n,
@@ -213,10 +217,12 @@ export function axonServerEventStore(connection: AxonServerConnection, serialize
     ): Promise<AppendTransaction> {
       const taggedEvents = newEvents.map(eventToProto)
       const request = {
-        condition: condition ? {
-          consistencyMarker: condition.marker.position,
-          criterion: criteriaToCriterions(condition.criteria),
-        } : undefined,
+        condition: condition
+          ? {
+              consistencyMarker: condition.marker.position,
+              criterion: criteriaToCriterions(compileQuery(condition.query)),
+            }
+          : undefined,
         event: taggedEvents,
       }
 
@@ -229,7 +235,9 @@ export function axonServerEventStore(connection: AxonServerConnection, serialize
           async function* requestStream() {
             yield request
           }
-          const response = await connection.eventStore.append(requestStream(), { metadata: createAxonMetadata() })
+          const response = await connection.eventStore.append(requestStream(), {
+            metadata: createAxonMetadata(),
+          })
           responseMarker = response.consistencyMarker
           await notifySubscribers(newEvents)
         },
@@ -252,7 +260,7 @@ export function axonServerEventStore(connection: AxonServerConnection, serialize
     },
 
     open(condition: StreamingCondition): MessageStream<SequencedEvent> {
-      const criterions = condition.criteria ? criteriaToCriterions(condition.criteria) : []
+      const criterions = condition.query ? criteriaToCriterions(compileQuery(condition.query)) : []
 
       const request = {
         fromSequence: condition.position,

package/src/axon-server-snapshot-store.ts

@@ -1,10 +1,8 @@
-import type { SnapshotStore, Snapshot } from "@kronos-ts/eventsourcing"
-import type { Serializer } from "@kronos-ts/common"
-import type { AxonServerConnection } from "./connection.js"
-import type {
-  Snapshot as ProtoSnapshot,
-} from "./generated/dcb.js"
-import { Metadata } from "nice-grpc"
+import type { SnapshotStore, Snapshot } from "@kronos-ts/core"
+import type { Serializer } from "@kronos-ts/core"
+import type { AxonServerStoreSource } from "./connection.js"
+import { contextView } from "./context-view.js"
+import type { Snapshot as ProtoSnapshot } from "./generated/dcb.js"
 
 // ---------------------------------------------------------------------------
 // Conversion — framework Snapshot ↔ proto Snapshot
@@ -26,9 +24,10 @@ function createSnapshotConverters(serializer: Serializer) {
     },
 
     snapshotFromProto(proto: ProtoSnapshot, position: bigint): Snapshot {
-      const payload = proto.payload.length > 0
-        ? serializer.deserialize({ data: proto.payload, type: "snapshot", revision: "" })
-        : {}
+      const payload =
+        proto.payload.length > 0
+          ? serializer.deserialize({ data: proto.payload, type: "snapshot", revision: "" })
+          : {}
 
       return {
         position,
@@ -50,27 +49,20 @@ function encodeKey(stateName: string, id: unknown): Uint8Array {
 // ---------------------------------------------------------------------------
 
 /**
- * Creates a SnapshotStore backed by Axon Server's gRPC snapshot service.
+ * A SnapshotStore over Axon Server's gRPC snapshot service, in one context.
  *
- * Uses the `DcbSnapshotStore` gRPC service to store and retrieve
- * state snapshots. Payload serialization uses the configured
- * Serializer (defaults to JSON).
+ * Uses the `DcbSnapshotStore` gRPC service to store and retrieve state
+ * snapshots. `context` is a per-call header, so this shares the one channel
+ * `conn` holds with every other context — see `contextView`. Payloads go
+ * through the connection's serializer.
  */
 export function axonServerSnapshotStore(
-  connection: AxonServerConnection,
-  serializer: Serializer,
+  conn: AxonServerStoreSource,
+  context: string,
 ): SnapshotStore {
+  const { connection, serializer, metadata: createAxonMetadata } = contextView(conn, context)
   const { snapshotToProto, snapshotFromProto } = createSnapshotConverters(serializer)
 
-  function createAxonMetadata(): Metadata {
-    const axonMetadata = new Metadata()
-    axonMetadata.set("AxonIQ-Context", connection.config.context)
-    if (connection.config.token) {
-      axonMetadata.set("AxonIQ-Access-Token", connection.config.token)
-    }
-    return axonMetadata
-  }
-
   return {
     async store(stateName: string, id: unknown, snapshot: Snapshot): Promise<void> {
       await connection.snapshotStore.add(