Skip to content

Lightpanda: the headless browser designed for AI and automation

streams: correct error throws

Halil Durak86f9e3495c53
diff --git a/src/browser/tests/compression/decompression_stream.html b/src/browser/tests/compression/decompression_stream.html
index 4a9beba09..a149453c5 100644
--- a/src/browser/tests/compression/decompression_stream.html
+++ b/src/browser/tests/compression/decompression_stream.html
@@ -379,3 +379,27 @@
testing.expectEqual({ whole: true, split: true }, results);
});
</script>
+
+<script id=stored_type_error type=module>
+ const state = await testing.async();
+
+ // A stream errored by a bad chunk rejects with one TypeError object, on
+ // both sides.
+ const ds = new DecompressionStream('gzip');
+ const writer = ds.writable.getWriter();
+ const reader = ds.readable.getReader();
+ const pending_read = reader.read().catch((e) => e);
+ await writer.write('hello').catch(() => {});
+ const errors = [
+ await pending_read,
+ await reader.read().catch((e) => e),
+ await reader.cancel().catch((e) => e),
+ await writer.write(new Uint8Array(1)).catch((e) => e),
+ ];
+
+ state.resolve();
+ await state.done(() => {
+ testing.expectEqual(true, errors[0] instanceof TypeError);
+ testing.expectEqual([true, true, true, true], errors.map((e) => e === errors[0]));
+ });
+</script>
diff --git a/src/browser/tests/net/fetch.html b/src/browser/tests/net/fetch.html
index a39452611..91d779fca 100644
--- a/src/browser/tests/net/fetch.html
+++ b/src/browser/tests/net/fetch.html
@@ -369,6 +369,11 @@
c6.abort();
const stream_read = await rejection(streamed.body.getReader().read());
+ const c7 = new AbortController();
+ const streamed_custom = await fetch('http://127.0.0.1:9582/xhr', { signal: c7.signal });
+ c7.abort(custom);
+ const stream_read_custom = await rejection(streamed_custom.body.getReader().read());
+
state.resolve();
await state.done(() => {
testing.expectEqual('AbortError', inflight.name);
@@ -380,7 +385,8 @@
testing.expectEqual(100, text.length);
testing.expectEqual(custom, unread_text);
testing.expectEqual(custom, unread_clone_json);
- testing.expectTrue(stream_read !== 'resolved', 'aborted body stream read resolved');
+ testing.expectEqual('AbortError', stream_read.name);
+ testing.expectEqual(custom, stream_read_custom);
});
}
</script>
diff --git a/src/browser/tests/streams/readable_stream.html b/src/browser/tests/streams/readable_stream.html
index 050daa6cd..a00ea8edc 100644
--- a/src/browser/tests/streams/readable_stream.html
+++ b/src/browser/tests/streams/readable_stream.html
@@ -450,3 +450,21 @@
], results);
});
</script>
+
+<script id=stored_error type=module>
+ const state = await testing.async();
+
+ // read() and cancel() reject with whatever controller.error() was given.
+ const errored = new ReadableStream({ start(c) { c.error('err!'); } }).getReader();
+ const no_reason = new ReadableStream({ start(c) { c.error(); } }).getReader();
+ const results = [
+ await errored.read().catch((e) => e),
+ await errored.cancel().catch((e) => e),
+ await no_reason.read().then(() => 'resolved', (e) => e),
+ ];
+
+ state.resolve();
+ await state.done(() => {
+ testing.expectEqual(['err!', 'err!', undefined], results);
+ });
+</script>
diff --git a/src/browser/tests/streams/transform_stream.html b/src/browser/tests/streams/transform_stream.html
index 575189153..32bedcc68 100644
--- a/src/browser/tests/streams/transform_stream.html
+++ b/src/browser/tests/streams/transform_stream.html
@@ -162,3 +162,20 @@
testing.expectEqual(true, result2.done);
})();
</script>
+
+<script id=transform_error_both_sides type=module>
+ const state = await testing.async();
+
+ // controller.error(e) errors the readable and the writable side with e.
+ const err = new Error('boom');
+ const ts = new TransformStream({ transform(chunk, controller) { controller.error(err); } });
+ const writer = ts.writable.getWriter();
+ const reader = ts.readable.getReader();
+ await writer.write('a').catch(() => {});
+ const errors = [await reader.read().catch((e) => e), await writer.write('b').catch((e) => e)];
+
+ state.resolve();
+ await state.done(() => {
+ testing.expectEqual([true, true], errors.map((e) => e === err));
+ });
+</script>
diff --git a/src/browser/webapi/net/Response.zig b/src/browser/webapi/net/Response.zig
index 7e17ffffb..bc8397639 100644
--- a/src/browser/webapi/net/Response.zig
+++ b/src/browser/webapi/net/Response.zig
@@ -307,9 +307,10 @@ pub fn getBody(self: *Response, exec: *const Execution) !?*ReadableStream {
return stream;
}
const stream = blk: {
- if (self.abortReason() != null) {
+ if (self.abortReason()) |reason| {
+ // Like text() and json(), reads reject with the signal's reason.
const stream = try ReadableStream.init(null, null, exec);
- try stream._controller.doError("The operation was aborted.");
+ try stream._controller.doError(try AbortSignal.reasonJsValue(reason, exec.js.local.?));
break :blk stream;
}
if (body.len == 0) {
@@ -330,7 +331,7 @@ pub fn getBody(self: *Response, exec: *const Execution) !?*ReadableStream {
return stream;
}
const stream = try ReadableStream.init(null, null, exec);
- try stream._controller.doError("Failed to read response body");
+ try stream._controller.typeError("Failed to read response body");
self._body_stream = stream;
if (self._body_used) {
try lockStream(stream, exec);
diff --git a/src/browser/webapi/streams/ReadableStream.zig b/src/browser/webapi/streams/ReadableStream.zig
index fd1300689..5ca167dc3 100644
--- a/src/browser/webapi/streams/ReadableStream.zig
+++ b/src/browser/webapi/streams/ReadableStream.zig
@@ -43,11 +43,47 @@ pub const State = enum {
errored,
};
+/// Why a stream errored; WritableStream uses it too.
+pub const StoredError = union(enum) {
+ /// What page JS errored the stream with, e.g. controller.error(e).
+ js_val: js.Value.Global,
+ type_error: []const u8,
+ undefined,
+
+ pub fn fromJs(value_: ?js.Value) !StoredError {
+ const value = value_ orelse return .undefined;
+ if (value.isUndefined()) {
+ return .undefined;
+ }
+ return .{ .js_val = try value.persist() };
+ }
+
+ pub fn toJs(self: *StoredError, local: *const js.Local) !js.Value {
+ switch (self.*) {
+ .js_val => |global| return local.toLocal(global),
+ .undefined => return .{ .local = local, .handle = local.isolate.initUndefined() },
+ .type_error => |message| {
+ const value: js.Value = .{ .local = local, .handle = local.isolate.createTypeError(message) };
+ self.* = .{ .js_val = try value.persist() };
+ return value;
+ },
+ }
+ }
+
+ pub fn reject(self: *StoredError, comptime source: []const u8, resolver: js.PromiseResolver) void {
+ const value = self.toJs(resolver.local) catch {
+ resolver.rejectError(source, .{ .type_error = "Stream errored" });
+ return;
+ };
+ resolver.reject(source, value);
+ }
+};
+
_state: State,
_execution: *const Execution,
_reader: ?*ReadableStreamDefaultReader,
_controller: *ReadableStreamDefaultController,
-_stored_error: ?[]const u8,
+_stored_error: ?StoredError,
_pull_fn: ?js.Function.Global = null,
_pulling: bool = false,
_pull_again: bool = false,
@@ -236,17 +272,25 @@ fn shouldCallPull(self: *const ReadableStream) bool {
return desired_size > 0;
}
-pub fn cancel(self: *ReadableStream, reason: ?[]const u8, exec: *const Execution) !js.Promise {
+pub fn cancel(self: *ReadableStream, reason: ?js.Value, exec: *const Execution) !js.Promise {
const local = exec.js.local.?;
self._disturbed = true;
- if (self._state != .readable) {
- if (self._cancel) |c| {
- if (c.resolver) |r| {
- return local.toLocal(r).promise();
+ switch (self._state) {
+ .readable => {},
+ .closed => {
+ if (self._cancel) |c| {
+ if (c.resolver) |r| {
+ return local.toLocal(r).promise();
+ }
}
- }
- return local.resolvePromise(.{});
+ return local.resolvePromise(.{});
+ },
+ .errored => {
+ const resolver = local.createPromiseResolver();
+ self._stored_error.?.reject("ReadableStream.cancel", resolver);
+ return resolver.promise();
+ },
}
if (self._cancel == null) {
@@ -411,7 +455,6 @@ const PipeState = struct {
const Cancel = struct {
callback: ?js.Function.Global = null,
- reason: ?[]const u8 = null,
resolver: ?js.PromiseResolver.Global = null,
};
diff --git a/src/browser/webapi/streams/ReadableStreamDefaultController.zig b/src/browser/webapi/streams/ReadableStreamDefaultController.zig
index 015a939da..3a5e26ff1 100644
--- a/src/browser/webapi/streams/ReadableStreamDefaultController.zig
+++ b/src/browser/webapi/streams/ReadableStreamDefaultController.zig
@@ -205,36 +205,39 @@ pub fn close(self: *ReadableStreamDefaultController) !void {
self._pending_reads.clearRetainingCapacity();
}
-pub fn doError(self: *ReadableStreamDefaultController, err: []const u8) !void {
- return self.fail(err, false);
+pub fn doError(self: *ReadableStreamDefaultController, reason: ?js.Value) !void {
+ return self.fail(try .fromJs(reason));
}
-/// Like doError, but pending reads reject with a TypeError instead of the
-/// bare message, which is what native transforms (e.g. CompressionStream) throw.
pub fn typeError(self: *ReadableStreamDefaultController, message: []const u8) !void {
- return self.fail(message, true);
+ return self.fail(.{ .type_error = try self._arena.dupe(u8, message) });
}
-fn fail(self: *ReadableStreamDefaultController, err: []const u8, type_error: bool) !void {
- if (self._stream._state != .readable) {
+fn fail(self: *ReadableStreamDefaultController, err: ReadableStream.StoredError) !void {
+ const stream = self._stream;
+ if (stream._state != .readable) {
return;
}
- self._stream._state = .errored;
- self._stream._stored_error = try self._arena.dupe(u8, err);
+ stream._state = .errored;
+ stream._stored_error = err;
self.clearQueue();
- // Reject all pending reads
- for (self._pending_reads.items) |resolver| {
- const local_resolver = self._execution.js.toLocal(resolver);
- if (type_error) {
- local_resolver.rejectError("stream error", .{ .type_error = err });
- } else {
- local_resolver.reject("stream error", err);
- }
+ // Rejecting runs page JS, which can reach the list too.
+ const pending_reads = self._pending_reads;
+ self._pending_reads = .empty;
+ if (pending_reads.items.len == 0) {
+ return;
+ }
+
+ var ls: js.Local.Scope = undefined;
+ self._execution.js.localScope(&ls);
+ defer ls.deinit();
+
+ for (pending_reads.items) |resolver| {
+ stream._stored_error.?.reject("stream error", ls.toLocal(resolver));
resolver.release();
}
- self._pending_reads.clearRetainingCapacity();
}
/// The caller owns the returned global and must release it.
@@ -323,6 +326,7 @@ test "ReadableStreamDefaultController: chunks and pending reads release their gl
\\new Response('native chunk').body.getReader().read();
, null);
- // cancel() keeps its own resolver so a repeated cancel returns the same promise.
- try testing.expectEqual(base + 1, tracker.list.items.len);
+ // cancel() keeps its own resolver so a repeated cancel returns the same
+ // promise, and each errored stream keeps what it errored with.
+ try testing.expectEqual(base + 3, tracker.list.items.len);
}
diff --git a/src/browser/webapi/streams/ReadableStreamDefaultReader.zig b/src/browser/webapi/streams/ReadableStreamDefaultReader.zig
index 3f2be22c0..320cca5c4 100644
--- a/src/browser/webapi/streams/ReadableStreamDefaultReader.zig
+++ b/src/browser/webapi/streams/ReadableStreamDefaultReader.zig
@@ -53,8 +53,9 @@ pub fn read(self: *ReadableStreamDefaultReader, exec: *const Execution) !js.Prom
stream._disturbed = true;
if (stream._state == .errored) {
- //const err = stream._stored_error orelse "Stream errored";
- return local.rejectPromise(.{ .type_error = "Stream errored" });
+ const resolver = local.createPromiseResolver();
+ stream._stored_error.?.reject("ReadableStreamDefaultReader.read", resolver);
+ return resolver.promise();
}
if (stream._controller.dequeue()) |chunk| {
@@ -85,7 +86,7 @@ pub fn releaseLock(self: *ReadableStreamDefaultReader) void {
}
}
-pub fn cancel(self: *ReadableStreamDefaultReader, reason_: ?[]const u8, exec: *const Execution) !js.Promise {
+pub fn cancel(self: *ReadableStreamDefaultReader, reason_: ?js.Value, exec: *const Execution) !js.Promise {
const stream = self._stream orelse {
return exec.js.typeError("Reader has been released");
};
diff --git a/src/browser/webapi/streams/TransformStream.zig b/src/browser/webapi/streams/TransformStream.zig
index 2470f59e0..dc055db67 100644
--- a/src/browser/webapi/streams/TransformStream.zig
+++ b/src/browser/webapi/streams/TransformStream.zig
@@ -211,13 +211,21 @@ pub const TransformStreamDefaultController = struct {
try self._stream._readable._controller.enqueueValue(value);
}
- fn doError(self: *TransformStreamDefaultController, reason: []const u8) !void {
+ /// Errors both sides of the stream. The writable side goes first; erroring
+ /// it runs no JS, while rejecting the readable's pending reads does.
+ fn doError(self: *TransformStreamDefaultController, reason: ?js.Value) !void {
+ try self._stream._writable._controller.doError(reason);
try self._stream._readable._controller.doError(reason);
}
+ /// Errors both sides with the same TypeError object.
pub fn typeError(self: *TransformStreamDefaultController, message: []const u8) !void {
- try self._stream._readable._controller.typeError(message);
- self._stream._writable._controller.doError(message);
+ var ls: js.Local.Scope = undefined;
+ self._stream._readable._execution.js.localScope(&ls);
+ defer ls.deinit();
+
+ const local = &ls.local;
+ return self.doError(.{ .local = local, .handle = local.isolate.createTypeError(message) });
}
pub fn terminate(self: *TransformStreamDefaultController) !void {
diff --git a/src/browser/webapi/streams/WritableStream.zig b/src/browser/webapi/streams/WritableStream.zig
index 90f3624f1..ffe15dc65 100644
--- a/src/browser/webapi/streams/WritableStream.zig
+++ b/src/browser/webapi/streams/WritableStream.zig
@@ -18,11 +18,13 @@
const js = @import("../../js/js.zig");
+const ReadableStream = @import("ReadableStream.zig");
const WritableStreamDefaultWriter = @import("WritableStreamDefaultWriter.zig");
const WritableStreamDefaultController = @import("WritableStreamDefaultController.zig");
const TransformStream = @import("TransformStream.zig");
const Execution = js.Execution;
+const StoredError = ReadableStream.StoredError;
const WritableStream = @This();
@@ -35,7 +37,7 @@ pub const State = enum {
_state: State,
_writer: ?*WritableStreamDefaultWriter,
_controller: *WritableStreamDefaultController,
-_stored_error: ?[]const u8,
+_stored_error: ?StoredError,
_write_fn: ?js.Function.Global,
_close_fn: ?js.Function.Global,
_transform_stream: ?*TransformStream,
diff --git a/src/browser/webapi/streams/WritableStreamDefaultController.zig b/src/browser/webapi/streams/WritableStreamDefaultController.zig
index eebb5c3b3..809c4faed 100644
--- a/src/browser/webapi/streams/WritableStreamDefaultController.zig
+++ b/src/browser/webapi/streams/WritableStreamDefaultController.zig
@@ -31,10 +31,10 @@ pub fn init(stream: *WritableStream, exec: *const Execution) !*WritableStreamDef
});
}
-pub fn doError(self: *WritableStreamDefaultController, reason: []const u8) void {
+pub fn doError(self: *WritableStreamDefaultController, reason: ?js.Value) !void {
if (self._stream._state != .writable) return;
self._stream._state = .errored;
- self._stream._stored_error = reason;
+ self._stream._stored_error = try .fromJs(reason);
}
pub const JsApi = struct {
diff --git a/src/browser/webapi/streams/WritableStreamDefaultWriter.zig b/src/browser/webapi/streams/WritableStreamDefaultWriter.zig
index e149a9625..c97bd38bd 100644
--- a/src/browser/webapi/streams/WritableStreamDefaultWriter.zig
+++ b/src/browser/webapi/streams/WritableStreamDefaultWriter.zig
@@ -37,8 +37,14 @@ pub fn write(self: *WritableStreamDefaultWriter, chunk: js.Value, exec: *const E
return local.typeError("Writer has been released");
};
- if (stream._state != .writable) {
- return local.typeError("Stream is not writable");
+ switch (stream._state) {
+ .writable => {},
+ .errored => {
+ const resolver = local.createPromiseResolver();
+ stream._stored_error.?.reject("WritableStreamDefaultWriter.write", resolver);
+ return resolver.promise();
+ },
+ .closed => return local.typeError("Stream is not writable"),
}
try stream.writeChunk(chunk, exec);