@kronos-ts/axon-server 0.3.2 → 0.4.0

package/dist/axon-server.d.ts

@@ -1,64 +1,33 @@
 /**
- * Axon Server backend for kronos.
+ * The Axon Server command and query buses.
  *
- * `axonServer(config)` is an async factory: it connects eagerly, hands back
- * the four components it provides (eventStore, snapshotStore, commandBus,
- * queryBus), and gives you a `start`/`close` pair. There is no lifecycle
- * framework — the ordering that used to be encoded as `onStart("connect")` /
- * `onStart("processors")` / `onStop("connect")` is now three lines you write
- * in your composition root:
+ * Axon Server is a SMART HUB: outbound dispatch always goes to the server, and
+ * the server decides which node handles it — there is no client-side
+ * prefer-local fork here, which is the whole difference from the dumb-pipe
+ * broker in `@kronos-ts/rabbitmq`.
  *
- * ```ts
- * const axon = await axonServer({
- *   componentName: "university-service",
- *   serializer,
- *   unitOfWorkFactory,
- * })
- * const app = kronos({
- *   components: { ...inMemoryComponents({ serializer, unitOfWorkFactory }), ...axon.components },
- *   modules,
- * })
- * await axon.start()   // readiness barrier: the server can route to our handlers
- * // …
- * await app.stop(); await axon.close()
- * ```
- *
- * Connecting before the app is built is what removes the lazy proxies and
- * subscribe-buffering wrappers the container version needed: by the time
- * `kronos` subscribes a handler, the gRPC streams are already live.
- *
- * REMOTE ADMINISTRATION IS NOT IN HERE. Processor instructions (pause / start /
- * release / split / merge) and processor status reporting are the platform
- * CONTROL PLANE — they are neither persistence nor transport, and lived here
- * only because they share this gRPC connection. They are now an opt-in second
- * object built on the platform stream this backend exposes:
+ * Both buses are plain functions over the shared connection and YOUR local bus:
  *
  * ```ts
- * const control = await axonServerControlPlane(axon.platform, app.processors.values())
+ * const commandBus = interceptingCommandBus(
+ *   axonServerCommandBus(axon, simpleCommandBus(unitOfWork)), lineage)
+ * const queryBus = interceptingQueryBus(
+ *   axonServerQueryBus(axon, simpleQueryBus(unitOfWork)), lineage)
  * ```
  *
- * `start()` therefore takes NO arguments and does exactly one thing: the
- * data-path readiness barrier. See `control-plane.ts`.
- *
  * Axon-specific protocol invariants are preserved byte-for-byte:
  *
  *   - CLIENT_SUPPORTS_STREAMING capability advertised on every dispatched
  *     query via `defaultQueryInstructions(...)`;
  *   - AxonIQ-Context + AxonIQ-Access-Token gRPC metadata headers built by
- *     `createAxonMetadata(...)` and attached to every outbound stream/RPC;
+ *     `contextView(...)` and attached to every outbound stream/RPC;
  *   - permits-AFTER-subscriptions stream ordering preserved on the initial
  *     handshake AND on reconnect (see `ensureStreamStarted` /
- *     `reestablishStreamBody`);
- *   - shutdown ordering: busLatches → platform.stop → connection.close.
+ *     `reestablishStreamBody`).
  */
-import { type Serializer, type ResilienceConfig } from "@kronos-ts/common";
-import type { CommandBus, QueryBus, UoWRunner } from "@kronos-ts/messaging";
-import type { AxonServerConnectionConfig } from "./connection.js";
-import { type AxonServerConnection } from "./connection.js";
-import { axonServerEventStore } from "./axon-server-event-store.js";
-import { axonServerSnapshotStore } from "./axon-server-snapshot-store.js";
-import { type ShutdownLatch } from "./shutdown-latch.js";
-import { type PlatformConnection, type PlatformServiceOptions } from "./platform-service.js";
+import { type ResilienceConfig } from "@kronos-ts/core";
+import type { CommandBus, QueryBus } from "@kronos-ts/core";
+import type { AxonServerBusSource } from "./connection.js";
 /**
  * Flow control configuration for a bus channel.
  */
@@ -80,175 +49,117 @@ export interface ProcessingInstructions {
     /** Timeout in ms. Axon Server cancels the command/query if not handled in time. */
     timeoutMs?: number;
 }
-export interface AxonServerConfig extends AxonServerConnectionConfig {
-    /** Flow control for the command bus channel. */
-    commandFlowControl?: FlowControlConfig;
-    /** Flow control for the query bus channel. */
-    queryFlowControl?: FlowControlConfig;
-    /** Platform service configuration (heartbeat, etc.). */
-    platformService?: PlatformServiceOptions;
-    /**
-     * When true, queries are first checked against locally registered handlers
-     * before being dispatched through Axon Server. Avoids a network round-trip
-     * when the handler is co-located.
-     *
-     * Aligned with Java's `shortcutQueriesToLocalHandlers`.
-     * Default: false.
-     */
-    shortcutQueriesToLocalHandlers?: boolean;
+/**
+ * Tuning for {@link axonServerCommandBus}. Every field has a working default;
+ * the two arguments that carry meaning — the connection and your local bus —
+ * are positional, and this record is the trailing remainder.
+ */
+export interface AxonServerCommandBusOptions {
+    /** Axon Server context for this bus's stream. Default: the connection's. */
+    context?: string;
+    /** Flow control for the command stream. */
+    flowControl?: FlowControlConfig;
     /**
-     * Load factor for command handler registration.
-     * Signals to Axon Server how much capacity this handler has.
-     * Higher value = handler can take more commands.
-     *
+     * Load factor for this command handler. Signals to Axon Server how much
+     * capacity this node has — higher value = more commands routed here.
      * Aligned with Java's `commandLoadFactor`. Default: 100.
      */
-    commandLoadFactor?: number;
-    /**
-     * Default timeout for command dispatch in ms. Default: 300000 (5 min).
-     * Aligned with Java's processing instruction timeout.
-     */
-    commandTimeoutMs?: number;
-    /**
-     * Default timeout for query dispatch in ms. Default: 3600000 (1 hour).
-     * Aligned with Java's processing instruction timeout.
-     */
-    queryTimeoutMs?: number;
-    /** Per-extension resilience config (D-100 / D-101). */
+    loadFactor?: number;
+    /** Retry policy for stream re-establishment. Default: the connection's. */
     resilience?: Partial<ResilienceConfig>;
-    /**
-     * How long `start()` waits for Axon Server's routing tables to register the
-     * subscribe frames sent on the command/query streams. This is the entire
-     * data-path readiness barrier.
-     *
-     * It is a timed wait rather than an observed signal because nothing on the
-     * client can observe it: subscribes travel on the bus streams, and the
-     * platform stream — which is where an ack would arrive — is a different
-     * stream that Axon Server holds open silently after `register`. Default:
-     * 1000, matching the legacy enhancer. Tests against a freshly-booted server
-     * can tighten this once subscriptions are observed to land faster.
-     */
-    busSubscriptionAckDelayMs?: number;
-}
-/** The components an Axon Server backend provides. Spread into `kronos`. */
-export interface AxonServerComponents {
-    eventStore: ReturnType<typeof axonServerEventStore>;
-    snapshotStore: ReturnType<typeof axonServerSnapshotStore>;
-    commandBus: CommandBus;
-    queryBus: QueryBus;
 }
 /**
- * A live Axon Server backend: the components it provides plus the two calls
- * that used to be lifecycle stages.
+ * Tuning for {@link axonServerQueryBus}. See {@link AxonServerCommandBusOptions}.
  */
-/** Everything axonServer() needs: its own config plus the framework values it borrows. */
-export type AxonServerOptions = AxonServerConfig & {
-    serializer: Serializer;
-    unitOfWorkFactory: UoWRunner;
-};
-export interface AxonServerBackend {
-    readonly components: AxonServerComponents;
+export interface AxonServerQueryBusOptions {
+    /** Axon Server context for this bus's stream. Default: the connection's. */
+    context?: string;
+    /** Flow control for the query stream. */
+    flowControl?: FlowControlConfig;
     /**
-     * The platform stream. It is built here because the backend owns the gRPC
-     * connection it rides on and the `platformService` tuning that configures it.
-     *
-     * `start()` below brings it up for the DATA path — heartbeats and reconnect
-     * detection — via `platform.armConnectionMonitoring()`. What it deliberately
-     * does NOT do is arm processor status reporting or route instructions: that is
-     * remote administration, and it stays opt-in behind
-     * `axonServerControlPlane(axon.platform, …)`, which registers its handler and
-     * supplier and then calls `platform.start()` on this same live stream.
+     * When true, queries are first checked against locally subscribed handlers
+     * before being dispatched through Axon Server. Avoids a network round-trip
+     * when the handler is co-located.
      *
-     * An instruction that arrives before a control plane exists is buffered by the
-     * platform connection and drained on the first `onInstruction` registration,
-     * so opening the stream early costs nothing.
+     * This is NOT the rabbitmq `preferLocal` fork by another name: it is Java's
+     * `shortcutQueriesToLocalHandlers`, it is off by default, and commands have
+     * no equivalent — Axon Server routes those, always.
      */
-    readonly platform: PlatformConnection;
+    shortcutQueriesToLocalHandlers?: boolean;
     /**
-     * DATA-PATH START. Two things, both data path:
-     *
-     *   1. arm heartbeat-driven reconnect detection on the platform stream, and
-     *   2. wait until Axon Server can route to the handlers subscribed on the bus
-     *      streams.
-     *
-     * Call AFTER `kronos` — the subscribe frames must already be on the wire for
-     * the readiness wait to mean anything.
-     *
-     * Takes no arguments and arms no control-plane state.
+     * Default timeout for query dispatch in ms. Default: 3600000 (1 hour).
+     * Aligned with Java's processing instruction timeout.
      */
-    start(): Promise<void>;
-    /** Drain in-flight bus work, stop the platform stream, close the connection. */
-    close(): Promise<void>;
+    timeoutMs?: number;
+    /** Retry policy for stream re-establishment. Default: the connection's. */
+    resilience?: Partial<ResilienceConfig>;
 }
 /**
- * Connect to Axon Server and build the components it backs.
- *
- * `serializer` and `unitOfWorkFactory` are arguments rather than slot lookups:
- * the buses serialize payloads with the former and run every inbound command /
- * query in the latter, so they must be the SAME instances the rest of the app
- * uses. Pass the ones you hand to `kronos`.
- */
-export declare function axonServer(options: AxonServerOptions): Promise<AxonServerBackend>;
-/**
- * A command bus backed by Axon Server.
- *
- * - **Outbound dispatch**: Always goes through Axon Server via the unary Dispatch RPC.
- *   Axon Server routes the command to the appropriate node (which may be this one).
- * - **Local segment**: Handlers subscribed via `subscribe()` are registered with
- *   Axon Server (so other nodes can route to us) and stored locally. When Axon Server
- *   routes an inbound command to this node, it's executed on the local segment
- *   within a UnitOfWork.
- */
-/**
- * A command bus backed by Axon Server.
+ * A command bus backed by Axon Server, over YOUR local bus.
+ *
+ * - **Outbound dispatch**: ALWAYS through Axon Server, via the unary Dispatch
+ *   RPC. Axon Server routes the command to the appropriate node (which may be
+ *   this one). There is deliberately no client-side prefer-local fork: the hub
+ *   is the router, and short-circuiting it would silently defeat load factors,
+ *   priorities and routing keys.
+ * - **Inbound**: a command the server routes here is dispatched into `local` —
+ *   not into a privately-held handler map. That is what makes the unit-of-work
+ *   policy you chose for `local` (say `postgresUnitOfWork(pg, unitOfWork)`)
+ *   apply to server-routed work exactly as it applies to work this process
+ *   originated. It is also why this function takes no `unitOfWork` argument:
+ *   `local` carries that policy now.
+ * - **subscribe**: registers the handler on `local` AND announces the name to
+ *   Axon Server, so other nodes can route to us.
  *
  * ## Correlation lineage and the interceptor layer
  *
- * The returned bus is wrapped in {@link interceptingCommandBus} carrying
- * {@link correlationDataDispatchInterceptor}, so lineage is stamped onto the
- * outgoing message BEFORE it is serialized onto the wire.
+ * The returned bus stamps no lineage of its own. A host that wants it wraps the
+ * OUTERMOST bus:
+ *
+ * ```ts
+ * interceptingCommandBus(axonServerCommandBus(conn, local), lineage)
+ * ```
+ *
+ * so whatever a host adds runs BEFORE the message is serialized onto the wire.
+ * Lineage itself is usually already on `message.metadata` by then — `ctx.send`
+ * stamps the unit of work's correlation data before any bus sees the message.
  *
  * This is precisely how the Java client does it. AF4's `AxonServerCommandBus`
  * holds its own `DispatchInterceptors` and dispatches as
  * `doDispatch(dispatchInterceptors.intercept(commandMessage), cb)` — one call
- * site, at the top, ahead of any routing; and its `doDispatch` (like this one)
- * always goes to the server, letting Axon Server decide where the command lands.
- * AF5 keeps the property via decorator order:
- * `DISTRIBUTED_COMMAND_BUS_ORDER = InterceptingCommandBus.DECORATION_ORDER - 50`
+ * site, at the top, ahead of any routing. AF5 keeps the property via decorator
+ * order: `DISTRIBUTED_COMMAND_BUS_ORDER = InterceptingCommandBus.DECORATION_ORDER - 50`
  * stacks `InterceptingCommandBus → DistributedCommandBus → SimpleCommandBus`.
  *
- * Before this wrap, an Axon-backed service lost lineage on EVERY command: the
- * only registration of `correlationDataDispatchInterceptor` lives in
- * `@kronos-ts/app`'s in-memory default bus, and `components.commandBus` from
- * this backend replaces it wholesale.
- *
- * No double-application risk: the local segment here is a plain handler map, not
- * a `CommandBus`, so this is the only interceptor in the chain. Inbound commands
- * from the server are invoked through that map directly, which matches AF —
- * `CommandProcessingTask` runs the local segment WITHOUT re-running dispatch
- * interceptors.
+ * If `local` is itself an intercepting bus, a server-routed command sees
+ * `lineage` twice. That is harmless: both of its fields are `??` seeds, so the
+ * second application finds them set and changes nothing.
  */
-export declare function distributedCommandBus(connection: AxonServerConnection, unitOfWorkRunner: UoWRunner, shutdownLatch: ShutdownLatch, serializer: Serializer, flowControl?: FlowControlConfig, commandLoadFactor?: number, resilience?: Partial<ResilienceConfig>): CommandBus;
+export declare function axonServerCommandBus(conn: AxonServerBusSource, local: CommandBus, options?: AxonServerCommandBusOptions): CommandBus;
 /**
- * A query bus backed by Axon Server.
+ * A query bus backed by Axon Server, over YOUR local bus.
+ *
+ * Same architecture as {@link axonServerCommandBus}: outbound dispatch goes
+ * through Axon Server, and a query the server routes here runs through `local`,
+ * so your unit-of-work policy applies to server-routed reads too. `subscribe`
+ * registers on `local` and announces the name to the server.
  *
- * Same architecture as the distributed command bus:
- * - **Outbound dispatch**: Always through Axon Server.
- * - **Local segment**: Handlers registered here are stored locally and
- *   registered with Axon Server for inbound routing. Inbound queries
- *   are executed within a UnitOfWork.
+ * The one asymmetry with commands is `shortcutQueriesToLocalHandlers` — Java
+ * has it for queries and not for commands, and so do we. When it is on and this
+ * node subscribed the name, `query()` goes straight to `local` and the caller's
+ * unit of work is passed through, so the local branch nests exactly as the
+ * in-process bus does.
  *
- * Wrapped in {@link interceptingQueryBus} with
- * {@link correlationDataDispatchInterceptor}, matching AF4's
- * `AxonServerQueryBus`, which calls `dispatchInterceptors.intercept(...)` at the
- * top of `query`, `streamingQuery`, `scatterGather` and `subscriptionQuery`.
- * Because the wrap is outside, the `shortcutQueriesToLocalHandlers` branch in
- * `query()` gets identical lineage to the remote branch.
+ * Lineage, if wanted, is `interceptingQueryBus(bus, lineage)` at the host,
+ * matching AF4's `AxonServerQueryBus`, which calls
+ * `dispatchInterceptors.intercept(...)` at the top of `query`, `streamingQuery`,
+ * `scatterGather` and `subscriptionQuery`. Because the wrap is outside, the
+ * shortcut branch gets identical lineage to the remote branch.
  *
  * KNOWN GAP: `subscriptionQuery` / `subscribeToUpdates` build their proto
  * straight from `message.metadata`, and `interceptingQueryBus` (in
- * `@kronos-ts/messaging`) forwards those two calls to the delegate without
- * running the dispatch chain. Closing that needs a messaging-package change.
+ * `@kronos-ts/core`) forwards those two calls to the delegate without
+ * running the dispatch chain. Closing that needs a core change.
  */
-export declare function distributedQueryBus(connection: AxonServerConnection, unitOfWorkRunner: UoWRunner, shutdownLatch: ShutdownLatch, serializer: Serializer, flowControl?: FlowControlConfig, shortcutQueriesToLocalHandlers?: boolean, queryTimeoutMs?: number, resilience?: Partial<ResilienceConfig>): QueryBus;
+export declare function axonServerQueryBus(conn: AxonServerBusSource, local: QueryBus, options?: AxonServerQueryBusOptions): QueryBus;
 //# sourceMappingURL=axon-server.d.ts.map

package/dist/axon-server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"axon-server.d.ts","sourceRoot":"","sources":["../src/axon-server.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"axon-server.d.ts","sourceRoot":"","sources":["../src/axon-server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,EAML,KAAK,gBAAgB,EACtB,MAAM,iBAAiB,CAAA;AACxB,OAAO,KAAK,EACV,UAAU,EAEV,QAAQ,EAOT,MAAM,iBAAiB,CAAA;AAOxB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAgB1D;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,iFAAiF;IACjF,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,qFAAqF;IACrF,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAED;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACrC,+DAA+D;IAC/D,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,sDAAsD;IACtD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,mFAAmF;IACnF,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;;;GAIG;AACH,MAAM,WAAW,2BAA2B;IAC1C,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,2CAA2C;IAC3C,WAAW,CAAC,EAAE,iBAAiB,CAAA;IAC/B;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,2EAA2E;IAC3E,UAAU,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAA;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,yCAAyC;IACzC,WAAW,CAAC,EAAE,iBAAiB,CAAA;IAC/B;;;;;;;;OAQG;IACH,8BAA8B,CAAC,EAAE,OAAO,CAAA;IACxC;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,2EAA2E;IAC3E,UAAU,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAA;CACvC;AAyED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,mBAAmB,EACzB,KAAK,EAAE,UAAU,EACjB,OAAO,GAAE,2BAAgC,GACxC,UAAU,CAuOZ;AAMD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,mBAAmB,EACzB,KAAK,EAAE,QAAQ,EACf,OAAO,GAAE,yBAA8B,GACtC,QAAQ,CAojBV"}