@bakery-framework/plugin-vue 2.0.0-rc.1 → 2.0.0-rc.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bakery-framework/plugin-vue",
-  "version": "2.0.0-rc.1",
+  "version": "2.0.0-rc.3",
   "description": "Bakery vue plugin.",
   "keywords": [
     "bakery",
@@ -43,7 +43,7 @@
     "vue": "^3.5.38"
   },
   "dependencies": {
-    "@bakery-framework/core": "^2.0.0-rc.1"
+    "@bakery-framework/core": "^2.0.0-rc.3"
   },
   "engines": {
     "bun": ">=1.4.0"

package/src/index.ts

@@ -12,6 +12,17 @@ import { rewriteVueImports } from './utils'
  */
 export type { CustomElementsOption, VuePluginOptions } from './types'
 
+/**
+ * The request body inside a `<script server>` block, and anything it calls.
+ *
+ * Pairs with `getRequest()` from `@bakery-framework/core`. Both replace the
+ * `req` and `body` globals this plugin declared in `vue.d.ts`, which only
+ * reached a file when that `.d.ts` happened to land in the tsconfig project
+ * an editor resolved for it. The globals still work; they are no longer the
+ * only way, and they are no longer load-bearing.
+ */
+export { getBody } from './server-context'
+
 export default function vuePlugin(options?: VuePluginOptions) {
   if (options) setVuePluginOptions(options)
   return definePlugin({

package/src/server-context.ts

@@ -0,0 +1,37 @@
+import { AsyncLocalStorage } from 'node:async_hooks'
+
+/**
+ * The parsed body of the request a `<script server>` block is running for.
+ *
+ * Separate from core's `getRequest()` deliberately: the request is core's and
+ * every surface has one, while `body` is this plugin's own computation
+ * (`VueHandler.params(req, finalParams)`, which merges route params with the
+ * parsed payload). A `.tsx` page receives its body as a function argument and
+ * has no use for this.
+ *
+ * Why it exists at all is the same reason as `getRequest()`. The block used
+ * to reach `body` as a global declared in `vue.d.ts`, which only works if
+ * that `.d.ts` lands in whatever tsconfig project an editor resolves for the
+ * SFC, and for an SFC it routinely does not. An import cannot fail that way,
+ * it carries a real type instead of `any`, and it reaches a helper the block
+ * calls rather than stopping at the wrapper's parameter list.
+ */
+const bodyStore = new AsyncLocalStorage<{ body: unknown }>()
+
+/** Run `fn` with `body` visible to `getBody()`. Called by the plugin only. */
+export function runWithServerBody<T>(body: unknown, fn: () => T): T {
+  return bodyStore.run({ body }, fn)
+}
+
+/**
+ * The request body, inside a `<script server>` block or anything it calls.
+ *
+ * Unlike {@link import('@bakery-framework/core').getRequest} this does **not**
+ * throw when absent: a GET with no payload and no route params is an ordinary
+ * request, and `undefined` is the honest answer rather than an error
+ * condition. The type parameter is the caller's assertion about a shape the
+ * framework cannot know, exactly as it was when this was an `any` global.
+ */
+export function getBody<T = unknown>(): T | undefined {
+  return bodyStore.getStore()?.body as T | undefined
+}

package/src/utils.ts

@@ -4,9 +4,11 @@ import {
   unlink as nodeUnlink,
 } from 'node:fs/promises'
 import { LRUCache } from '@bakery-framework/core/cache/lru'
-import { Bakery } from '@bakery-framework/core/core/bakery'
+import { Bakery, hostStore } from '@bakery-framework/core/core/bakery'
 import { Logger } from '@bakery-framework/core/logger'
 import { fs, is, Try } from '@bakery-framework/core/utils'
+import { runWithServerBody } from './server-context'
+import type { HostContext } from '@bakery-framework/core/core/bakery'
 import type { ParsedCacheEntry, ServerResponseOptions, VueMeta } from './types'
 
 const logger = new Logger('vue')
@@ -434,6 +436,34 @@ ${
   `
 }
 
+/**
+ * Run `fn` in a host store that carries `req`.
+ *
+ * Preserves an outer store when there is one: it holds the host config and
+ * hostname the router resolved, and only `req` needs adding. Outside one
+ * (a test driving a route directly, a direct handler call) it builds a
+ * minimal context from the process config, which is what `Bakery.config`
+ * already falls back to.
+ */
+function runInRequest<T>(req: Request, fn: () => T): T {
+  const outer = hostStore.getStore()
+  if (outer) return hostStore.run({ ...outer, req }, fn)
+
+  // No outer store: carry the request and leave `config` unread.
+  //
+  // A plain `{ config: Bakery.config, ... }` throws "Config has not been
+  // initialized" the moment this runs before `initConfig()`, which is every
+  // test that drives a route directly, so the eager read reintroduced the
+  // failure it was added to fix. A getter defers it to whoever actually
+  // wants the config, and nothing in a block that only needs `req` does.
+  const ctx = { hostname: '', req } as HostContext
+  Object.defineProperty(ctx, 'config', {
+    get: () => Bakery.config,
+    enumerable: true,
+  })
+  return hostStore.run(ctx, fn)
+}
+
 /** Drop stale compiled versions of the same source so the cache dir stays bounded. */
 async function pruneServerCache(dir: string, id: string, keepName: string) {
   const entries = await Try(nodeReaddir(dir))
@@ -524,7 +554,21 @@ export async function getServerResponse(options: ServerResponseOptions) {
     })
     const execPromise = Promise.resolve(
       is.function(exported)
-        ? exported(req, body, actionName, actionArgs)
+        ? // The block runs inside a store carrying its own request, so
+          // `getRequest()` works whatever the caller did. Depending on an
+          // outer store looked fine because the worker always enters one,
+          // and then every test that drives a route directly got a throw,
+          // which `getServerResponse` swallows into `{}`: a guard block
+          // stopped redirecting and served 200. Entering it here is what
+          // makes the function total.
+          //
+          // An outer store is preserved rather than replaced: it carries the
+          // host config and hostname this request resolved.
+          runInRequest(req, () =>
+            runWithServerBody(body, () =>
+              exported(req, body, actionName, actionArgs),
+            ),
+          )
         : exported,
     )
     const params = await Promise.race([execPromise, timeoutPromise])