@kronos-ts/axon-server 0.3.2 → 0.5.0

package/dist/axon-server.d.ts

@@ -1,254 +1,138 @@
-/**
- * Axon Server backend for kronos.
- *
- * `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:
- *
- * ```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:
- *
- * ```ts
- * const control = await axonServerControlPlane(axon.platform, app.processors.values())
- * ```
- *
- * `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;
- *   - permits-AFTER-subscriptions stream ordering preserved on the initial
- *     handshake AND on reconnect (see `ensureStreamStarted` /
- *     `reestablishStreamBody`);
- *   - shutdown ordering: busLatches → platform.stop → connection.close.
- */
-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 "./resilience.js";
+import type { CommandBus, QueryBus, UnitOfWork } from "@kronos-ts/core";
+import type { AxonServerBusSource } from "./connection.js";
 /**
  * Flow control configuration for a bus channel.
  */
-export interface FlowControlConfig {
+export type FlowControlConfig = {
     /** Initial permits granted to Axon Server. Default: 5000 (aligned with Java). */
     permits?: number;
     /** Threshold at which to request more permits. Default: 2500 (aligned with Java). */
     refillThreshold?: number;
-}
+};
 /**
  * Processing instructions attached to outbound messages.
  * Controls routing, priority, and timeout behavior on Axon Server.
  */
-export interface ProcessingInstructions {
+export type ProcessingInstructions = {
     /** Routing key for consistent hashing (e.g., aggregate ID). */
     routingKey?: string;
     /** Priority (higher = processed first). Default: 0 */
     priority?: number;
     /** 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;
+};
+/**
+ * Tuning for {@link axonServerCommandBus}. Every field has a working default;
+ * the two arguments that carry meaning — the connection and your next bus —
+ * are positional, and this record is the trailing remainder.
+ */
+export type 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 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.
+     */
+    loadFactor?: number;
+    /** Retry policy for stream re-establishment. Default: the connection's. */
+    resilience?: Partial<ResilienceConfig>;
+};
+/**
+ * Tuning for {@link axonServerQueryBus}. See {@link AxonServerCommandBusOptions}.
+ */
+export type AxonServerQueryBusOptions = {
+    /** Axon Server context for this bus's stream. Default: the connection's. */
+    context?: string;
+    /** Flow control for the query stream. */
+    flowControl?: FlowControlConfig;
     /**
-     * When true, queries are first checked against locally registered handlers
+     * 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.
      *
-     * Aligned with Java's `shortcutQueriesToLocalHandlers`.
-     * Default: false.
+     * 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.
      */
     shortcutQueriesToLocalHandlers?: boolean;
-    /**
-     * Load factor for command handler registration.
-     * Signals to Axon Server how much capacity this handler has.
-     * Higher value = handler can take more commands.
-     *
-     * 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). */
+    timeoutMs?: 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.
- */
-/** 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;
-    /**
-     * 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.
-     *
-     * 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.
-     */
-    readonly platform: PlatformConnection;
-    /**
-     * 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.
-     */
-    start(): Promise<void>;
-    /** Drain in-flight bus work, stop the platform stream, close the connection. */
-    close(): Promise<void>;
-}
-/**
- * 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.
+ * A command bus backed by Axon Server, over YOUR next 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-next 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 `next` —
+ *   not into a privately-held handler map. That is what makes the unit-of-work
+ *   policy you chose for `next` (say `postgresUnitOfWork(unitOfWork, pg)`)
+ *   apply to server-routed work exactly as it applies to work this process
+ *   originated. It is also why this function takes no `unitOfWork` argument:
+ *   `next` carries that policy now.
+ * - **subscribe**: registers the handler on `next` AND announces the name to
+ *   Axon Server, so other nodes can route to us.
+ *
+ * ## correlation and the interceptor layer
+ *
+ * The returned bus stamps no correlation of its own. A host that wants it wraps the
+ * OUTERMOST bus:
  *
- * - **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.
- *
- * ## Correlation lineage and the interceptor layer
+ * ```ts
+ * interceptingCommandBus(axonServerCommandBus(next, conn), correlation)
+ * ```
  *
- * 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.
+ * so whatever a host adds runs BEFORE the message is serialized onto the wire.
+ * Correlation 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`
- * 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.
+ * 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 → LocalCommandBus`.
  *
- * 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 `next` is itself an intercepting bus, a server-routed command sees
+ * `correlation` 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<U extends UnitOfWork = UnitOfWork>(next: CommandBus<U>, conn: AxonServerBusSource, options?: AxonServerCommandBusOptions): CommandBus<U>;
 /**
- * A query bus backed by Axon Server.
+ * A query bus backed by Axon Server, over YOUR next bus.
+ *
+ * Same architecture as {@link axonServerCommandBus}: outbound dispatch goes
+ * through Axon Server, and a query the server routes here runs through `next`,
+ * so your unit-of-work policy applies to server-routed reads too. `subscribe`
+ * registers on `next` 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 `next` and the caller's
+ * unit of work is passed through, so the next 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.
+ * Correlation, if wanted, is `interceptingQueryBus(bus, correlation)` 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 correlation 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<U extends UnitOfWork = UnitOfWork>(next: QueryBus<U>, conn: AxonServerBusSource, options?: AxonServerQueryBusOptions): QueryBus<U>;
 //# 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":"AAiCA,OAAO,EAAa,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAClE,OAAO,KAAK,EACV,UAAU,EAEV,QAAQ,EAIR,UAAU,EAEX,MAAM,iBAAiB,CAAA;AAMxB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAgB1D;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,iFAAiF;IACjF,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,qFAAqF;IACrF,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,+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,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,2BAA2B,GAAG;IACxC,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,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACtC,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,CAAA;AAyED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU,EACpE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EACnB,IAAI,EAAE,mBAAmB,EACzB,OAAO,GAAE,2BAAgC,GACxC,UAAU,CAAC,CAAC,CAAC,CAsOf;AAMD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU,EAClE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EACjB,IAAI,EAAE,mBAAmB,EACzB,OAAO,GAAE,yBAA8B,GACtC,QAAQ,CAAC,CAAC,CAAC,CAmjBb"}