@bakery-framework/core 2.5.0-alpha.0 → 2.5.0-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bakery-framework/core",
-  "version": "2.5.0-alpha.0",
+  "version": "2.5.0-alpha.1",
   "description": "Bakery framework core: handlers, router, config, session, caches, logger, compiler.",
   "keywords": [
     "bakery",
@@ -65,6 +65,6 @@
     "!src/tests"
   ],
   "engines": {
-    "bun": ">=1.4.0"
+    "bun": ">=1.4.4"
   }
 }

package/src/compiler/compiler.ts

@@ -1,12 +1,7 @@
 import { Strings } from '../cache/string'
 import { Bakery } from '../core/bakery'
 import { PluginHooks } from '../core/plugins'
-import {
-  compLog,
-  errorMsg,
-  errorWithPosition,
-  handlerLog,
-} from '../logger/serve-log'
+import { compLog, errorWithPosition, handlerLog } from '../logger/serve-log'
 import type { MapOf } from '../types'
 import { is, Try, toHash } from '../utils/common'
 import { FileSystem as fs } from '../utils/fs'
@@ -128,10 +123,14 @@ function preprocessImports(source: string, filePath: fs.AbsolutePath): string {
  * Compile `source`, naming `path` so a failure can say where it happened.
  *
  * The two branches are not symmetric on purpose. Without a path there is no
- * file to name and no caller that can render a 500 (the Vue plugin compiles
- * fragments of an SFC it has already parsed), so a failure logs and hands the
- * source back. With a path the failure is a served request, and the answer is
- * `null`: `TSHandler` turns that into the 500 it has always had a branch for.
+ * file to resolve imports against and no caller that can render a 500 (the
+ * Vue plugin compiles fragments of an SFC it has already parsed), so a failure
+ * logs and hands the source back. `origin.file` names the file such a
+ * fragment came from, for that log line only: without it the line read
+ * "Failed to compile inline source: Transform failed", and a component that
+ * would not parse in the browser had to be found by hand. With a path the
+ * failure is a served request, and the answer is `null`: `TSHandler` turns
+ * that into the 500 it has always had a branch for.
  *
  * It used to be neither. The transpiler was wrapped only on the pathless
  * branch, so a syntax error in a `.ts` asset threw straight past `compile()`,
@@ -140,22 +139,31 @@ function preprocessImports(source: string, filePath: fs.AbsolutePath): string {
  * `Unhandled Server Error: <message>` with no file and no line while the client
  * got `An unexpected error occurred.` A total blackout for a one-character typo.
  */
-export function compileText(source: string): Promise<string>
+export function compileText(
+  source: string,
+  origin?: { file: string },
+): Promise<string>
 export function compileText(
   source: string,
   path: fs.AbsolutePath,
 ): Promise<string | null>
-export async function compileText(source: string, path?: fs.AbsolutePath) {
-  if (!path) {
-    try {
-      const content = await (await getTranspiler()).transform(source)
-      return content
-    } catch (err) {
-      compLog.COMPILE_SOURCE_FAIL({ error: errorMsg(err) })
-      return source
-    }
+export async function compileText(
+  source: string,
+  where?: fs.AbsolutePath | { file: string },
+) {
+  if (typeof where !== 'string') {
+    const [failed, content] = await Try.catch(
+      (await getTranspiler()).transform(source),
+    )
+    if (!failed) return content!
+
+    const error = errorWithPosition(failed)
+    if (where) compLog.COMPILE_FAIL({ file: where.file, error })
+    else compLog.COMPILE_SOURCE_FAIL({ error })
+    return source
   }
 
+  const path = where
   source = preprocessImports(source, path)
 
   const [failed, transformed] = await Try.catch(
@@ -163,8 +171,9 @@ export async function compileText(source: string, path?: fs.AbsolutePath) {
   )
 
   if (failed) {
-    // `errorWithPosition`, not `errorMsg`: the thrown `BuildMessage` has no
-    // stack, so `errorMsg` degrades to the bare message and the line number (    // the only thing that makes this actionable) is dropped. The file comes
+    // `errorWithPosition`, not `errorMsg`: what `transform()` rejects with
+    // has no stack, so `errorMsg` degrades to a bare message and drops the
+    // line number, the only thing that makes this actionable. The file comes
     // from `{file}`; the diagnostic's own `position.file` is `input.ts`,
     // because `transform()` was handed a string.
     compLog.COMPILE_FAIL({ file: path, error: errorWithPosition(failed) })

package/src/core/jsx.ts

@@ -33,7 +33,7 @@ export const Fragment = ({ children }: { children?: any }) =>
  * like a string everywhere (`.trim()`, concatenation, `String()`), so callers
  * are unaffected.
  */
-export class SafeHtml extends String {}
+class SafeHtml extends String {}
 
 /** Mark a string as trusted HTML, exempting it from escaping. */
 export function raw(value: unknown): string {

package/src/logger/serve-log.ts

@@ -257,12 +257,20 @@ export function errorDetail(err: any): string {
  * `position.file` is `input.ts` whenever `transform()` was handed a source
  * string rather than a path (which is every compile this codebase does), so
  * printing it beside the real path would contradict it.
+ *
+ * `transform()` rejects with an `AggregateError` whose own message is only
+ * "Transform failed", with no position, and whose `errors` are the
+ * diagnostics, so the first of those is the one read. The rest usually follow
+ * from it: a `;` inside an object literal is reported as `Expected "}" but
+ * found ";"`, then as `Unexpected }` at the brace after it.
  */
 export function errorWithPosition(err: any): string {
-  const position = (err as Diagnostic)?.position
+  const first: Diagnostic =
+    Array.isArray(err?.errors) && err.errors.length ? err.errors[0] : err
+  const position = first?.position
   if (!position || position.line == null) return errorMsg(err)
 
-  const message = (err as Diagnostic).message || errorMsg(err)
+  const message = first.message || errorMsg(first)
   return `${message} (line ${position.line}, column ${position.column ?? 0})`
 }
 

package/src/router.ts

@@ -289,7 +289,8 @@ export const serveWebSocket: Bun.WebSocketHandler<any> = {
       try {
         const h = prepareWSData(ws)
         if (h) return await h.handler.message(ws, message, h.data)
-        config.websocket.message(ws, message)
+        // Optional since bun-types 1.4.4, like the other three below.
+        await config.websocket.message?.(ws, message)
       } catch (err: any) {
         serveLog.UNHANDLED_ERR({
           error: `WebSocket message error: ${errorMsg(err)}`,