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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bakery-framework/plugin-vue",
-  "version": "2.0.0-rc.1",
+  "version": "2.0.0-rc.2",
   "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.2"
   },
   "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

@@ -7,6 +7,7 @@ import { LRUCache } from '@bakery-framework/core/cache/lru'
 import { Bakery } 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 { ParsedCacheEntry, ServerResponseOptions, VueMeta } from './types'
 
 const logger = new Logger('vue')
@@ -524,7 +525,11 @@ export async function getServerResponse(options: ServerResponseOptions) {
     })
     const execPromise = Promise.resolve(
       is.function(exported)
-        ? exported(req, body, actionName, actionArgs)
+        ? // The parameters stay, so every existing block keeps working; the
+          // store is what lets `getBody()` reach a helper the block calls.
+          runWithServerBody(body, () =>
+            exported(req, body, actionName, actionArgs),
+          )
         : exported,
     )
     const params = await Promise.race([execPromise, timeoutPromise])