@rotorsoft/act-http 1.11.1 → 1.11.3

package/dist/@types/trpc/index.d.ts

@@ -1,7 +1,60 @@
+/**
+ * @packageDocumentation
+ * @module act-http/trpc
+ *
+ * tRPC subpath of the auto-generated API. Walks the
+ * registry of a built `Act` once at function call and emits a typed
+ * router that exposes every registered action as a flat `mutation`,
+ * matching the shape hand-written tRPC routers in the Act ecosystem
+ * already use.
+ *
+ * Usage:
+ *
+ * ```ts
+ * import { trpc } from "@rotorsoft/act-http/trpc";
+ *
+ * type Ctx = { user: { id: string; name: string }; tenant: string };
+ *
+ * const router = trpc<Ctx, typeof app>(app, {
+ *   actor: (ctx) => ({ id: ctx.user.id, name: ctx.user.name }),
+ *   stream: (action, input, ctx) => `tenant-${ctx.tenant}`,
+ * });
+ *
+ * // Client sees:
+ * //   appRouter.PressKey.mutate({ key: "5" })
+ * //   appRouter.OpenTicket.mutate({ title: "..." })
+ * ```
+ *
+ * The route shape is flat: one procedure per registered action at
+ * the top level. Action names are the unique identifiers across
+ * the registry (the framework already enforces no duplicates), so
+ * an extra namespace tier would be overhead in the common case.
+ * See `libs/act-http/README.md` for the full surface walkthrough.
+ *
+ * **Actor lives on the context.** The generator wires an internal
+ * tRPC middleware that runs the host's
+ * {@link TrpcOptions.actor | actor extractor} once per call and
+ * injects the resolved {@link Actor} onto the downstream context as
+ * `ctx.actor`. Every generated mutation reads from there — auth
+ * resolves at the procedure boundary, not inside each action body,
+ * and any composed middleware (logging, tracing) sees the same
+ * `ctx.actor`. The middleware factory is also exported as
+ * {@link authenticated} for hosts that need to compose it into
+ * their own procedure chain.
+ *
+ * Composes the shared utilities at `@rotorsoft/act-http/api`:
+ * {@link ActorExtractor} for the auth seam, {@link toApiError} for
+ * the uniform error→status/code mapping, {@link withIdempotency}
+ * for `Idempotency-Key` dedup. Three transports (this one, Hono,
+ * OpenAPI) ride the same utilities so a client talking to two
+ * transports never sees two error shapes for the same framework
+ * error.
+ */
+import { type Actor } from "@rotorsoft/act";
 import type { IdempotencyStore } from "@rotorsoft/act-ops/idempotency";
-import { type AnyTRPCMiddlewareFunction, type AnyTRPCMutationProcedure, type AnyTRPCRootTypes, type TRPCBuiltRouter } from "@trpc/server";
-import { type ActSurface } from "../api/dispatch.js";
-import { type ActorExtractor, type SseOptions } from "../api/index.js";
+import { type TRPCBuiltRouter, type TRPCDefaultErrorShape, type TRPCMiddlewareFunction, type TRPCMutationProcedure, type TRPCSubscriptionProcedure } from "@trpc/server";
+import { type ActionResult, type ActSurface, type AppActions, type AppState, type AppStateNames, type ResolverArgs } from "../api/dispatch.js";
+import { type ActorExtractor, type SseOptions, type SseSubscriptionFrame } from "../api/index.js";
 /**
  * Per-call options for {@link trpc}. The host supplies the three
  * seams the package can't make decisions on:
@@ -18,9 +71,9 @@ import { type ActorExtractor, type SseOptions } from "../api/index.js";
  *   `target.expectedVersion` so `app.do` refuses to commit if the
  *   stream has moved. Hosts typically read it from an `If-Match`
  *   header on the underlying HTTP request, or pull it from the
- *   client's last-known snapshot. Returning `undefined` skips the
- *   check for that call — handy when only some actions are
- *   concurrency-sensitive.
+ *   client's last-known snapshot. Returning `undefined` leaves the
+ *   call to the version the action loads; a number pins it, and a
+ *   pinned conflict is never retried.
  * - `idempotency` (optional) — when set, the procedure honors
  *   `Idempotency-Key` via the shared
  *   {@link withIdempotency} helper. The host supplies the
@@ -38,10 +91,10 @@ import { type ActorExtractor, type SseOptions } from "../api/index.js";
  *   procedures see this exact context type (plus `actor`) at
  *   runtime.
  */
-export type TrpcOptions<Ctx> = {
-    readonly actor: ActorExtractor;
-    readonly stream: (action_name: string, input: unknown, ctx: Ctx) => string | Promise<string>;
-    readonly expectedVersion?: (action_name: string, input: unknown, ctx: Ctx) => number | undefined | Promise<number | undefined>;
+export type TrpcOptions<Ctx, TApp = ActSurface> = {
+    readonly actor: ActorExtractor<Ctx>;
+    readonly stream: (...args: ResolverArgs<TApp, NoInfer<Ctx>>) => string | Promise<string>;
+    readonly expectedVersion?: (...args: ResolverArgs<TApp, NoInfer<Ctx>>) => number | undefined | Promise<number | undefined>;
     readonly idempotency?: {
         readonly store: IdempotencyStore;
         readonly keyFrom: (ctx: Ctx) => string | undefined;
@@ -94,25 +147,43 @@ export type TrpcOptions<Ctx> = {
  * (typically wrap them as `TRPCError({ code: "UNAUTHORIZED" })`
  * in the extractor body).
  */
-export declare function authenticated(extractor: ActorExtractor): AnyTRPCMiddlewareFunction;
+export declare function authenticated<Ctx extends object = object>(extractor: ActorExtractor<Ctx>): TRPCMiddlewareFunction<Ctx, object, object, {
+    actor: Actor;
+}, unknown>;
+/** The root types of the router {@link trpc} builds over `Ctx`. */
+type GeneratedRoot<Ctx extends object> = {
+    ctx: Ctx;
+    meta: object;
+    errorShape: TRPCDefaultErrorShape;
+    transformer: false;
+};
 /**
- * Generated router type — one mutation procedure per action name in
- * `TApp`'s registry. Mapped over the concrete action keys so
- * `createTRPCReact<typeof router>()` sees specific procedure names
- * (`PressKey`, `Clear`, …) instead of a wide `Record<string, ...>`
- * index signature — which is what trips tRPC React's
- * "useContext / Provider / useUtils collides" check on widely-typed
- * routers.
- *
- * @internal
+ * One mutation per action of `TApp`: the action's payload in, the
+ * snapshots `app.do` returns out. Mapped over the concrete action names,
+ * so `createTRPCReact<typeof router>()` sees `PressKey`, `Clear`, …
+ * instead of an index signature, which trips tRPC React's collision check.
  */
-type GeneratedRouter<TApp> = TRPCBuiltRouter<AnyTRPCRootTypes, TApp extends {
-    registry: {
-        actions: infer TActions;
+type ActionProcedures<TApp> = {
+    [K in keyof AppActions<TApp> & string]: TRPCMutationProcedure<{
+        input: AppActions<TApp>[K];
+        output: ActionResult<TApp, K>;
+        meta: object;
+    }>;
+};
+/** One subscription per state of `TApp`, yielding that state's frames. */
+type SubscribeRouter<TApp> = {
+    subscribe: {
+        [N in AppStateNames<TApp>]: TRPCSubscriptionProcedure<{
+            input: {
+                stream: string;
+            };
+            output: AsyncIterable<SseSubscriptionFrame<AppState<TApp, N>>, void, any>;
+            meta: object;
+        }>;
     };
-} ? {
-    [K in keyof TActions]: AnyTRPCMutationProcedure;
-} : Record<string, AnyTRPCMutationProcedure>>;
+};
+/** The router {@link trpc} builds: the actions, and the subscriptions with `sse`. */
+export type GeneratedRouter<Ctx extends object, TApp, TRecord> = TRPCBuiltRouter<GeneratedRoot<Ctx>, ActionProcedures<TApp> & TRecord>;
 /**
  * Build a typed tRPC router from a built `Act` instance.
  *
@@ -133,12 +204,11 @@ type GeneratedRouter<TApp> = TRPCBuiltRouter<AnyTRPCRootTypes, TApp extends {
  * 5. Maps any thrown framework error onto a `TRPCError` via
  *    {@link toApiError}.
  *
- * The returned router's procedure inputs come straight from each
- * action's Zod schema; outputs are the framework's
- * `Snapshot<TState, TEvents>[]` shape. Strong typing flows
- * end-to-end via tRPC's normal inference path — the client sees
- * `appRouter.Calculator.PressKey.mutate({ key: "5" })` as a typed
- * call without any codegen.
+ * The router is typed from `TApp`: each mutation takes its action's
+ * payload and returns the `Snapshot[]` `app.do` returns, and with `sse`
+ * each `subscribe.<state>` yields that state's frames, so a client sees
+ * `client.PressKey.mutate({ key: "5" })` as a typed call without
+ * codegen. Pass `TApp` whenever you pass `Ctx`.
  *
  * @template Ctx The tRPC context shape the host's runtime feeds in.
  *   Flows through `actor`, `stream`, and `idempotency.keyFrom` so
@@ -148,9 +218,11 @@ type GeneratedRouter<TApp> = TRPCBuiltRouter<AnyTRPCRootTypes, TApp extends {
  *
  * @param app A built `Act` orchestrator.
  * @param options Auth, stream, and (optional) idempotency seams.
- * @returns A tRPC router covering every registered action, grouped
- *   by owning state.
+ * @returns A tRPC router with one mutation per registered action.
  */
-export declare function trpc<Ctx extends object = object, TApp extends ActSurface = ActSurface>(app: TApp, options: TrpcOptions<Ctx>): GeneratedRouter<TApp>;
+export declare function trpc<Ctx extends object = object, TApp extends ActSurface = ActSurface>(app: TApp, options: TrpcOptions<Ctx, TApp> & {
+    readonly sse: SseOptions;
+}): GeneratedRouter<Ctx, TApp, SubscribeRouter<TApp>>;
+export declare function trpc<Ctx extends object = object, TApp extends ActSurface = ActSurface>(app: TApp, options: TrpcOptions<Ctx, TApp>): GeneratedRouter<Ctx, TApp, unknown>;
 export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/@types/trpc/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/trpc/index.ts"],"names":[],"mappings":"AA0DA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EACL,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC7B,KAAK,gBAAgB,EAErB,KAAK,eAAe,EAErB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,KAAK,UAAU,EAAiB,MAAM,oBAAoB,CAAC;AACpE,OAAO,EACL,KAAK,cAAc,EAInB,KAAK,UAAU,EAEhB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,MAAM,WAAW,CAAC,GAAG,IAAI;IAC7B,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,CACf,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,GAAG,KACL,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC9B,QAAQ,CAAC,eAAe,CAAC,EAAE,CACzB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,GAAG,KACL,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IACtD,QAAQ,CAAC,WAAW,CAAC,EAAE;QACrB,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;QACjC,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,GAAG,SAAS,CAAC;KACpD,CAAC;IACF;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC;CAC3B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,cAAc,GACxB,yBAAyB,CAmB3B;AAuDD;;;;;;;;;;GAUG;AACH,KAAK,eAAe,CAAC,IAAI,IAAI,eAAe,CAC1C,gBAAgB,EAChB,IAAI,SAAS;IAAE,QAAQ,EAAE;QAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;KAAE,CAAA;CAAE,GAClD;KAAG,CAAC,IAAI,MAAM,QAAQ,GAAG,wBAAwB;CAAE,GACnD,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAC7C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,IAAI,CAClB,GAAG,SAAS,MAAM,GAAG,MAAM,EAC3B,IAAI,SAAS,UAAU,GAAG,UAAU,EACpC,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,CAAC,GAAG,CAAC,GAAG,eAAe,CAAC,IAAI,CAAC,CAsJ7D"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/trpc/index.ts"],"names":[],"mappings":"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"}

package/dist/@types/webhook/index.d.ts

@@ -6,7 +6,7 @@
  *
  * Wraps `fetch` with timeouts, automatic `Idempotency-Key` derivation, and
  * status-classified errors. Designed to be composed with the reaction
- * options shipped in ACT-601 (`maxRetries`, `blockOnError`, `backoff`):
+ * options (`maxRetries`, `blockOnError`, `backoff`):
  *
  * ```ts
  * import { webhook } from "@rotorsoft/act-http/webhook";

package/dist/@types/webhook/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/webhook/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAa,eAAe,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAG1E,OAAO,EAEL,KAAK,aAAa,EAEnB,MAAM,YAAY,CAAC;AAEpB,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAInE,OAAO,EAAE,oBAAoB,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC5D,YAAY,EACV,qBAAqB,EACrB,WAAW,EACX,aAAa,EACb,eAAe,GAChB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,qBAAqB,EACrB,wBAAwB,EACxB,kBAAkB,EAClB,YAAY,GACb,MAAM,YAAY,CAAC;AAsBpB;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,OAAO,SAAS,OAAO,GAAG,OAAO,EACvD,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,GAC7B,eAAe,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,CAiGzC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/webhook/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAa,eAAe,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAG1E,OAAO,EAEL,KAAK,aAAa,EAEnB,MAAM,YAAY,CAAC;AAEpB,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAEnE,OAAO,EAAE,oBAAoB,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC5D,YAAY,EACV,qBAAqB,EACrB,WAAW,EACX,aAAa,EACb,eAAe,GAChB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,qBAAqB,EACrB,wBAAwB,EACxB,kBAAkB,EAClB,YAAY,GACb,MAAM,YAAY,CAAC;AAsBpB;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,OAAO,SAAS,OAAO,GAAG,OAAO,EACvD,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,GAC7B,eAAe,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,CA8FzC"}

package/dist/@types/webhook/types.d.ts

@@ -47,7 +47,7 @@ export type WebhookConfig<TEvents extends Schemas = Schemas> = {
      * `fetch` resolves on response headers, so the timer stays armed through
      * the error-path body read as well. A receiver that answers with headers
      * and then stalls its body times out like any other overrun instead of
-     * hanging the handler forever (#1701).
+     * hanging the handler forever.
      */
     readonly timeoutMs?: number;
     /**

package/dist/api/index.cjs

@@ -19890,9 +19890,7 @@ async function* runSseSubscription(channel, stream_id, accounting, signal, optio
       pending.push(msg);
       return;
     }
-    const versioned = pending.findIndex(
-      (m) => !is_version_neutral(m)
-    );
+    const versioned = pending.findIndex((m) => !is_version_neutral(m));
     if (versioned >= 0) {
       pending.splice(versioned, 1);
       pending.push(msg);