refactor(app-shell): keep the newTabUrl routing rule out of the factory-stubbed module

Nineteen app-shell tests stub `utils/consoleServerAction` with a factory
that names only `createConsoleServerActionHandler`, so a rule exported from
there was undefined under each of them and the record page and the runtime
hook threw on mount. The predicate and the api-handler composition now live
in `utils/newTabUrlFastPath`, which those stubs do not touch.

Co-Authored-By: Claude <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QsR2jSH8FbKjEztmGT1sbB

Author: claude

ui/packages/app-shell/src/hooks/useConsoleActionRuntime.tsx

@@ -52,7 +52,8 @@ import { EnvironmentEntitlementDialog, type EntitlementDialogState } from '../en
 import { entitlementDialogFromError, type EntitlementDialogSpec } from '../environment/entitlements.js';
 import { resolvePageVarTokens } from '../utils/resolvePageVarTokens.js';
 import { launchConsoleFlow } from '../utils/flowLaunch.js';
-import { createConsoleServerActionHandler, withNewTabUrlFastPath } from '../utils/consoleServerAction.js';
+import { createConsoleServerActionHandler } from '../utils/consoleServerAction.js';
+import { withNewTabUrlFastPath } from '../utils/newTabUrlFastPath.js';
 import { modalTargetRefusalMessage } from '../utils/modalTargetDiagnostics.js';
 import { actionContextOrg } from '../utils/actionContextOrg.js';
 import { resolveHostAppSegment } from '../utils/appRoute.js';

ui/packages/app-shell/src/utils/consoleServerAction.ts

@@ -49,11 +49,11 @@ import {
   resolveServerActionRecordId,
   type ActionContext,
   type ActionDef,
-  type ActionResult,
   type ServerActionFetch,
   type ServerActionHandler,
   type ServerActionRecordIdResolver,
 } from '@object-ui/core';
+import { takesNewTabUrlFastPath } from './newTabUrlFastPath.js';
 
 /**
  * i18next-style translate function: `t(key, englishDefault)` returns the
@@ -166,48 +166,6 @@ function openInTab(preOpenedTab: Window | null, url: string, t: ConsoleServerAct
   }
 }
 
-/**
- * Whether `action` takes the zero-roundtrip `newTabUrl` fast path:
- * `opensInNewTab` plus a non-empty `newTabUrl`. The spec gives that pair one
- * meaning whatever the action's `type` — navigate the pre-opened tab, no
- * request — so a host's `type: 'api'` handler asks this and hands such an
- * action to the handler {@link createConsoleServerActionHandler} builds,
- * instead of sending its own request to `target`.
- */
-export function takesNewTabUrlFastPath(action: ActionDef): action is ActionDef & { newTabUrl: string } {
-  return !!action.opensInNewTab && typeof action.newTabUrl === 'string' && action.newTabUrl !== '';
-}
-
-/**
- * A host's registered `type: 'api'` handler, made to honour the `newTabUrl`
- * fast path: an action that {@link takesNewTabUrlFastPath} goes to
- * `consoleHandler` (the handler {@link createConsoleServerActionHandler}
- * built for the same surface, so the record id resolves the way that surface
- * resolves it), and every other action to `apiHandler` unchanged.
- *
- * Without it the console's api handlers sent their request to `target` and
- * never read the pair, so a `type: 'api'` action declaring `opensInNewTab` +
- * `newTabUrl` opened no tab and POSTed instead, from the record header, its
- * more-menu and the list toolbar alike (objectstack#26747). The pair's early
- * row-count refusal is the fast path's own, forwarded only for those actions;
- * an ordinary api action keeps having none.
- */
-export function withNewTabUrlFastPath(
-  apiHandler: (action: ActionDef, context?: ActionContext) => Promise<ActionResult>,
-  consoleHandler: ServerActionHandler,
-): ServerActionHandler {
-  return Object.assign(
-    (action: ActionDef, context?: ActionContext) => (takesNewTabUrlFastPath(action)
-      ? consoleHandler(action, context)
-      : apiHandler(action, context)),
-    {
-      refuseBeforeInput: (action: ActionDef, context?: ActionContext) => (takesNewTabUrlFastPath(action)
-        ? consoleHandler.refuseBeforeInput?.(action, context)
-        : undefined),
-    },
-  );
-}
-
 export function createConsoleServerActionHandler(opts: ConsoleServerActionOptions): ServerActionHandler {
   const dispatch = createServerActionHandler({
     fetch: opts.fetch,

ui/packages/app-shell/src/utils/newTabUrlFastPath.ts

@@ -0,0 +1,62 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * The `newTabUrl` fast path's routing rule, shared by the console server-action
+ * handler (`consoleServerAction`) and the hosts that register a `type: 'api'`
+ * handler beside it (`useConsoleActionRuntime`, `RecordDetailView`).
+ *
+ * It lives apart from `consoleServerAction` on purpose: the hosts' tests stub
+ * that module with a factory, and a rule kept there would vanish under every
+ * such stub. Kept here, an api action is routed by the same rule under test as
+ * in the console.
+ */
+
+import type { ActionContext, ActionDef, ActionResult, ServerActionHandler } from '@object-ui/core';
+
+/**
+ * Whether `action` takes the zero-roundtrip `newTabUrl` fast path:
+ * `opensInNewTab` plus a non-empty `newTabUrl`. The spec gives that pair one
+ * meaning whatever the action's `type` — navigate the pre-opened tab, no
+ * request — so a host's `type: 'api'` handler asks this and hands such an
+ * action to the handler `createConsoleServerActionHandler` builds,
+ * instead of sending its own request to `target`.
+ */
+export function takesNewTabUrlFastPath(action: ActionDef): action is ActionDef & { newTabUrl: string } {
+  return !!action.opensInNewTab && typeof action.newTabUrl === 'string' && action.newTabUrl !== '';
+}
+
+/**
+ * A host's registered `type: 'api'` handler, made to honour the `newTabUrl`
+ * fast path: an action that {@link takesNewTabUrlFastPath} goes to
+ * `consoleHandler` (the handler `createConsoleServerActionHandler`
+ * built for the same surface, so the record id resolves the way that surface
+ * resolves it), and every other action to `apiHandler` unchanged.
+ *
+ * Without it the console's api handlers sent their request to `target` and
+ * never read the pair, so a `type: 'api'` action declaring `opensInNewTab` +
+ * `newTabUrl` opened no tab and POSTed instead, from the record header, its
+ * more-menu and the list toolbar alike (objectstack#26747). The pair's early
+ * row-count refusal is the fast path's own, forwarded only for those actions;
+ * an ordinary api action keeps having none.
+ */
+export function withNewTabUrlFastPath(
+  apiHandler: (action: ActionDef, context?: ActionContext) => Promise<ActionResult>,
+  consoleHandler: ServerActionHandler,
+): ServerActionHandler {
+  return Object.assign(
+    (action: ActionDef, context?: ActionContext) => (takesNewTabUrlFastPath(action)
+      ? consoleHandler(action, context)
+      : apiHandler(action, context)),
+    {
+      refuseBeforeInput: (action: ActionDef, context?: ActionContext) => (takesNewTabUrlFastPath(action)
+        ? consoleHandler.refuseBeforeInput?.(action, context)
+        : undefined),
+    },
+  );
+}

ui/packages/app-shell/src/views/RecordDetailView.tsx

@@ -35,7 +35,8 @@ import { RelatedRecordActionsBridge } from './RelatedRecordActionsBridge.js';
 import { withPageTabsUrlSync } from '../utils/pageTabsUrlSync.js';
 import { RECORD_DETAIL_TAB_PARAM, RECORD_TRAIL_PARAM, decodeRecordTrail, buildRecordTrailHref } from '../urlParams.js';
 import { resolveActionParams } from '@object-ui/fields';
-import { createConsoleServerActionHandler, withNewTabUrlFastPath } from '../utils/consoleServerAction.js';
+import { createConsoleServerActionHandler } from '../utils/consoleServerAction.js';
+import { withNewTabUrlFastPath } from '../utils/newTabUrlFastPath.js';
 import { modalTargetRefusalMessage } from '../utils/modalTargetDiagnostics.js';
 import { actionContextOrg } from '../utils/actionContextOrg.js';
 import { resolveHostAppSegment } from '../utils/appRoute.js';