@btravstack/amqp-worker 0.8.0 → 0.10.0

package/README.md

@@ -13,7 +13,7 @@
 
 ```sh
 pnpm add @btravstack/amqp-worker @btravstack/core @btravstack/config @btravstack/di unthrown \
-  @amqp-contract/worker @opentelemetry/api
+  @amqp-contract/worker@^3.0.0-beta.7 @opentelemetry/api
 ```
 
 All six are peer dependencies — install them (`@opentelemetry/api` because
@@ -50,37 +50,35 @@ import { ErrAsync, OkAsync, P } from "unthrown";
 // built by di from the use cases it lists — no injected context — on the
 // starter's own handlers port, typed by the contract (a consumer serves one
 // handlers record, so there is nothing to name).
-const orderHandlers = AmqpHandlers(orderContract)(
-  { placeOrder: PlaceOrder },
-  {
-    sync: ({ placeOrder }) => ({
-      orderNotifications: (message) =>
-        placeOrder
-          .execute(
-            TenantId(message.payload.tenantId),
-            message.payload.id,
-            message.payload.payload?.quantity ?? 0,
-          )
-          .map(() => undefined)
-          // A modeled domain error is permanent: dead-letter it, no retry.
-          .mapErrCases((matcher) =>
-            matcher.with(
-              P.tag("InvalidQuantity"),
-              P.tag("InvalidOrderId"),
-              P.tag("DuplicateOrder"),
-              (error) => new NonRetryableError(error._tag, error),
-            ),
-          )
-          // Infrastructure failing is not: recover the defect into a retry.
-          .recoverDefect((cause) =>
-            ErrAsync(new RetryableError("placing the order failed", cause)),
+const orderHandlers = AmqpHandlers(orderContract)({
+  inject: { placeOrder: PlaceOrder },
+  sync: ({ placeOrder }) => ({
+    orderNotifications: ({ input: message }) =>
+      placeOrder
+        .execute(
+          TenantId(message.payload.tenantId),
+          message.payload.id,
+          message.payload.payload?.quantity ?? 0,
+        )
+        .map(() => undefined)
+        // A modeled domain error is permanent: dead-letter it, no retry.
+        .mapErrCases((matcher) =>
+          matcher.with(
+            P.tag("InvalidQuantity"),
+            P.tag("InvalidOrderId"),
+            P.tag("DuplicateOrder"),
+            (error) => new NonRetryableError(error._tag, error),
           ),
-      // Every consumer the contract declares must be covered — an uncovered
-      // key is refused at this call, not on the first delivery.
-      orderAudit: () => OkAsync(undefined),
-    }),
-  },
-);
+        )
+        // Infrastructure failing is not: recover the defect into a retry.
+        .recoverDefect((cause) =>
+          ErrAsync(new RetryableError("placing the order failed", cause)),
+        ),
+    // Every consumer the contract declares must be covered — an uncovered
+    // key is refused at this call, not on the first delivery.
+    orderAudit: () => OkAsync(undefined),
+  }),
+});
 
 const Worker = AmqpModule("Worker")({
   needs: [Env],
@@ -99,7 +97,7 @@ call, not on the first delivery. `runtimeInfo()` reads `{ queues }` back once
 consuming.
 
 A worker with several consumers can be several slices instead of one record:
-`AmqpHandler(contract, key)({ name: Dep }, arm)` mints a provider for ONE consumer or
+`AmqpHandler(contract, key)({ inject: { name: Dep }, ...arm })` mints a provider for ONE consumer or
 rpc, typed by the key alone, and `AmqpHandlers(contract)([...])` composes an
 array of them into the same handlers provider `AmqpModule` takes — the array
 must cover every key the contract declares, and each piece's own port must
@@ -108,6 +106,10 @@ pieces' ports, not what they close over. Two slices claiming one key are di's
 duplicate-provider defect at build, which is the point: a consumer belongs to
 exactly one slice.
 
+Its own test suite needs a **Docker daemon**: the specs run against the shared
+`rabbitmq` container `internal/test-infra` starts once per machine and every
+workspace reuses. Nothing else here does.
+
 ## Options
 
 `AmqpModule(name)({...})` takes `amqp()`'s options plus `handlers` and the

package/dist/index.cjs

@@ -34,7 +34,17 @@ const AmqpHandler = (contract, key) => {
 * handler that must stop when the kernel stops waiting reads
 * `currentUnit()?.signal`.
 */
-const messageUnits = (host) => (args, next) => host.run(metaFor(args.rawMessage), () => next());
+const messageUnits = (host, observers) => (args, next) => {
+	const settle = (0, _btravstack_core.observe)(observers, {
+		component: "amqp",
+		name: "delivery",
+		attributes: { handler: args.handlerName }
+	});
+	return host.run(metaFor(args.rawMessage), () => next()).tap(() => settle({ outcome: "ok" })).tapFailure((failure) => settle({
+		outcome: "error",
+		cause: failure.tag === "Err" ? failure.error : failure.cause
+	}));
+};
 /**
 * `UnitMeta.id` must be unique per unit, and a **delivery tag is not one**: tags
 * are per-channel and restart at `1` after a reconnect, which
@@ -115,27 +125,38 @@ const amqp = (options) => {
 	}));
 	return (0, _btravstack_di.Module)("Amqp")({
 		needs: [_btravstack_config.Env, AmqpHandlersPort],
-		provides: [config, (0, _btravstack_di.Provider)(AmqpRuntime)({
-			config: AmqpConfig,
-			handlers: AmqpHandlersPort
-		}, { sync: ({ config: bound, handlers }) => ({
-			name: "amqp",
-			resolves: [],
-			start: (host) => createWorker(host, bound, options, handlers)
-		}) })],
+		provides: [
+			config,
+			_btravstack_di.Provider.member(_btravstack_core.Observers)({
+				inject: {},
+				value: _btravstack_core.noObserver
+			}),
+			(0, _btravstack_di.Provider)(AmqpRuntime)({
+				inject: {
+					config: AmqpConfig,
+					handlers: AmqpHandlersPort,
+					observers: _btravstack_core.Observers
+				},
+				sync: ({ config: bound, handlers, observers }) => ({
+					name: "amqp",
+					resolves: [],
+					start: (host) => createWorker(host, bound, options, handlers, observers)
+				})
+			})
+		],
 		exports: [AmqpRuntime, AmqpConfig]
 	});
 };
 /**
-* The handlers as a provider, from the contract. Three call forms, one port.
+* The handlers as a provider, from the contract. Two call forms, one port.
 *
 * ```ts
-* AmqpHandlers(orderContract)({ logger: Logger }, { sync: ({ logger }) => ({ orderNotifications: (m) => … }) })
+* AmqpHandlers(orderContract)({ inject: { logger: Logger }, sync: ({ logger }) => ({ orderNotifications: (m) => … }) })
 * AmqpHandlers(orderContract)([orderNotifications, orderAudit])
 * ```
 *
-* The first two are di's own `Provider(port)` on the starter's handlers port
-* typed for the contract. The third takes the pieces `AmqpHandler(contract,
+* The first is di's own `Provider(port)` on the starter's handlers port
+* typed for the contract. The second takes the pieces `AmqpHandler(contract,
 * key)` builds: they are the provider's deps, keyed by the contract key each
 * piece's port id carries, so the services record IS the handlers record. Every
 * declared key must be covered, and two slices claiming one key are di's
@@ -143,8 +164,11 @@ const amqp = (options) => {
 */
 const AmqpHandlers = (contract) => {
 	const build = (0, _btravstack_di.Provider)(AmqpHandlersPort);
-	const compose = (pieces) => build(Object.fromEntries(pieces.map((piece) => [piece.port.portId.slice(12), piece.port])), { sync: (services) => services });
-	return ((first, second) => second === void 0 && Array.isArray(first) ? compose(first) : build(first, second));
+	const compose = (pieces) => build({
+		inject: Object.fromEntries(pieces.map((piece) => [piece.port.portId.slice(12), piece.port])),
+		sync: (services) => services
+	});
+	return ((first) => Array.isArray(first) ? compose(first) : build(first));
 };
 const startFailed = (cause) => new _btravstack_core.RuntimeStartFailed({
 	runtime: "amqp",
@@ -159,15 +183,15 @@ const queuesOf = (contract) => [...new Set(Object.values({
 	...contract.consumers,
 	...contract.rpcs
 }).map((entry) => entry.queue.name))].sort();
-const createWorker = (host, config, options, handlers) => _amqp_contract_worker.TypedAmqpWorker.create({
+const createWorker = (host, config, options, handlers, observers) => _amqp_contract_worker.TypedAmqpWorker.create({
 	contract: options.contract,
 	handlers,
-	middleware: messageUnits(host),
+	middleware: messageUnits(host, observers),
 	urls: [config.url],
 	...options.connectionOptions === void 0 ? {} : { connectionOptions: options.connectionOptions },
 	...options.defaultConsumerOptions === void 0 ? {} : { defaultConsumerOptions: options.defaultConsumerOptions },
 	connectTimeoutMs: config.connectTimeoutMs
-}).map((worker) => consume(worker, queuesOf(options.contract))).recoverDefect((cause) => (0, unthrown.ErrAsync)(startFailed(cause)));
+}).map((worker) => consume(worker, queuesOf(options.contract))).mapErrCases((matcher) => matcher.with(unthrown.P.tag("@amqp-contract/ConnectionError"), (error) => startFailed(error)));
 const consume = (worker, queues) => {
 	let closing;
 	const beginClose = () => closing ??= worker.close({ drainTimeoutMs: null });

package/dist/index.d.cts

@@ -123,15 +123,15 @@ type Compose<C extends AnyAmqpContract> = <const T extends readonly PieceOf<C>[]
   readonly port: HandlersPortOf<C>;
 };
 /**
- * The handlers as a provider, from the contract. Three call forms, one port.
+ * The handlers as a provider, from the contract. Two call forms, one port.
  *
  * ```ts
- * AmqpHandlers(orderContract)({ logger: Logger }, { sync: ({ logger }) => ({ orderNotifications: (m) => … }) })
+ * AmqpHandlers(orderContract)({ inject: { logger: Logger }, sync: ({ logger }) => ({ orderNotifications: (m) => … }) })
  * AmqpHandlers(orderContract)([orderNotifications, orderAudit])
  * ```
  *
- * The first two are di's own `Provider(port)` on the starter's handlers port
- * typed for the contract. The third takes the pieces `AmqpHandler(contract,
+ * The first is di's own `Provider(port)` on the starter's handlers port
+ * typed for the contract. The second takes the pieces `AmqpHandler(contract,
  * key)` builds: they are the provider's deps, keyed by the contract key each
  * piece's port id carries, so the services record IS the handlers record. Every
  * declared key must be covered, and two slices claiming one key are di's

package/dist/index.d.mts

@@ -123,15 +123,15 @@ type Compose<C extends AnyAmqpContract> = <const T extends readonly PieceOf<C>[]
   readonly port: HandlersPortOf<C>;
 };
 /**
- * The handlers as a provider, from the contract. Three call forms, one port.
+ * The handlers as a provider, from the contract. Two call forms, one port.
  *
  * ```ts
- * AmqpHandlers(orderContract)({ logger: Logger }, { sync: ({ logger }) => ({ orderNotifications: (m) => … }) })
+ * AmqpHandlers(orderContract)({ inject: { logger: Logger }, sync: ({ logger }) => ({ orderNotifications: (m) => … }) })
  * AmqpHandlers(orderContract)([orderNotifications, orderAudit])
  * ```
  *
- * The first two are di's own `Provider(port)` on the starter's handlers port
- * typed for the contract. The third takes the pieces `AmqpHandler(contract,
+ * The first is di's own `Provider(port)` on the starter's handlers port
+ * typed for the contract. The second takes the pieces `AmqpHandler(contract,
  * key)` builds: they are the provider's deps, keyed by the contract key each
  * piece's port id carries, so the services record IS the handlers record. Every
  * declared key must be covered, and two slices claiming one key are di's

package/dist/index.mjs

@@ -1,8 +1,8 @@
 import { Module, Port, Provider } from "@btravstack/di";
 import { TypedAmqpWorker } from "@amqp-contract/worker";
 import { Config, Env } from "@btravstack/config";
-import { RuntimePort, RuntimeStartFailed, releasedBy } from "@btravstack/core";
-import { ErrAsync } from "unthrown";
+import { Observers, RuntimePort, RuntimeStartFailed, noObserver, observe, releasedBy } from "@btravstack/core";
+import { P } from "unthrown";
 import { randomUUID } from "node:crypto";
 //#region src/handler.ts
 /** The prefix a piece's port id carries; the composing form strips it to recover the key. */
@@ -33,7 +33,17 @@ const AmqpHandler = (contract, key) => {
 * handler that must stop when the kernel stops waiting reads
 * `currentUnit()?.signal`.
 */
-const messageUnits = (host) => (args, next) => host.run(metaFor(args.rawMessage), () => next());
+const messageUnits = (host, observers) => (args, next) => {
+	const settle = observe(observers, {
+		component: "amqp",
+		name: "delivery",
+		attributes: { handler: args.handlerName }
+	});
+	return host.run(metaFor(args.rawMessage), () => next()).tap(() => settle({ outcome: "ok" })).tapFailure((failure) => settle({
+		outcome: "error",
+		cause: failure.tag === "Err" ? failure.error : failure.cause
+	}));
+};
 /**
 * `UnitMeta.id` must be unique per unit, and a **delivery tag is not one**: tags
 * are per-channel and restart at `1` after a reconnect, which
@@ -114,27 +124,38 @@ const amqp = (options) => {
 	}));
 	return Module("Amqp")({
 		needs: [Env, AmqpHandlersPort],
-		provides: [config, Provider(AmqpRuntime)({
-			config: AmqpConfig,
-			handlers: AmqpHandlersPort
-		}, { sync: ({ config: bound, handlers }) => ({
-			name: "amqp",
-			resolves: [],
-			start: (host) => createWorker(host, bound, options, handlers)
-		}) })],
+		provides: [
+			config,
+			Provider.member(Observers)({
+				inject: {},
+				value: noObserver
+			}),
+			Provider(AmqpRuntime)({
+				inject: {
+					config: AmqpConfig,
+					handlers: AmqpHandlersPort,
+					observers: Observers
+				},
+				sync: ({ config: bound, handlers, observers }) => ({
+					name: "amqp",
+					resolves: [],
+					start: (host) => createWorker(host, bound, options, handlers, observers)
+				})
+			})
+		],
 		exports: [AmqpRuntime, AmqpConfig]
 	});
 };
 /**
-* The handlers as a provider, from the contract. Three call forms, one port.
+* The handlers as a provider, from the contract. Two call forms, one port.
 *
 * ```ts
-* AmqpHandlers(orderContract)({ logger: Logger }, { sync: ({ logger }) => ({ orderNotifications: (m) => … }) })
+* AmqpHandlers(orderContract)({ inject: { logger: Logger }, sync: ({ logger }) => ({ orderNotifications: (m) => … }) })
 * AmqpHandlers(orderContract)([orderNotifications, orderAudit])
 * ```
 *
-* The first two are di's own `Provider(port)` on the starter's handlers port
-* typed for the contract. The third takes the pieces `AmqpHandler(contract,
+* The first is di's own `Provider(port)` on the starter's handlers port
+* typed for the contract. The second takes the pieces `AmqpHandler(contract,
 * key)` builds: they are the provider's deps, keyed by the contract key each
 * piece's port id carries, so the services record IS the handlers record. Every
 * declared key must be covered, and two slices claiming one key are di's
@@ -142,8 +163,11 @@ const amqp = (options) => {
 */
 const AmqpHandlers = (contract) => {
 	const build = Provider(AmqpHandlersPort);
-	const compose = (pieces) => build(Object.fromEntries(pieces.map((piece) => [piece.port.portId.slice(12), piece.port])), { sync: (services) => services });
-	return ((first, second) => second === void 0 && Array.isArray(first) ? compose(first) : build(first, second));
+	const compose = (pieces) => build({
+		inject: Object.fromEntries(pieces.map((piece) => [piece.port.portId.slice(12), piece.port])),
+		sync: (services) => services
+	});
+	return ((first) => Array.isArray(first) ? compose(first) : build(first));
 };
 const startFailed = (cause) => new RuntimeStartFailed({
 	runtime: "amqp",
@@ -158,15 +182,15 @@ const queuesOf = (contract) => [...new Set(Object.values({
 	...contract.consumers,
 	...contract.rpcs
 }).map((entry) => entry.queue.name))].sort();
-const createWorker = (host, config, options, handlers) => TypedAmqpWorker.create({
+const createWorker = (host, config, options, handlers, observers) => TypedAmqpWorker.create({
 	contract: options.contract,
 	handlers,
-	middleware: messageUnits(host),
+	middleware: messageUnits(host, observers),
 	urls: [config.url],
 	...options.connectionOptions === void 0 ? {} : { connectionOptions: options.connectionOptions },
 	...options.defaultConsumerOptions === void 0 ? {} : { defaultConsumerOptions: options.defaultConsumerOptions },
 	connectTimeoutMs: config.connectTimeoutMs
-}).map((worker) => consume(worker, queuesOf(options.contract))).recoverDefect((cause) => ErrAsync(startFailed(cause)));
+}).map((worker) => consume(worker, queuesOf(options.contract))).mapErrCases((matcher) => matcher.with(P.tag("@amqp-contract/ConnectionError"), (error) => startFailed(error)));
 const consume = (worker, queues) => {
 	let closing;
 	const beginClose = () => closing ??= worker.close({ drainTimeoutMs: null });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@btravstack/amqp-worker",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "The AMQP starter for @btravstack/core: the handlers as a port, one unit per delivery, and a drain the kernel's deadline releases",
   "keywords": [
     "amqp",
@@ -44,9 +44,9 @@
     "./package.json": "./package.json"
   },
   "devDependencies": {
-    "@amqp-contract/contract": "3.0.0-beta.6",
-    "@amqp-contract/testing": "3.0.0-beta.6",
-    "@amqp-contract/worker": "3.0.0-beta.6",
+    "@amqp-contract/contract": "3.0.0-beta.7",
+    "@amqp-contract/testing": "3.0.0-beta.7",
+    "@amqp-contract/worker": "3.0.0-beta.7",
     "@btravstack/tsconfig": "0.2.0",
     "@opentelemetry/api": "1.9.1",
     "@types/node": "26.4.0",
@@ -56,20 +56,20 @@
     "typescript": "7.0.2",
     "unthrown": "5.7.0",
     "vitest": "4.1.11",
-    "zod": "4.5.1",
-    "@btravstack/config": "0.8.0",
-    "@btravstack/core": "0.8.0",
-    "@btravstack/di": "0.8.0",
+    "zod": "4.5.3",
+    "@btravstack/config": "0.10.0",
+    "@btravstack/core": "0.10.0",
+    "@btravstack/di": "0.10.0",
     "@btravstack/internal-test-infra": "0.0.0",
-    "@btravstack/testing": "0.8.0"
+    "@btravstack/testing": "0.10.0"
   },
   "peerDependencies": {
-    "@amqp-contract/worker": "^3.0.0-beta.6",
+    "@amqp-contract/worker": "^3.0.0-beta.7",
     "@opentelemetry/api": "^1",
     "unthrown": "^5.0.0",
-    "@btravstack/config": "^0.8.0",
-    "@btravstack/core": "^0.8.0",
-    "@btravstack/di": "^0.8.0"
+    "@btravstack/config": "^0.10.0",
+    "@btravstack/core": "^0.10.0",
+    "@btravstack/di": "^0.10.0"
   },
   "engines": {
     "node": ">=22"