@trpc/client 10.28.2 → 10.29.1

package/dist/httpBatchLink-f35df745.js

@@ -0,0 +1,239 @@
+import { observable } from '@trpc/server/observable';
+import { t as transformResult, T as TRPCClientError } from './transformResult-ae8e970c.js';
+import { r as resolveHTTPLinkOptions, g as getUrl, j as jsonHttpRequester } from './httpUtils-145e783b.js';
+
+/**
+ * A function that should never be called unless we messed something up.
+ */
+const throwFatalError = () => {
+    throw new Error('Something went wrong. Please submit an issue at https://github.com/trpc/trpc/issues/new');
+};
+/**
+ * Dataloader that's very inspired by https://github.com/graphql/dataloader
+ * Less configuration, no caching, and allows you to cancel requests
+ * When cancelling a single fetch the whole batch will be cancelled only when _all_ items are cancelled
+ */
+function dataLoader(batchLoader) {
+    let pendingItems = null;
+    let dispatchTimer = null;
+    const destroyTimerAndPendingItems = () => {
+        clearTimeout(dispatchTimer);
+        dispatchTimer = null;
+        pendingItems = null;
+    };
+    /**
+     * Iterate through the items and split them into groups based on the `batchLoader`'s validate function
+     */
+    function groupItems(items) {
+        const groupedItems = [[]];
+        let index = 0;
+        while (true) {
+            const item = items[index];
+            if (!item) {
+                // we're done
+                break;
+            }
+            const lastGroup = groupedItems[groupedItems.length - 1];
+            if (item.aborted) {
+                // Item was aborted before it was dispatched
+                item.reject?.(new Error('Aborted'));
+                index++;
+                continue;
+            }
+            const isValid = batchLoader.validate(lastGroup.concat(item).map((it) => it.key));
+            if (isValid) {
+                lastGroup.push(item);
+                index++;
+                continue;
+            }
+            if (lastGroup.length === 0) {
+                item.reject?.(new Error('Input is too big for a single dispatch'));
+                index++;
+                continue;
+            }
+            // Create new group, next iteration will try to add the item to that
+            groupedItems.push([]);
+        }
+        return groupedItems;
+    }
+    function dispatch() {
+        const groupedItems = groupItems(pendingItems);
+        destroyTimerAndPendingItems();
+        // Create batches for each group of items
+        for (const items of groupedItems) {
+            if (!items.length) {
+                continue;
+            }
+            const batch = {
+                items,
+                cancel: throwFatalError,
+            };
+            for (const item of items) {
+                item.batch = batch;
+            }
+            const unitResolver = (index, value) => {
+                const item = batch.items[index];
+                item.resolve?.(value);
+                item.batch = null;
+                item.reject = null;
+                item.resolve = null;
+            };
+            const { promise, cancel } = batchLoader.fetch(batch.items.map((_item) => _item.key), unitResolver);
+            batch.cancel = cancel;
+            promise
+                .then((result) => {
+                for (let i = 0; i < result.length; i++) {
+                    const value = result[i];
+                    unitResolver(i, value);
+                }
+                for (let i = 0; i < batch.items.length; i++) {
+                    const item = batch.items[i];
+                    item.reject?.(new Error('Missing result'));
+                    item.batch = null;
+                }
+            })
+                .catch((cause) => {
+                for (const item of batch.items) {
+                    item.reject?.(cause);
+                    item.batch = null;
+                }
+            });
+        }
+    }
+    function load(key) {
+        const item = {
+            aborted: false,
+            key,
+            batch: null,
+            resolve: throwFatalError,
+            reject: throwFatalError,
+        };
+        const promise = new Promise((resolve, reject) => {
+            item.reject = reject;
+            item.resolve = resolve;
+            if (!pendingItems) {
+                pendingItems = [];
+            }
+            pendingItems.push(item);
+        });
+        if (!dispatchTimer) {
+            dispatchTimer = setTimeout(dispatch);
+        }
+        const cancel = () => {
+            item.aborted = true;
+            if (item.batch?.items.every((item) => item.aborted)) {
+                // All items in the batch have been cancelled
+                item.batch.cancel();
+                item.batch = null;
+            }
+        };
+        return { promise, cancel };
+    }
+    return {
+        load,
+    };
+}
+
+/**
+ * @internal
+ */
+function createHTTPBatchLink(requester) {
+    return function httpBatchLink(opts) {
+        const resolvedOpts = resolveHTTPLinkOptions(opts);
+        const maxURLLength = opts.maxURLLength || Infinity;
+        // initialized config
+        return (runtime) => {
+            const batchLoader = (type) => {
+                const validate = (batchOps) => {
+                    if (maxURLLength === Infinity) {
+                        // escape hatch for quick calcs
+                        return true;
+                    }
+                    const path = batchOps.map((op) => op.path).join(',');
+                    const inputs = batchOps.map((op) => op.input);
+                    const url = getUrl({
+                        ...resolvedOpts,
+                        runtime,
+                        type,
+                        path,
+                        inputs,
+                    });
+                    return url.length <= maxURLLength;
+                };
+                const fetch = requester({
+                    ...resolvedOpts,
+                    runtime,
+                    type,
+                    opts,
+                });
+                return { validate, fetch };
+            };
+            const query = dataLoader(batchLoader('query'));
+            const mutation = dataLoader(batchLoader('mutation'));
+            const subscription = dataLoader(batchLoader('subscription'));
+            const loaders = { query, subscription, mutation };
+            return ({ op }) => {
+                return observable((observer) => {
+                    const loader = loaders[op.type];
+                    const { promise, cancel } = loader.load(op);
+                    promise
+                        .then((res) => {
+                        const transformed = transformResult(res.json, runtime);
+                        if (!transformed.ok) {
+                            observer.error(TRPCClientError.from(transformed.error, {
+                                meta: res.meta,
+                            }));
+                            return;
+                        }
+                        observer.next({
+                            context: res.meta,
+                            result: transformed.result,
+                        });
+                        observer.complete();
+                    })
+                        .catch((err) => observer.error(TRPCClientError.from(err)));
+                    return () => cancel();
+                });
+            };
+        };
+    };
+}
+
+const batchRequester = (requesterOpts) => {
+    return (batchOps) => {
+        const path = batchOps.map((op) => op.path).join(',');
+        const inputs = batchOps.map((op) => op.input);
+        const { promise, cancel } = jsonHttpRequester({
+            ...requesterOpts,
+            path,
+            inputs,
+            headers() {
+                if (!requesterOpts.opts.headers) {
+                    return {};
+                }
+                if (typeof requesterOpts.opts.headers === 'function') {
+                    return requesterOpts.opts.headers({
+                        opList: batchOps,
+                    });
+                }
+                return requesterOpts.opts.headers;
+            },
+        });
+        return {
+            promise: promise.then((res) => {
+                const resJSON = Array.isArray(res.json)
+                    ? res.json
+                    : batchOps.map(() => res.json);
+                const result = resJSON.map((item) => ({
+                    meta: res.meta,
+                    json: item,
+                }));
+                return result;
+            }),
+            cancel,
+        };
+    };
+};
+const httpBatchLink = createHTTPBatchLink(batchRequester);
+
+export { createHTTPBatchLink as c, httpBatchLink as h };

package/dist/{httpUtils-00c8b54e.js → httpUtils-145e783b.js}

@@ -86,31 +86,35 @@ const jsonHttpRequester = (opts) => {
         getBody,
     });
 };
-function httpRequest(opts) {
+async function fetchHTTPResponse(opts, ac) {
+    const url = opts.getUrl(opts);
+    const body = opts.getBody(opts);
     const { type } = opts;
+    const headers = await opts.headers();
+    /* istanbul ignore if -- @preserve */
+    if (type === 'subscription') {
+        throw new Error('Subscriptions should use wsLink');
+    }
+    return opts.fetch(url, {
+        method: METHOD[type],
+        signal: ac?.signal,
+        body: body,
+        headers: {
+            ...(opts.contentTypeHeader
+                ? { 'content-type': opts.contentTypeHeader }
+                : {}),
+            ...(opts.batchModeHeader
+                ? { 'trpc-batch-mode': opts.batchModeHeader }
+                : {}),
+            ...headers,
+        },
+    });
+}
+function httpRequest(opts) {
     const ac = opts.AbortController ? new opts.AbortController() : null;
+    const meta = {};
     const promise = new Promise((resolve, reject) => {
-        const url = opts.getUrl(opts);
-        const body = opts.getBody(opts);
-        const meta = {};
-        Promise.resolve(opts.headers())
-            .then((headers) => {
-            /* istanbul ignore if -- @preserve */
-            if (type === 'subscription') {
-                throw new Error('Subscriptions should use wsLink');
-            }
-            return opts.fetch(url, {
-                method: METHOD[type],
-                signal: ac?.signal,
-                body: body,
-                headers: {
-                    ...(opts.contentTypeHeader
-                        ? { 'content-type': opts.contentTypeHeader }
-                        : {}),
-                    ...headers,
-                },
-            });
-        })
+        fetchHTTPResponse(opts, ac)
             .then((_res) => {
             meta.response = _res;
             return _res.json();
@@ -129,4 +133,4 @@ function httpRequest(opts) {
     return { promise, cancel };
 }
 
-export { getUrl as a, getFetch as g, httpRequest as h, jsonHttpRequester as j, resolveHTTPLinkOptions as r };
+export { getBody as a, getFetch as b, fetchHTTPResponse as f, getUrl as g, httpRequest as h, jsonHttpRequester as j, resolveHTTPLinkOptions as r };

package/dist/{httpUtils-90a6bccb.js → httpUtils-21cbb35d.js}

@@ -86,29 +86,34 @@ const jsonHttpRequester = (opts)=>{
         getBody
     });
 };
-function httpRequest(opts) {
+async function fetchHTTPResponse(opts, ac) {
+    const url = opts.getUrl(opts);
+    const body = opts.getBody(opts);
     const { type  } = opts;
+    const headers = await opts.headers();
+    /* istanbul ignore if -- @preserve */ if (type === 'subscription') {
+        throw new Error('Subscriptions should use wsLink');
+    }
+    return opts.fetch(url, {
+        method: METHOD[type],
+        signal: ac?.signal,
+        body: body,
+        headers: {
+            ...opts.contentTypeHeader ? {
+                'content-type': opts.contentTypeHeader
+            } : {},
+            ...opts.batchModeHeader ? {
+                'trpc-batch-mode': opts.batchModeHeader
+            } : {},
+            ...headers
+        }
+    });
+}
+function httpRequest(opts) {
     const ac = opts.AbortController ? new opts.AbortController() : null;
+    const meta = {};
     const promise = new Promise((resolve, reject)=>{
-        const url = opts.getUrl(opts);
-        const body = opts.getBody(opts);
-        const meta = {};
-        Promise.resolve(opts.headers()).then((headers)=>{
-            /* istanbul ignore if -- @preserve */ if (type === 'subscription') {
-                throw new Error('Subscriptions should use wsLink');
-            }
-            return opts.fetch(url, {
-                method: METHOD[type],
-                signal: ac?.signal,
-                body: body,
-                headers: {
-                    ...opts.contentTypeHeader ? {
-                        'content-type': opts.contentTypeHeader
-                    } : {},
-                    ...headers
-                }
-            });
-        }).then((_res)=>{
+        fetchHTTPResponse(opts, ac).then((_res)=>{
             meta.response = _res;
             return _res.json();
         }).then((json)=>{
@@ -127,6 +132,8 @@ function httpRequest(opts) {
     };
 }
 
+exports.fetchHTTPResponse = fetchHTTPResponse;
+exports.getBody = getBody;
 exports.getFetch = getFetch;
 exports.getUrl = getUrl;
 exports.httpRequest = httpRequest;

package/dist/{httpUtils-8a5c637a.mjs → httpUtils-b2fcc20c.mjs}

@@ -84,29 +84,34 @@ const jsonHttpRequester = (opts)=>{
         getBody
     });
 };
-function httpRequest(opts) {
+async function fetchHTTPResponse(opts, ac) {
+    const url = opts.getUrl(opts);
+    const body = opts.getBody(opts);
     const { type  } = opts;
+    const headers = await opts.headers();
+    /* istanbul ignore if -- @preserve */ if (type === 'subscription') {
+        throw new Error('Subscriptions should use wsLink');
+    }
+    return opts.fetch(url, {
+        method: METHOD[type],
+        signal: ac?.signal,
+        body: body,
+        headers: {
+            ...opts.contentTypeHeader ? {
+                'content-type': opts.contentTypeHeader
+            } : {},
+            ...opts.batchModeHeader ? {
+                'trpc-batch-mode': opts.batchModeHeader
+            } : {},
+            ...headers
+        }
+    });
+}
+function httpRequest(opts) {
     const ac = opts.AbortController ? new opts.AbortController() : null;
+    const meta = {};
     const promise = new Promise((resolve, reject)=>{
-        const url = opts.getUrl(opts);
-        const body = opts.getBody(opts);
-        const meta = {};
-        Promise.resolve(opts.headers()).then((headers)=>{
-            /* istanbul ignore if -- @preserve */ if (type === 'subscription') {
-                throw new Error('Subscriptions should use wsLink');
-            }
-            return opts.fetch(url, {
-                method: METHOD[type],
-                signal: ac?.signal,
-                body: body,
-                headers: {
-                    ...opts.contentTypeHeader ? {
-                        'content-type': opts.contentTypeHeader
-                    } : {},
-                    ...headers
-                }
-            });
-        }).then((_res)=>{
+        fetchHTTPResponse(opts, ac).then((_res)=>{
             meta.response = _res;
             return _res.json();
         }).then((json)=>{
@@ -125,4 +130,4 @@ function httpRequest(opts) {
     };
 }
 
-export { getUrl as a, getFetch as g, httpRequest as h, jsonHttpRequester as j, resolveHTTPLinkOptions as r };
+export { getBody as a, getFetch as b, fetchHTTPResponse as f, getUrl as g, httpRequest as h, jsonHttpRequester as j, resolveHTTPLinkOptions as r };

package/dist/index.js

@@ -6,8 +6,8 @@ var observable = require('@trpc/server/observable');
 var links_splitLink = require('./splitLink-f29e84be.js');
 var transformResult = require('./transformResult-70f95ffb.js');
 var shared = require('@trpc/server/shared');
-var httpUtils = require('./httpUtils-90a6bccb.js');
-var links_httpBatchLink = require('./links/httpBatchLink.js');
+var httpUtils = require('./httpUtils-21cbb35d.js');
+var links_httpBatchLink = require('./httpBatchLink-38dcf5f2.js');
 var links_httpLink = require('./links/httpLink.js');
 var links_loggerLink = require('./links/loggerLink.js');
 var links_wsLink = require('./links/wsLink.js');
@@ -163,6 +163,165 @@ function createTRPCProxyClient(opts) {
     return proxy;
 }
 
+function getTextDecoder(customTextDecoder) {
+    if (customTextDecoder) {
+        return customTextDecoder;
+    }
+    if (typeof window !== 'undefined' && window.TextDecoder) {
+        return new window.TextDecoder();
+    }
+    if (typeof globalThis !== 'undefined' && globalThis.TextDecoder) {
+        return new globalThis.TextDecoder();
+    }
+    throw new Error('No TextDecoder implementation found');
+}
+
+// Stream parsing adapted from https://www.loginradius.com/blog/engineering/guest-post/http-streaming-with-nodejs-and-fetch-api/
+/**
+ * @internal
+ * @description Take a stream of bytes and call `onLine` with
+ * a JSON object for each line in the stream. Expected stream
+ * format is:
+ * ```json
+ * {"1": {...}
+ * ,"0": {...}
+ * }
+ * ```
+ */ async function parseJSONStream(opts) {
+    const parse = opts.parse ?? JSON.parse;
+    const onLine = (line)=>{
+        if (opts.signal?.aborted) return;
+        if (!line || line === '}') {
+            return;
+        }
+        /**
+     * At this point, `line` can be one of two things:
+     * - The first line of the stream `{"2":{...}`
+     * - A line in the middle of the stream `,"2":{...}`
+     */ const indexOfColon = line.indexOf(':');
+        const indexAsStr = line.substring(2, indexOfColon - 1);
+        const text = line.substring(indexOfColon + 1);
+        opts.onSingle(Number(indexAsStr), parse(text));
+    };
+    await readLines(opts.readableStream, onLine, opts.textDecoder);
+}
+/**
+ * Handle transforming a stream of bytes into lines of text.
+ * To avoid using AsyncIterators / AsyncGenerators,
+ * we use a callback for each line.
+ *
+ * @param readableStream can be a NodeJS stream or a WebAPI stream
+ * @param onLine will be called for every line ('\n' delimited) in the stream
+ */ async function readLines(readableStream, onLine, textDecoder) {
+    let partOfLine = '';
+    const onChunk = (chunk)=>{
+        const chunkText = textDecoder.decode(chunk);
+        const chunkLines = chunkText.split('\n');
+        if (chunkLines.length === 1) {
+            partOfLine += chunkLines[0];
+        } else if (chunkLines.length > 1) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- length checked on line above
+            onLine(partOfLine + chunkLines[0]);
+            for(let i = 1; i < chunkLines.length - 1; i++){
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- length checked on line above
+                onLine(chunkLines[i]);
+            }
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- length doesn't change, so is necessarily > 1
+            partOfLine = chunkLines[chunkLines.length - 1];
+        }
+    };
+    // we handle 2 different types of streams, this if where we figure out which one we have
+    if ('getReader' in readableStream) {
+        await readStandardChunks(readableStream, onChunk);
+    } else {
+        await readNodeChunks(readableStream, onChunk);
+    }
+    onLine(partOfLine);
+}
+/**
+ * Handle NodeJS stream
+ */ function readNodeChunks(stream, onChunk) {
+    return new Promise((resolve)=>{
+        stream.on('data', onChunk);
+        stream.on('end', resolve);
+    });
+}
+/**
+ * Handle WebAPI stream
+ */ async function readStandardChunks(stream, onChunk) {
+    const reader = stream.getReader();
+    let readResult = await reader.read();
+    while(!readResult.done){
+        onChunk(readResult.value);
+        readResult = await reader.read();
+    }
+}
+const streamingJsonHttpRequester = (opts, onSingle)=>{
+    const ac = opts.AbortController ? new opts.AbortController() : null;
+    const responsePromise = httpUtils.fetchHTTPResponse({
+        ...opts,
+        contentTypeHeader: 'application/json',
+        batchModeHeader: 'stream',
+        getUrl: httpUtils.getUrl,
+        getBody: httpUtils.getBody
+    }, ac);
+    const cancel = ()=>ac?.abort();
+    const promise = responsePromise.then(async (res)=>{
+        if (!res.body) throw new Error('Received response without body');
+        const meta = {
+            response: res
+        };
+        return parseJSONStream({
+            readableStream: res.body,
+            onSingle,
+            parse: (string)=>({
+                    json: JSON.parse(string),
+                    meta
+                }),
+            signal: ac?.signal,
+            textDecoder: opts.textDecoder
+        });
+    });
+    return {
+        cancel,
+        promise
+    };
+};
+
+const streamRequester = (requesterOpts)=>{
+    const textDecoder = getTextDecoder(requesterOpts.opts.textDecoder);
+    return (batchOps, unitResolver)=>{
+        const path = batchOps.map((op)=>op.path).join(',');
+        const inputs = batchOps.map((op)=>op.input);
+        const { cancel , promise  } = streamingJsonHttpRequester({
+            ...requesterOpts,
+            textDecoder,
+            path,
+            inputs,
+            headers () {
+                if (!requesterOpts.opts.headers) {
+                    return {};
+                }
+                if (typeof requesterOpts.opts.headers === 'function') {
+                    return requesterOpts.opts.headers({
+                        opList: batchOps
+                    });
+                }
+                return requesterOpts.opts.headers;
+            }
+        }, (index, res)=>unitResolver(index, res));
+        return {
+            /**
+       * return an empty array because the batchLoader expects an array of results
+       * but we've already called the `unitResolver` for each of them, there's
+       * nothing left to do here.
+       */ promise: promise.then(()=>[]),
+            cancel
+        };
+    };
+};
+const unstable_httpBatchStreamLink = links_httpBatchLink.createHTTPBatchLink(streamRequester);
+
 const getBody = (opts)=>{
     if (!('input' in opts)) {
         return undefined;
@@ -204,3 +363,4 @@ exports.createTRPCClientProxy = createTRPCClientProxy;
 exports.createTRPCProxyClient = createTRPCProxyClient;
 exports.createTRPCUntypedClient = createTRPCUntypedClient;
 exports.experimental_formDataLink = experimental_formDataLink;
+exports.unstable_httpBatchStreamLink = unstable_httpBatchStreamLink;