@avelonjs/next 0.3.1 → 0.3.3

package/README.md

@@ -91,6 +91,7 @@ Writes become server actions in `framework/routing/actions.generated.ts`. `.api(
 | `dispatch`                  | `(controller, action, uri, formData) => Promise<NextNativeResponse>`         | Server-action entry used by generated writes.                                        |
 | `handleRoute`               | `(controller, action, uri, request, params?) => Promise<NextNativeResponse>` | JSON route-handler entry used by `.api()` files.                                     |
 | `reportFailure`             | `(scope, uri, error) => void`                                                | Writes a request failure and its cause chain to stderr.                              |
+| `reportMappedFailure`       | `(scope, uri, result) => void`                                               | Writes a 5xx action result the kernel mapped; input failures stay unlogged.          |
 | `middleware`                | `(request, routes?) => Promise<NextNativeResponse>`                          | `proxy.ts` / `middleware.ts` bridge. Pass generated routes on the Node proxy.        |
 | `MiddlewareRoute`           | `interface`                                                                  | Method, path, and middleware aliases for Edge auth.                                  |
 | `setCookie`                 | `(name, value, options?) => void`                                            | Queues a cookie write for the current Next request.                                  |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avelonjs/next",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "private": false,
   "description": "Next.js adapter for Avelon routing, server actions, and pages.",
   "license": "MIT",

package/src/adapter.ts

@@ -54,22 +54,43 @@ export interface NextAdapterOptions {
   capabilities?: Partial<typeof nextCapabilities>
 }
 
-let boundAdapter: NextAdapter | undefined
-let runtimeBoot: (() => Promise<void>) | undefined
+interface MountState {
+  adapter: NextAdapter | undefined
+  boot: (() => Promise<void>) | undefined
+}
+
+const MOUNT_STATE = Symbol.for('avelon.next.mount')
+
+/**
+ * The mount lives on `globalThis` because Next compiles one build into several module graphs.
+ *
+ * `instrumentation.ts` is assigned its own webpack layer, so a module it imports is duplicated into
+ * the layer serving requests: two copies of this file, two sets of module-level bindings. Boot ran
+ * in the instrumentation copy and a server action read the request copy, which had never been
+ * mounted and held no boot function to mount it — `dispatch` answered `Next adapter has not been
+ * mounted.` while pages worked, because the root layout boots the copy they render in. Next shares
+ * its own cross-entry state the same way (`globalThis.__incrementalCache`).
+ */
+function mountState(): MountState {
+  const host = globalThis as typeof globalThis & { [MOUNT_STATE]?: MountState }
+  host[MOUNT_STATE] ??= { adapter: undefined, boot: undefined }
+  return host[MOUNT_STATE]
+}
 
 /** Returns the adapter last passed to {@link bindAdapter}. */
 export function getAdapter(): NextAdapter {
-  if (boundAdapter === undefined) {
+  const adapter = mountState().adapter
+  if (adapter === undefined) {
     throw new Invalid('Next adapter has not been mounted.', {
       metadata: { fields: { adapter: ['Call NextAdapter.mount() before page() or dispatch().'] } },
     })
   }
-  return boundAdapter
+  return adapter
 }
 
 /** Records the adapter generated code and runtime helpers dispatch through. */
 export function bindAdapter(adapter: NextAdapter | undefined): void {
-  boundAdapter = adapter
+  mountState().adapter = adapter
 }
 
 /**
@@ -77,13 +98,14 @@ export function bindAdapter(adapter: NextAdapter | undefined): void {
  * is not yet attached. Next may render a page before the root layout finishes.
  */
 export function setRuntimeBoot(boot: (() => Promise<void>) | undefined): void {
-  runtimeBoot = boot
+  mountState().boot = boot
 }
 
 /** Returns the bound adapter, booting the runtime first when necessary. */
 export async function ensureAdapter(): Promise<NextAdapter> {
-  if (boundAdapter !== undefined) return boundAdapter
-  if (runtimeBoot !== undefined) await runtimeBoot()
+  const state = mountState()
+  if (state.adapter !== undefined) return state.adapter
+  if (state.boot !== undefined) await state.boot()
   return getAdapter()
 }
 

package/src/dispatch.ts

@@ -2,7 +2,7 @@ import { finishResponse, mapKernelException, type ControllerClass } from '@avelo
 
 import { ensureAdapter, findMountedRoute } from './adapter'
 import { readIncomingCookies, withCookies } from './cookies'
-import { reportFailure } from './failures'
+import { reportFailure, reportMappedFailure } from './failures'
 import { isNextControlFlow, type NextNativeResponse } from './response'
 
 /**
@@ -51,6 +51,7 @@ export async function dispatch(
       const request = await adapter.toRequest({ kind: 'form', uri, formData, cookies })
       const route = findMountedRoute(controller, action, uri)
       const result = await kernel.dispatch(route, request)
+      reportMappedFailure('action', uri, result)
       const response = await adapter.toResponse(result)
       await finishResponse()
       return response
@@ -89,6 +90,7 @@ export async function handleRoute(
       const http = await adapter.toRequest({ kind: 'http', request, params })
       const route = findMountedRoute(controller, action, uri)
       const result = await kernel.dispatch(route, http)
+      reportMappedFailure('route', uri, result)
       const response = await adapter.toResponse(result)
       await finishResponse()
       return response

package/src/failures.ts

@@ -16,6 +16,26 @@ export function reportFailure(scope: string, uri: string, error: unknown): void
   console.error(lines.join('\n'))
 }
 
+/**
+ * Writes a service failure the kernel already turned into a result.
+ *
+ * `mapKernelException` answers `Unavailable` with a 503 action result, so the request completes and
+ * the reason reaches the form. Nothing reaches the log, which leaves an operator reading a vendor
+ * sentence in a browser and no record of the deployment that produced it. Input failures stay
+ * unlogged: a mistyped password is not an incident.
+ */
+export function reportMappedFailure(
+  scope: string,
+  uri: string,
+  result: { type?: string; status?: number; errors?: Readonly<Record<string, readonly string[]>> },
+): void {
+  if (result.type !== 'action' || (result.status ?? 0) < 500) return
+  const messages = Object.entries(result.errors ?? {})
+    .map(([field, list]) => `${field}: ${list.join('; ')}`)
+    .join(' | ')
+  console.error(`[avelon] ${scope} ${uri} failed: ${result.status} ${messages}`)
+}
+
 function describe(error: unknown): string {
   if (error instanceof AvelonError) {
     return `${error.name}(${error.code}) ${error.message} ${JSON.stringify(error.metadata)}`

package/src/index.ts

@@ -11,7 +11,7 @@ export {
   type NextNativeRequest,
 } from './adapter'
 export { clearCookie, setCookie, type PendingCookie, type ViewRegistry } from './cookies'
-export { reportFailure } from './failures'
+export { reportFailure, reportMappedFailure } from './failures'
 export { generateRouter } from './codegen'
 export { dispatch, handleRoute } from './dispatch'
 export { middleware, type MiddlewareRoute } from './middleware'