@trpc/server 11.0.0-alpha-tmp-app-router-example.388 → 11.0.0-alpha-tmp-issues-5851-take-two.448

package/dist/unstable-core-do-not-import/stream/{stream.mjs → jsonl.mjs}

@@ -1,18 +1,8 @@
-import { isObject, isFunction, isAsyncIterable } from '../utils.mjs';
+import { getTRPCErrorFromUnknown } from '../error/TRPCError.mjs';
+import { isObject, isFunction, isAsyncIterable, run } from '../utils.mjs';
+import { createDeferred } from './utils/createDeferred.mjs';
+import { createReadableStream } from './utils/createReadableStream.mjs';
 
-// ---------- utils
-function createReadableStream() {
-    let controller = null;
-    const stream = new ReadableStream({
-        start (c) {
-            controller = c;
-        }
-    });
-    return [
-        stream,
-        controller
-    ];
-}
 // ---------- types
 const CHUNK_VALUE_TYPE_PROMISE = 0;
 const CHUNK_VALUE_TYPE_ASYNC_ITERABLE = 1;
@@ -34,14 +24,14 @@ function createBatchStreamProducer(opts) {
     const { data  } = opts;
     let counter = 0;
     const placeholder = 0;
-    const [stream, controller] = createReadableStream();
+    const stream = createReadableStream();
     const pending = new Set();
     function maybeClose() {
-        if (pending.size === 0) {
-            controller.close();
+        if (pending.size === 0 && !stream.cancelled()) {
+            stream.controller.close();
         }
     }
-    function hydratePromise(promise, path) {
+    function dehydratePromise(promise, path) {
         //
         const error = checkMaxDepth(path);
         if (error) {
@@ -52,25 +42,28 @@ function createBatchStreamProducer(opts) {
         }
         const idx = counter++;
         pending.add(idx);
-        const enqueue = (value)=>{
-            controller.enqueue(value);
-        };
-        promise.then((it)=>{
-            enqueue([
+        Promise.race([
+            promise,
+            stream.cancelledPromise
+        ]).then((it)=>{
+            if (it === null) {
+                return;
+            }
+            stream.controller.enqueue([
                 idx,
                 PROMISE_STATUS_FULFILLED,
-                hydrate(it, path)
+                dehydrate(it, path)
             ]);
-        }).catch((error)=>{
+        }).catch((cause)=>{
             opts.onError?.({
-                error,
+                error: cause,
                 path
             });
-            enqueue([
+            stream.controller.enqueue([
                 idx,
                 PROMISE_STATUS_REJECTED,
                 opts.formatError?.({
-                    error,
+                    error: cause,
                     path
                 })
             ]);
@@ -80,7 +73,7 @@ function createBatchStreamProducer(opts) {
         });
         return idx;
     }
-    function hydrateAsyncIterable(iterable, path) {
+    function dehydrateAsyncIterable(iterable, path) {
         const error = checkMaxDepth(path);
         if (error) {
             iterable = {
@@ -91,37 +84,58 @@ function createBatchStreamProducer(opts) {
         }
         const idx = counter++;
         pending.add(idx);
-        void (async ()=>{
-            try {
-                for await (const item of iterable){
-                    controller.enqueue([
+        run(async ()=>{
+            const iterator = iterable[Symbol.asyncIterator]();
+            while(true){
+                const next = await Promise.race([
+                    iterator.next().catch(getTRPCErrorFromUnknown),
+                    stream.cancelledPromise
+                ]);
+                if (next instanceof Error) {
+                    opts.onError?.({
+                        error: next,
+                        path
+                    });
+                    stream.controller.enqueue([
                         idx,
-                        ASYNC_ITERABLE_STATUS_VALUE,
-                        hydrate(item, path)
+                        ASYNC_ITERABLE_STATUS_ERROR,
+                        opts.formatError?.({
+                            error: next,
+                            path
+                        })
                     ]);
+                    return;
                 }
-                controller.enqueue([
-                    idx,
-                    ASYNC_ITERABLE_STATUS_DONE
-                ]);
-            } catch (error) {
-                opts.onError?.({
-                    error,
-                    path
-                });
-                controller.enqueue([
+                if (next === 'cancelled') {
+                    await iterator.return?.();
+                    break;
+                }
+                if (next.done) {
+                    stream.controller.enqueue([
+                        idx,
+                        ASYNC_ITERABLE_STATUS_DONE
+                    ]);
+                    break;
+                }
+                stream.controller.enqueue([
                     idx,
-                    ASYNC_ITERABLE_STATUS_ERROR,
-                    opts.formatError?.({
-                        error,
-                        path
-                    })
+                    ASYNC_ITERABLE_STATUS_VALUE,
+                    dehydrate(next.value, path)
                 ]);
-            } finally{
-                pending.delete(idx);
-                maybeClose();
             }
-        })();
+            pending.delete(idx);
+            maybeClose();
+        }).catch((cause)=>{
+            // this shouldn't happen, but node crashes if we don't catch it
+            opts.onError?.({
+                error: new Error('You found a bug - please report it on https://github.com/trpc/trpc', // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore https://github.com/tc39/proposal-error-cause
+                {
+                    cause
+                }),
+                path
+            });
+        });
         return idx;
     }
     function checkMaxDepth(path) {
@@ -130,11 +144,11 @@ function createBatchStreamProducer(opts) {
         }
         return null;
     }
-    function hydrateChunk(value, path) {
+    function dehydrateChunk(value, path) {
         if (isPromise(value)) {
             return [
                 CHUNK_VALUE_TYPE_PROMISE,
-                hydratePromise(value, path)
+                dehydratePromise(value, path)
             ];
         }
         if (isAsyncIterable(value)) {
@@ -143,13 +157,13 @@ function createBatchStreamProducer(opts) {
             }
             return [
                 CHUNK_VALUE_TYPE_ASYNC_ITERABLE,
-                hydrateAsyncIterable(value, path)
+                dehydrateAsyncIterable(value, path)
             ];
         }
         return null;
     }
-    function hydrate(value, path) {
-        const reg = hydrateChunk(value, path);
+    function dehydrate(value, path) {
+        const reg = dehydrateChunk(value, path);
         if (reg) {
             return [
                 [
@@ -171,7 +185,7 @@ function createBatchStreamProducer(opts) {
         const newObj = {};
         const asyncValues = [];
         for (const [key, item] of Object.entries(value)){
-            const transformed = hydrateChunk(item, [
+            const transformed = dehydrateChunk(item, [
                 ...path,
                 key
             ]);
@@ -194,13 +208,13 @@ function createBatchStreamProducer(opts) {
     }
     const newHead = {};
     for (const [key, item] of Object.entries(data)){
-        newHead[key] = hydrate(item, [
+        newHead[key] = dehydrate(item, [
             key
         ]);
     }
     return [
         newHead,
-        stream
+        stream.readable
     ];
 }
 /**
@@ -244,7 +258,7 @@ class AsyncError extends Error {
 const nodeJsStreamToReaderEsque = (source)=>{
     return {
         getReader () {
-            const [stream, controller] = createReadableStream();
+            const { readable , controller  } = createReadableStream();
             source.on('data', (chunk)=>{
                 controller.enqueue(chunk);
             });
@@ -254,7 +268,7 @@ const nodeJsStreamToReaderEsque = (source)=>{
             source.on('error', (error)=>{
                 controller.error(error);
             });
-            return stream.getReader();
+            return readable.getReader();
         }
     };
 };
@@ -300,24 +314,12 @@ function createConsumerStream(from) {
         }
     }));
 }
-function createDeferred() {
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej)=>{
-        resolve = res;
-        reject = rej;
-    });
-    return {
-        promise,
-        resolve: resolve,
-        reject: reject
-    };
-}
 /**
  * JSON Lines stream consumer
  * @see https://jsonlines.org/
  */ async function jsonlStreamConsumer(opts) {
     const { deserialize =(v)=>v  } = opts;
+    const abortController = new AbortController();
     let source = createConsumerStream(opts.from);
     if (deserialize) {
         source = source.pipeThrough(new TransformStream({
@@ -329,9 +331,16 @@ function createDeferred() {
     let headDeferred = createDeferred();
     const chunkDeferred = new Map();
     const controllers = new Map();
-    function dehydrateChunkDefinition(value) {
+    const deleteController = (idx)=>{
+        controllers.delete(idx);
+        if (controllers.size === 0 && chunkDeferred.size === 0) {
+            // nothing can be listening to the stream anymore
+            abortController.abort();
+        }
+    };
+    function hydrateChunkDefinition(value) {
         const [_path, type, chunkId] = value;
-        const [stream, controller] = createReadableStream();
+        const { readable , controller  } = createReadableStream();
         controllers.set(chunkId, controller);
         // resolve chunk deferred if it exists
         const deferred = chunkDeferred.get(chunkId);
@@ -344,7 +353,7 @@ function createDeferred() {
                 {
                     return new Promise((resolve, reject)=>{
                         // listen for next value in the stream
-                        const reader = stream.getReader();
+                        const reader = readable.getReader();
                         reader.read().then((it)=>{
                             if (it.done) {
                                 reject(new Error('Promise chunk ended without value'));
@@ -358,7 +367,7 @@ function createDeferred() {
                             const [_chunkId, status, data] = value;
                             switch(status){
                                 case PROMISE_STATUS_FULFILLED:
-                                    resolve(dehydrate(data));
+                                    resolve(hydrate(data));
                                     break;
                                 case PROMISE_STATUS_REJECTED:
                                     reject(opts.formatError?.({
@@ -375,45 +384,68 @@ function createDeferred() {
             case CHUNK_VALUE_TYPE_ASYNC_ITERABLE:
                 {
                     return {
-                        [Symbol.asyncIterator]: async function*() {
-                            const reader = stream.getReader();
-                            while(true){
-                                const { done , value  } = await reader.read();
-                                if (done) {
-                                    break;
-                                }
-                                if (value instanceof StreamInterruptedError) {
-                                    throw value;
-                                }
-                                const [_chunkId, status, data] = value;
-                                switch(status){
-                                    case ASYNC_ITERABLE_STATUS_VALUE:
-                                        yield dehydrate(data);
-                                        break;
-                                    case ASYNC_ITERABLE_STATUS_DONE:
-                                        controllers.delete(chunkId);
-                                        return;
-                                    case ASYNC_ITERABLE_STATUS_ERROR:
-                                        controllers.delete(chunkId);
-                                        throw opts.formatError?.({
-                                            error: data
-                                        }) ?? new AsyncError(data);
+                        [Symbol.asyncIterator]: ()=>{
+                            const reader = readable.getReader();
+                            const iterator = {
+                                next: async ()=>{
+                                    const { done , value  } = await reader.read();
+                                    if (value instanceof StreamInterruptedError) {
+                                        throw value;
+                                    }
+                                    if (done) {
+                                        deleteController(chunkId);
+                                        return {
+                                            done: true,
+                                            value: undefined
+                                        };
+                                    }
+                                    const [_chunkId, status, data] = value;
+                                    switch(status){
+                                        case ASYNC_ITERABLE_STATUS_VALUE:
+                                            return {
+                                                done: false,
+                                                value: hydrate(data)
+                                            };
+                                        case ASYNC_ITERABLE_STATUS_DONE:
+                                            deleteController(chunkId);
+                                            return {
+                                                done: true,
+                                                value: undefined
+                                            };
+                                        case ASYNC_ITERABLE_STATUS_ERROR:
+                                            deleteController(chunkId);
+                                            throw opts.formatError?.({
+                                                error: data
+                                            }) ?? new AsyncError(data);
+                                    }
+                                },
+                                return: async ()=>{
+                                    deleteController(chunkId);
+                                    if (controllers.size === 0) {
+                                        // nothing can be listening to the stream anymore
+                                        abortController.abort();
+                                    }
+                                    return {
+                                        done: true,
+                                        value: undefined
+                                    };
                                 }
-                            }
+                            };
+                            return iterator;
                         }
                     };
                 }
         }
     }
-    function dehydrate(value) {
+    function hydrate(value) {
         const [[data], ...asyncProps] = value;
         for (const value1 of asyncProps){
-            const dehydrated = dehydrateChunkDefinition(value1);
+            const hydrated = hydrateChunkDefinition(value1);
             const [path] = value1;
             if (path === null) {
-                return dehydrated;
+                return hydrated;
             }
-            data[path] = dehydrated;
+            data[path] = hydrated;
         }
         return data;
     }
@@ -431,11 +463,16 @@ function createDeferred() {
         controllers.clear();
     };
     source.pipeTo(new WritableStream({
+        start (controller) {
+            abortController.signal.addEventListener('abort', ()=>{
+                controller.error(abortController.signal.reason);
+            });
+        },
         async write (chunkOrHead) {
             if (headDeferred) {
                 const head = chunkOrHead;
                 for (const [key, value] of Object.entries(chunkOrHead)){
-                    const parsed = dehydrate(value);
+                    const parsed = hydrate(value);
                     head[key] = parsed;
                 }
                 headDeferred.resolve(head);

package/dist/unstable-core-do-not-import/stream/sse.d.ts

@@ -0,0 +1,86 @@
+import type { ValidateShape } from '../types';
+import type { ConsumerOnError } from './jsonl';
+type Serialize = (value: any) => any;
+type Deserialize = (value: any) => any;
+/**
+ * Server-sent Event Message
+ * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
+ * @public
+ */
+export interface SSEMessage {
+    /**
+     * The data field of the message - this can be anything
+     */
+    data: unknown;
+    /**
+     * The id for this message
+     * Passing this id will allow the client to resume the connection from this point if the connection is lost
+     * @see https://html.spec.whatwg.org/multipage/server-sent-events.html#the-last-event-id-header
+     */
+    id: string;
+}
+declare const sseSymbol: unique symbol;
+export type SSEMessageEnvelope<TData> = [typeof sseSymbol, TData];
+/**
+ * Produce a typed server-sent event message
+ */
+export declare function sse<TData extends SSEMessage>(event: ValidateShape<TData, SSEMessage>): SSEMessageEnvelope<TData>;
+export declare function isSSEMessageEnvelope<TData extends SSEMessage>(value: unknown): value is SSEMessageEnvelope<TData>;
+export type SerializedSSEvent = Omit<SSEMessage, 'data'> & {
+    data?: string;
+};
+/**
+ * @internal
+ */
+export interface PingOptions {
+    /**
+     * Enable ping comments sent from the server
+     * @default false
+     */
+    enabled: boolean;
+    /**
+     * Interval in milliseconds
+     * @default 1000
+     */
+    intervalMs?: number;
+}
+export interface SSEStreamProducerOptions {
+    serialize?: Serialize;
+    data: AsyncIterable<unknown>;
+    maxDepth?: number;
+    ping?: PingOptions;
+    /**
+     * Maximum duration in milliseconds for the request before ending the stream
+     * Only useful for serverless runtimes
+     * @default undefined
+     */
+    maxDurationMs?: number;
+    /**
+     * End the request immediately after data is sent
+     * Only useful for serverless runtimes that do not support streaming responses
+     * @default false
+     */
+    emitAndEndImmediately?: boolean;
+}
+/**
+ *
+ * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
+ */
+export declare function sseStreamProducer(opts: SSEStreamProducerOptions): ReadableStream<string>;
+export type inferSSEOutput<TData> = TData extends SSEMessageEnvelope<infer $Data> ? $Data : TData;
+/**
+ * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
+ */
+export declare function sseStreamConsumer<TData>(opts: {
+    from: EventSource;
+    onError?: ConsumerOnError;
+    deserialize?: Deserialize;
+}): AsyncIterable<inferSSEOutput<TData>>;
+export declare const sseHeaders: {
+    readonly 'Content-Type': "text/event-stream";
+    readonly 'Cache-Control': "no-cache, no-transform";
+    readonly 'X-Accel-Buffering': "no";
+    readonly Connection: "keep-alive";
+};
+export {};
+//# sourceMappingURL=sse.d.ts.map

package/dist/unstable-core-do-not-import/stream/sse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../../src/unstable-core-do-not-import/stream/sse.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAI/C,KAAK,SAAS,GAAG,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC;AACrC,KAAK,WAAW,GAAG,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC;AAEvC;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,IAAI,EAAE,OAAO,CAAC;IACd;;;;OAIG;IACH,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,QAAA,MAAM,SAAS,eAA+B,CAAC;AAC/C,MAAM,MAAM,kBAAkB,CAAC,KAAK,IAAI,CAAC,OAAO,SAAS,EAAE,KAAK,CAAC,CAAC;AAElE;;GAEG;AACH,wBAAgB,GAAG,CAAC,KAAK,SAAS,UAAU,EAC1C,KAAK,EAAE,aAAa,CAAC,KAAK,EAAE,UAAU,CAAC,GACtC,kBAAkB,CAAC,KAAK,CAAC,CAQ3B;AAED,wBAAgB,oBAAoB,CAAC,KAAK,SAAS,UAAU,EAC3D,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,kBAAkB,CAAC,KAAK,CAAC,CAEpC;AAED,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,GAAG;IACzD,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,wBAAwB;IACvC,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC;AAQD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,wBAAwB,0BA2G/D;AACD,MAAM,MAAM,cAAc,CAAC,KAAK,IAAI,KAAK,SAAS,kBAAkB,CAClE,MAAM,KAAK,CACZ,GACG,KAAK,GACL,KAAK,CAAC;AACV;;GAEG;AAEH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,IAAI,EAAE;IAC7C,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B,GAAG,aAAa,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CA0DvC;AAED,eAAO,MAAM,UAAU;;;;;CAKb,CAAC"}