@rotorsoft/act-http 1.10.21 → 1.10.23

package/dist/trpc/index.cjs

@@ -19744,6 +19744,23 @@ function date4(params) {
   return _coercedDate(ZodDate, params);
 }
 
+// src/api/idempotency.ts
+async function withIdempotency(store, key, handler) {
+  const fresh = await store.claim(key);
+  if (!fresh) {
+    return { deduped: true };
+  }
+  let result;
+  try {
+    result = await handler();
+  } catch (err) {
+    await store.release(key);
+    throw err;
+  }
+  await store.commit(key);
+  return { deduped: false, result };
+}
+
 // src/api/in-flight.ts
 function track_in_flight(store) {
   let tracker = trackers.get(store);
@@ -19804,6 +19821,23 @@ function make_tracker(store) {
   };
 }
 
+// src/api/dispatch.ts
+function make_dispatch(app, resolvers, store) {
+  const tracker = store && track_in_flight(store);
+  return async (action_name, input2, payload, ctx, actor, key) => {
+    const stream = await resolvers.stream(action_name, input2, ctx);
+    const expected = await resolvers.expectedVersion?.(action_name, input2, ctx);
+    const target = expected === void 0 ? { stream, actor } : { stream, actor, expectedVersion: expected };
+    const run = () => app.do(action_name, target, payload);
+    if (!tracker) return { kind: "done", result: await run() };
+    const k = key();
+    if (!k) return { kind: "missing-key" };
+    const outcome = await withIdempotency(tracker.store, k, run);
+    if (!outcome.deduped) return { kind: "done", result: outcome.result };
+    return { kind: tracker.in_flight(k) ? "in-flight" : "conflict" };
+  };
+}
+
 // src/api/errors.ts
 var import_act = require("@rotorsoft/act");
 var ERROR_MAP = {
@@ -19846,23 +19880,6 @@ function toApiError(err) {
   };
 }
 
-// src/api/idempotency.ts
-async function withIdempotency(store, key, handler) {
-  const fresh = await store.claim(key);
-  if (!fresh) {
-    return { deduped: true };
-  }
-  let result;
-  try {
-    result = await handler();
-  } catch (err) {
-    await store.release(key);
-    throw err;
-  }
-  await store.commit(key);
-  return { deduped: false, result };
-}
-
 // src/sse/types.ts
 var resync_frame = () => ({ _resync: true });
 var is_version_neutral = (msg) => msg._overlay === true || msg._resync === true;
@@ -20011,7 +20028,7 @@ function status_to_trpc_code(status) {
 }
 function trpc(app, options) {
   const t = import_server.initTRPC.context().create();
-  const tracker = options.idempotency ? track_in_flight(options.idempotency.store) : void 0;
+  const dispatch = make_dispatch(app, options, options.idempotency?.store);
   const resolve_actor = async (host_ctx) => {
     try {
       return await options.actor(host_ctx);
@@ -20035,40 +20052,23 @@ function trpc(app, options) {
           input2,
           action_schema
         );
-        const stream = await options.stream(action_name, validated, host_ctx);
-        const expected_version = options.expectedVersion ? await options.expectedVersion(action_name, validated, host_ctx) : void 0;
-        const target = expected_version === void 0 ? { stream, actor } : { stream, actor, expectedVersion: expected_version };
-        if (options.idempotency) {
-          const key = options.idempotency.keyFrom(host_ctx);
-          if (!key) {
-            throw new import_server.TRPCError({
-              code: "BAD_REQUEST",
-              message: "Idempotency-Key required"
-            });
-          }
-          const outcome = await withIdempotency(
-            tracker.store,
-            key,
-            () => app.do(action_name, target, input2)
-          );
-          if (outcome.deduped && tracker.in_flight(key)) {
-            throw new import_server.TRPCError({
-              code: "SERVICE_UNAVAILABLE",
-              message: "Idempotency-Key in flight; the original request has not finished, retry later"
-            });
-          }
-          if (outcome.deduped) {
-            throw new import_server.TRPCError({
-              code: "CONFLICT",
-              message: "Idempotency-Key already used; original result not cached"
-            });
-          }
-          return outcome.result;
-        }
-        return await app.do(
+        const outcome = await dispatch(
           action_name,
-          target,
-          input2
+          validated,
+          input2,
+          host_ctx,
+          actor,
+          () => options.idempotency?.keyFrom(host_ctx)
+        );
+        if (outcome.kind === "done") return outcome.result;
+        throw new import_server.TRPCError(
+          outcome.kind === "missing-key" ? { code: "BAD_REQUEST", message: "Idempotency-Key required" } : outcome.kind === "in-flight" ? {
+            code: "SERVICE_UNAVAILABLE",
+            message: "Idempotency-Key in flight; the original request has not finished, retry later"
+          } : {
+            code: "CONFLICT",
+            message: "Idempotency-Key already used; original result not cached"
+          }
         );
       } catch (err) {
         if (err instanceof import_server.TRPCError) throw err;
@@ -20083,10 +20083,9 @@ function trpc(app, options) {
       );
     const sse_config = resolveSseConfig(options.sse);
     const sse_counter = new SseConnectionCounter(sse_config.maxConnections);
-    const state_names = /* @__PURE__ */ new Set();
-    for (const action of Object.values(app.registry.actions)) {
-      state_names.add(action.name);
-    }
+    const state_names = new Set(
+      Object.values(app.registry.actions).map((a) => a.name)
+    );
     const sse_handlers = {};
     for (const state_name of state_names) {
       sse_handlers[state_name] = t.procedure.input(external_exports.object({ stream: external_exports.string().min(1) })).subscription(async function* ({ input: input2, ctx, signal }) {