', '
'], createMemo(() => value())); + } + })); +} +async function render(run) { + const event = createRequestEvent(new Request('https://example.test')); + const stream = storage.run(event, () => renderToStream(() => page(run))); + const html = await stream; + return { html, hasErrors: stream.hasErrors }; +} +const error = new Error('PRIVATE'); +const first = await render(() => Promise.reject(error)); +const second = await render(() => Promise.reject(error)); +assert.equal(first.hasErrors, true); +assert.equal(second.hasErrors, true); +assert.deepEqual(calls, ['render', 'render']); +if (!isDev) assert.ok(!first.html.includes('PRIVATE')); +if (!isDev) assert.ok(!second.html.includes('PRIVATE')); +const load = createServerReference(registerServerReference('artifact/state', () => Promise.reject(new Error('PRIVATE_function')))); +const escaped = await render(() => load()); +assert.equal(escaped.hasErrors, true); +assert.ok(!isDev ? !escaped.html.includes('PRIVATE_function') : true); +const recovered = await render(() => load().catch(() => 'recovered')); +assert.equal(recovered.hasErrors, false); +assert.ok(recovered.html.includes('recovered')); +for (const failure of [undefined, null, false, 0, '']) { + const stream = renderToStream(() => createComponent(Errored, { + fallback: 'fallback', get children() { throw failure; } + })); + await stream; + assert.equal(stream.hasErrors, true); +} +process.stdout.write(JSON.stringify({isDev, passed: true})); +`; + +const serializationProbe = ` +import assert from 'node:assert/strict'; +import { configureServerErrors, renderToStream } from '@solidjs/web'; +import { createPlugin } from '@solidjs/web/serialization'; +import { sharedConfig } from 'solid-js/internal'; +let failure; +let kind; +let logs = 0; +console.error = () => logs++; +class Value {} +function parse() { + if (kind === 'parse') throw failure; + return {}; +} +const plugin = createPlugin({ + tag: 'test/render-error-state', + test: value => value instanceof Value, + parse: { sync: parse, stream: parse }, + serialize() { throw failure; }, + deserialize: () => new Value() +}); +for (kind of ['parse', 'serialize', 'unsupported']) { + for (const mode of ['async', 'sync', 'defer']) { + for (const hook of ['none', 'local', 'global', 'both']) { + logs = 0; + failure = new Error('plugin serialization failure'); + const calls = []; + const onError = (error, context) => { calls.push(['local', error, context.handling]); return new Error('public failure'); }; + const globalError = (error, context) => { calls.push(['global', error, context.handling]); return new Error('public failure'); }; + configureServerErrors(hook === 'global' || hook === 'both' ? { onError: globalError } : {}); + const abort = new AbortController(); + let completed = false; + const value = kind === 'unsupported' ? new WeakMap() : new Value(); + const stream = renderToStream(() => { + sharedConfig.context.serialize('value', mode === 'sync' ? value : Promise.resolve(value), mode === 'defer'); + return 'shell
'; + }, { plugins: [plugin], signal: abort.signal, onCompleteAll() { completed = true; }, ...(hook === 'local' || hook === 'both' ? { onError } : {}) }); + let timer; + try { + const html = await Promise.race([ + Promise.resolve(stream), + new Promise((_, reject) => { timer = setTimeout(() => reject(new Error('render did not complete')), 1000); }) + ]); + assert.equal(typeof html, 'string'); + assert.ok(!html.includes(failure.message)); + assert.ok(!html.includes('Seroval Error')); + assert.equal(stream.hasErrors, true); + assert.equal(completed, false); + assert.equal(calls.length, hook === 'none' ? 0 : 1); + assert.equal(logs, hook === 'none' ? 1 : 0); + if (calls.length) { + assert.equal(calls[0][0], hook === 'global' ? 'global' : 'local'); + assert.equal(calls[0][2], 'serialize'); + if (kind !== 'unsupported') assert.equal(calls[0][1], failure); + } + } finally { + clearTimeout(timer); + abort.abort(); + } + } + } +} +process.stdout.write('passed'); +`; + +describe("render error state in published artifacts", () => { + test.each(["production", "development", "observe"])("%s", condition => { + const args = condition === "production" ? [] : [`--conditions=${condition}`]; + const output = execFileSync(process.execPath, [...args, "--input-type=module", "-e", probe], { + cwd, + encoding: "utf8", + timeout: 10_000 + }); + expect(JSON.parse(output)).toEqual({ isDev: condition === "development", passed: true }); + }); + + test.each(["production", "development", "observe"])( + "terminates default serializer failures in %s", + condition => { + const args = condition === "production" ? [] : [`--conditions=${condition}`]; + const output = execFileSync( + process.execPath, + [...args, "--input-type=module", "-e", serializationProbe], + { cwd, encoding: "utf8", timeout: 10_000 } + ); + expect(output).toBe("passed"); + } + ); +}); diff --git a/packages/web/test/server/render-error-state.spec.tsx b/packages/web/test/server/render-error-state.spec.tsx new file mode 100644 index 0000000000..15cad8de2d --- /dev/null +++ b/packages/web/test/server/render-error-state.spec.tsx @@ -0,0 +1,833 @@ +/** @jsxImportSource @solidjs/web */ +import { AsyncLocalStorage } from "node:async_hooks"; +import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test, vi } from "vitest"; +import { + Errored, + Loading, + configureServerErrors, + createRequestEvent, + createSSRResponse, + redirect, + respond, + renderToStream, + type JSX, + type RequestEvent, + type ServerErrorHook +} from "@solidjs/web"; +import { SerovalParserError } from "seroval"; +import { NotReadyError, createMemo, onCleanup } from "solid-js"; +import { sharedConfig } from "solid-js/internal"; +import { createPlugin, type HydrationSerializerOptions } from "@solidjs/web/serialization"; +import { + createServerReference, + registerServerReference +} from "@solidjs/web/server-functions/server"; +import { renderServerComponent } from "../../frames/src/frame-sink.js"; +import { createJSONDataTable, createJSONSerializer } from "../../serialization/src/serializer.js"; + +const RequestContext = Symbol.for("solid.RequestContext"); +const storage = new AsyncLocalStorage{value()}
; +} +function deferredRender() { + const gate = Promise.withResolvershealthy
) + ]); + await Promise.all([failed, healthy]); + expect([failed.hasErrors, healthy.hasErrors]).toEqual([true, false]); + }); + + test("records each render even when the same request already reported its error", async () => { + const onError = vi.fnshell
; + }, + { onError } + ); + await stream; + expect(stream.hasErrors).toBe(true); + expect(onError).toHaveBeenCalledTimes(1); + expect(onError.mock.calls[0]?.[1]).toMatchObject({ handling: "serialize" }); + }); + + test.each([false, true])( + "terminates a synchronous parse failure without a local hook (global: %s)", + async hasGlobalHook => { + const onError = vi.fnshell
; + }, + { signal: abort.signal, onCompleteAll } + ); + try { + expect(() => context.serialize("unsupported", new WeakMap())).not.toThrow(); + await stream; + expect(stream.hasErrors).toBe(true); + expect(onCompleteAll).not.toHaveBeenCalled(); + expect(onError).toHaveBeenCalledTimes(hasGlobalHook ? 1 : 0); + expect(console.error).toHaveBeenCalledTimes(hasGlobalHook ? 0 : 1); + } finally { + abort.abort(); + } + } + ); + + test.each([new Error("private parse"), undefined, null, false, 0, ""])( + "cleans up pending sources after a parser throws %s", + async error => { + const token = {}; + const cleanup = vi.fn(); + const returned = vi.fn(async () => ({ done: true as const, value: undefined })); + const source = { + [Symbol.asyncIterator]() { + return { + next: () => new Promiseshell
; + }, + { plugins: [plugin], onCompleteAll } + ); + await stream; + await Promise.resolve(); + expect(stream.hasErrors).toBe(true); + expect(onError).toHaveBeenCalledTimes(1); + expect(onError.mock.calls[0]?.[0]).toBe(error); + expect(onError.mock.calls[0]?.[1]).toMatchObject({ handling: "serialize" }); + expect(onCompleteAll).not.toHaveBeenCalled(); + expect(cleanup).toHaveBeenCalledTimes(1); + expect(returned).toHaveBeenCalledTimes(1); + } + ); + + test.each(["pipe", "pipeTo", "readable"] as const)( + "ends %s and disposes pending siblings after a post-shell serialization failure", + async consumer => { + const gate = Promise.withResolversshell
; + }, + { onCompleteAll, onCompleteShell: () => shell.resolve() } + ); + let result: Promisehealthy
); + expect(await healthy).toContain("healthy"); + expect(healthy.hasErrors).toBe(false); + } + ); + + test.each(["response", "pipe", "pipeTo", "readable"] as const)( + "keeps a shell that met a serialization failure from reaching %s", + async consumer => { + let first = true; + const hole = () => { + if (first) { + first = false; + throw new NotReadyError(Promise.resolve()); + } + sharedConfig.context!.serialize("bad", new WeakMap()); + return "after"; + }; + const onError = vi.fnshell
; + }); + await stream.pipeTo( + new WritableStream({ + async write() { + events.push("write"); + gate.resolve(new WeakMap()); + await new Promise(resolve => setTimeout(resolve, 20)); + events.push("written"); + }, + close() { + events.push("close"); + } + }) + ); + events.push("resolved"); + expect(events).toEqual(["write", "written", "close", "resolved"]); + expect(stream.hasErrors).toBe(true); + }); + + test.each(["await", "pipe", "pipeTo", "readable"] as const)( + "contains a cleanup that throws as a healthy render completes (%s)", + async consumer => { + const onError = vi.fnhealthy
; + }); + let html: Promiseshell
, options); + await new Promiseshell
; + }, + { onCompleteAll } + ); + await stream; + expect(stream.hasErrors).toBe(true); + expect(onCompleteAll).not.toHaveBeenCalled(); + expect(console.error).toHaveBeenCalledTimes(1); + }); + + test.each(["none", "local", "global"])( + "preserves the custom serializer callback contract (%s hook)", + async hook => { + const error = new Error("custom serializer"); + const onError = vi.fnshell
, options); + await stream; + expect(typeof received).toBe(hook === "local" ? "function" : "undefined"); + expect(stream.hasErrors).toBe(hook === "local"); + expect(onError).toHaveBeenCalledTimes(hook === "local" ? 1 : 0); + } + ); + + test("reads the serializer factory before capturing its error hook", async () => { + let onError = vi.fnshell
, options); + await stream; + expect(received).toBeTypeOf("function"); + expect(onError).toHaveBeenCalledTimes(1); + expect(stream.hasErrors).toBe(true); + }); + + test("records a frozen custom serializer's synchronous throw without replacing it", () => { + const error = new Error("custom write"); + const abort = new AbortController(); + let context!: NonNullableshell
; + }, options); + try { + expect(() => context.serialize("custom", 1)).toThrow(error); + expect(stream.hasErrors).toBe(true); + } finally { + abort.abort(); + } + }); + + test("completes a frame stream whose client prop fails to serialize under a local hook", async () => { + const onError = vi.fncontrol handled
; + } + returnunexpected success
; + }) + ); + expect(await stream).toContain("control handled"); + expect(stream.hasErrors).toBe(false); + } + ); + + test("does not suppress a Response that actually renders an error fallback", async () => { + const stream = renderToStream(() => ( +