Thanks to visit codestin.com
Credit goes to github.com

Skip to content

Commit 8ef4099

Browse files
jasnelladuh95
jasnell
authored and
aduh95
committed
stream: use webidl validation semantics for args
Signed-off-by: James M Snell <[email protected]> Assisted-by: Opencode PR-URL: #65658 Reviewed-By: Trivikram Kamat <[email protected]>
1 parent 6286432 commit 8ef4099

19 files changed

Lines changed: 651 additions & 278 deletions

‎doc/api/stream_iter.md‎

Lines changed: 16 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -401,6 +401,12 @@ const { writer, readable } = push({
401401
A writer is any object conforming to the Writer interface. Only `write()` is
402402
required; all other methods are optional.
403403

404+
Writer arguments use Web IDL conversion semantics. A non-`Uint8Array` chunk is
405+
converted to a `USVString` and then UTF-8 encoded. `writev()` and
406+
`writevSync()` accept any iterable object whose values can be converted to
407+
chunks. Writer option dictionaries treat `null` as an empty dictionary and
408+
ignore unknown members.
409+
404410
Each async method has a synchronous `*Sync` counterpart designed for a
405411
try-fallback pattern: attempt the fast synchronous path first, and fall back
406412
to the async version only when the synchronous call indicates it could not
@@ -492,7 +498,7 @@ Synchronous write. Does not block; returns `false` if backpressure is active.
492498

493499
#### `writer.writev(chunks[, options])`
494500

495-
* `chunks` {Uint8Array\[]|string\[]}
501+
* `chunks` {Iterable} of {Uint8Array|string} values
496502
* `options` {Object}
497503
* `signal` {AbortSignal} Cancel just this write operation. The signal cancels
498504
only the pending `writev()` call; it does not fail the writer itself.
@@ -502,7 +508,7 @@ Write multiple chunks as a single batch.
502508

503509
#### `writer.writevSync(chunks)`
504510

505-
* `chunks` {Uint8Array\[]|string\[]}
511+
* `chunks` {Iterable} of {Uint8Array|string} values
506512
* Returns: {boolean} `true` if the write was accepted, `false` if the
507513
buffer is full.
508514

@@ -521,6 +527,12 @@ import { from, pull, bytes, Stream } from 'node:stream/iter';
521527
Stream.from('hello');
522528
```
523529

530+
Options dictionaries defined by the Iterable Streams API use Web IDL
531+
conversion semantics. `null` is treated as an empty dictionary, unknown
532+
members are ignored, and known members are converted to their declared types
533+
before the operation runs. Conversion failures use Node.js error codes such as
534+
`ERR_INVALID_ARG_TYPE`, `ERR_INVALID_ARG_VALUE`, and `ERR_OUT_OF_RANGE`.
535+
524536
```cjs
525537
// Named exports
526538
const { from, pull, bytes, Stream } = require('node:stream/iter');
@@ -844,7 +856,7 @@ added: v25.9.0
844856

845857
* `options` {Object}
846858
* `budget` {number} Buffer size in bytes for both directions.
847-
**Default:** `16384`.
859+
Must be >= 16384. **Default:** `16384`.
848860
* `backpressure` {string} Policy for both directions.
849861
**Default:** `'strict'`.
850862
* `signal` {AbortSignal} Cancellation signal for both channels.
@@ -1333,6 +1345,7 @@ added: v25.9.0
13331345
**Default:** `65536`.
13341346
* `backpressure` {string} `'strict'`, `'unbounded'`, `'drop-oldest'`, or
13351347
`'drop-newest'`. **Default:** `'strict'`.
1348+
* `signal` {AbortSignal}
13361349
* Returns: {Share}
13371350

13381351
Create a pull-model multi-consumer shared stream. Unlike `broadcast()`, the

‎lib/internal/fs/promises.js‎

Lines changed: 17 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -161,17 +161,19 @@ const lazyReadableStream = getLazy(() =>
161161
let newStreamsPull;
162162
let newStreamsPullSync;
163163
let newStreamsParsePullArgs;
164-
let newStreamsToUint8Array;
164+
let newStreamsToWriterUint8Array;
165165
let newStreamsConvertChunks;
166+
let newStreamsGetWriterSignal;
166167
function lazyNewStreams() {
167168
if (newStreamsPull === undefined) {
168169
const pullModule = require('internal/streams/iter/pull');
169170
newStreamsPull = pullModule.pull;
170171
newStreamsPullSync = pullModule.pullSync;
171172
const utils = require('internal/streams/iter/utils');
172173
newStreamsParsePullArgs = utils.parsePullArgs;
173-
newStreamsToUint8Array = utils.toUint8Array;
174+
newStreamsToWriterUint8Array = utils.toWriterUint8Array;
174175
newStreamsConvertChunks = utils.convertChunks;
176+
newStreamsGetWriterSignal = utils.getWriterSignal;
175177
}
176178
}
177179

@@ -882,24 +884,18 @@ if (getOptionValue('--experimental-stream-iter')) {
882884
return {
883885
__proto__: null,
884886
write(chunk, options = kNullPrototo) {
887+
chunk = newStreamsToWriterUint8Array(chunk);
888+
const signal = newStreamsGetWriterSignal(options);
885889
if (error) {
886890
return PromiseReject(error);
887891
}
888892
if (closed) {
889893
return PromiseReject(
890894
new ERR_INVALID_STATE.TypeError('The writer is closed'));
891895
}
892-
validateObject(options, 'options');
893-
const {
894-
signal,
895-
} = options;
896-
if (signal !== undefined) {
897-
validateAbortSignal(signal, 'options.signal');
898-
if (signal.aborted) {
899-
return PromiseReject(signal.reason);
900-
}
896+
if (signal?.aborted) {
897+
return PromiseReject(signal.reason);
901898
}
902-
chunk = newStreamsToUint8Array(chunk);
903899
if (bytesRemaining >= 0 && chunk.byteLength > bytesRemaining) {
904900
return PromiseReject(
905901
new ERR_OUT_OF_RANGE('write', `<= ${bytesRemaining} bytes`,
@@ -912,24 +908,18 @@ if (getOptionValue('--experimental-stream-iter')) {
912908
},
913909

914910
writev(chunks, options = kNullPrototo) {
911+
chunks = newStreamsConvertChunks(chunks);
912+
const signal = newStreamsGetWriterSignal(options);
915913
if (error) {
916914
return PromiseReject(error);
917915
}
918916
if (closed) {
919917
return PromiseReject(
920918
new ERR_INVALID_STATE.TypeError('The writer is closed'));
921919
}
922-
validateObject(options, 'options');
923-
const {
924-
signal,
925-
} = options;
926-
if (signal !== undefined) {
927-
validateAbortSignal(signal, 'options.signal');
928-
if (signal?.aborted) {
929-
return PromiseReject(signal.reason);
930-
}
920+
if (signal?.aborted) {
921+
return PromiseReject(signal.reason);
931922
}
932-
chunks = newStreamsConvertChunks(chunks);
933923
let totalSize = 0;
934924
for (let i = 0; i < chunks.length; i++) {
935925
totalSize += chunks[i].byteLength;
@@ -946,8 +936,8 @@ if (getOptionValue('--experimental-stream-iter')) {
946936
},
947937

948938
writeSync(chunk) {
939+
chunk = newStreamsToWriterUint8Array(chunk);
949940
if (error || closed || asyncPending) return false;
950-
chunk = newStreamsToUint8Array(chunk);
951941
const length = chunk.byteLength;
952942
if (length > syncWriteThreshold) return false;
953943
if (length === 0) return true;
@@ -977,8 +967,8 @@ if (getOptionValue('--experimental-stream-iter')) {
977967
},
978968

979969
writevSync(chunks) {
980-
if (error || closed || asyncPending) return false;
981970
chunks = newStreamsConvertChunks(chunks);
971+
if (error || closed || asyncPending) return false;
982972
let totalSize = 0;
983973
for (let i = 0; i < chunks.length; i++) {
984974
totalSize += chunks[i].byteLength;
@@ -1013,6 +1003,7 @@ if (getOptionValue('--experimental-stream-iter')) {
10131003
},
10141004

10151005
end(options = kNullPrototo) {
1006+
const signal = newStreamsGetWriterSignal(options);
10161007
if (error) {
10171008
return PromiseReject(error);
10181009
}
@@ -1022,15 +1013,8 @@ if (getOptionValue('--experimental-stream-iter')) {
10221013
if (closing) {
10231014
return pendingEndPromise;
10241015
}
1025-
validateObject(options, 'options');
1026-
const {
1027-
signal,
1028-
} = options;
1029-
if (signal !== undefined) {
1030-
validateAbortSignal(signal, 'options.signal');
1031-
if (signal.aborted) {
1032-
return PromiseReject(signal.reason);
1033-
}
1016+
if (signal?.aborted) {
1017+
return PromiseReject(signal.reason);
10341018
}
10351019
closing = true;
10361020
pendingEndPromise = PromisePrototypeThen(

‎lib/internal/quic/quic.js‎

Lines changed: 36 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -138,8 +138,9 @@ const {
138138
} = require('internal/streams/iter/types');
139139

140140
const {
141-
toUint8Array,
142141
convertChunks,
142+
getWriterSignal,
143+
toWriterUint8Array,
143144
} = require('internal/streams/iter/utils');
144145

145146
const {
@@ -164,7 +165,6 @@ const {
164165
} = require('internal/fs/promises');
165166

166167
const {
167-
validateAbortSignal,
168168
validateBoolean,
169169
validateFunction,
170170
validateInteger,
@@ -2197,15 +2197,14 @@ class QuicStream {
21972197
// signals backpressure additional writes are rejected until the buffer has
21982198
// capacity again.
21992199

2200-
function writeSync(chunk) {
2200+
function writeConvertedSync(chunk) {
22012201
// If the stream is closed, errored, or write-ended, we cannot accept
22022202
// more data. Refuse the sync write.
22032203
// If a drain is already pending, another operation is waiting
22042204
// for capacity. Refuse the sync write.
22052205
if (closed || errored || stream.#inner.state.writeEnded || drainWakeup != null) {
22062206
return false;
22072207
}
2208-
chunk = toUint8Array(chunk);
22092208
const len = TypedArrayPrototypeGetByteLength(chunk);
22102209
if (len === 0) return true;
22112210
// Refuse the write only when there is no available capacity at
@@ -2223,13 +2222,18 @@ class QuicStream {
22232222
return true;
22242223
}
22252224

2226-
async function write(chunk, options = kEmptyObject) {
2227-
validateObject(options, 'options');
2228-
const { signal } = options;
2229-
if (signal !== undefined) {
2230-
validateAbortSignal(signal, 'options.signal');
2231-
signal.throwIfAborted();
2232-
}
2225+
function writeSync(chunk) {
2226+
return writeConvertedSync(toWriterUint8Array(chunk));
2227+
}
2228+
2229+
function write(chunk, options = kEmptyObject) {
2230+
chunk = toWriterUint8Array(chunk);
2231+
const signal = getWriterSignal(options);
2232+
return writeAsync(chunk, signal);
2233+
}
2234+
2235+
async function writeAsync(chunk, signal) {
2236+
signal?.throwIfAborted();
22332237
if (errored) throw error;
22342238
if (closed || stream.#inner.state.writeEnded) {
22352239
throw new ERR_INVALID_STATE('Writer is closed');
@@ -2242,16 +2246,15 @@ class QuicStream {
22422246
throw new ERR_INVALID_STATE('Stream write buffer is full');
22432247
}
22442248

2245-
if (!writeSync(chunk)) {
2249+
if (!writeConvertedSync(chunk)) {
22462250
throw new ERR_INVALID_STATE('Stream write buffer is full');
22472251
}
22482252
}
22492253

2250-
function writevSync(chunks) {
2254+
function writevConvertedSync(chunks) {
22512255
if (closed || errored || stream.#inner.state.writeEnded || drainWakeup != null) {
22522256
return false;
22532257
}
2254-
chunks = convertChunks(chunks);
22552258
let len = 0;
22562259
for (const c of chunks) len += TypedArrayPrototypeGetByteLength(c);
22572260
if (len === 0) return true;
@@ -2262,13 +2265,18 @@ class QuicStream {
22622265
return true;
22632266
}
22642267

2265-
async function writev(chunks, options = kEmptyObject) {
2266-
validateObject(options, 'options');
2267-
const { signal } = options;
2268-
if (signal !== undefined) {
2269-
validateAbortSignal(signal, 'options.signal');
2270-
signal.throwIfAborted();
2271-
}
2268+
function writevSync(chunks) {
2269+
return writevConvertedSync(convertChunks(chunks));
2270+
}
2271+
2272+
function writev(chunks, options = kEmptyObject) {
2273+
chunks = convertChunks(chunks);
2274+
const signal = getWriterSignal(options);
2275+
return writevAsync(chunks, signal);
2276+
}
2277+
2278+
async function writevAsync(chunks, signal) {
2279+
signal?.throwIfAborted();
22722280

22732281
if (errored) throw error;
22742282
if (closed || stream.#inner.state.writeEnded) {
@@ -2283,7 +2291,7 @@ class QuicStream {
22832291
throw new ERR_INVALID_STATE('Stream write buffer is full');
22842292
}
22852293

2286-
if (!writevSync(chunks)) {
2294+
if (!writevConvertedSync(chunks)) {
22872295
throw new ERR_INVALID_STATE('Stream write buffer is full');
22882296
}
22892297
}
@@ -2308,11 +2316,13 @@ class QuicStream {
23082316
return totalBytesWritten;
23092317
}
23102318

2311-
async function end(options = kEmptyObject) {
2312-
validateObject(options, 'options');
2313-
const { signal } = options;
2319+
function end(options = kEmptyObject) {
2320+
const signal = getWriterSignal(options);
2321+
return endAsync(signal);
2322+
}
2323+
2324+
async function endAsync(signal) {
23142325
if (signal !== undefined) {
2315-
validateAbortSignal(signal, 'options.signal');
23162326
signal.throwIfAborted();
23172327
// TODO(@jasnell): The stream/iter spec allows individual sync end
23182328
// calls to be canceled via an AbortSignal. We currently do not support

0 commit comments

Comments
 (0)