@trpc/client 11.0.0-alpha-tmp-export-from-main.213 → 11.0.0-alpha-tmp-export-from-main.217

package/dist/links/internals/createHTTPBatchLink.js

@@ -0,0 +1,85 @@
+'use strict';
+
+var core = require('@trpc/core');
+var dataLoader = require('../../internals/dataLoader.js');
+var TRPCClientError = require('../../TRPCClientError.js');
+var httpUtils = require('./httpUtils.js');
+
+/**
+ * @internal
+ */ function createHTTPBatchLink(requester) {
+    return function httpBatchLink(opts) {
+        const resolvedOpts = httpUtils.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 = httpUtils.getUrl({
+                        ...resolvedOpts,
+                        runtime,
+                        type,
+                        path,
+                        inputs
+                    });
+                    return url.length <= maxURLLength;
+                };
+                const fetch = requester({
+                    ...resolvedOpts,
+                    runtime,
+                    type,
+                    opts
+                });
+                return {
+                    validate,
+                    fetch
+                };
+            };
+            const query = dataLoader.dataLoader(batchLoader('query'));
+            const mutation = dataLoader.dataLoader(batchLoader('mutation'));
+            const subscription = dataLoader.dataLoader(batchLoader('subscription'));
+            const loaders = {
+                query,
+                subscription,
+                mutation
+            };
+            return ({ op  })=>{
+                return core.observable((observer)=>{
+                    const loader = loaders[op.type];
+                    const { promise , cancel  } = loader.load(op);
+                    let _res = undefined;
+                    promise.then((res)=>{
+                        _res = res;
+                        const transformed = core.transformResult(res.json, runtime.transformer);
+                        if (!transformed.ok) {
+                            observer.error(TRPCClientError.TRPCClientError.from(transformed.error, {
+                                meta: res.meta
+                            }));
+                            return;
+                        }
+                        observer.next({
+                            context: res.meta,
+                            result: transformed.result
+                        });
+                        observer.complete();
+                    }).catch((err)=>{
+                        observer.error(TRPCClientError.TRPCClientError.from(err, {
+                            meta: _res?.meta
+                        }));
+                    });
+                    return ()=>{
+                        cancel();
+                    };
+                });
+            };
+        };
+    };
+}
+
+exports.createHTTPBatchLink = createHTTPBatchLink;

package/dist/links/internals/createHTTPBatchLink.mjs

@@ -0,0 +1,83 @@
+import { observable, transformResult } from '@trpc/core';
+import { dataLoader } from '../../internals/dataLoader.mjs';
+import { TRPCClientError } from '../../TRPCClientError.mjs';
+import { resolveHTTPLinkOptions, getUrl } from './httpUtils.mjs';
+
+/**
+ * @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);
+                    let _res = undefined;
+                    promise.then((res)=>{
+                        _res = res;
+                        const transformed = transformResult(res.json, runtime.transformer);
+                        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, {
+                            meta: _res?.meta
+                        }));
+                    });
+                    return ()=>{
+                        cancel();
+                    };
+                });
+            };
+        };
+    };
+}
+
+export { createHTTPBatchLink };

package/dist/links/internals/getTextDecoder.js

@@ -0,0 +1,18 @@
+'use strict';
+
+function getTextDecoder(customTextDecoder) {
+    if (customTextDecoder) {
+        return customTextDecoder;
+    }
+    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+    if (typeof window !== 'undefined' && window.TextDecoder) {
+        return new window.TextDecoder();
+    }
+    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+    if (typeof globalThis !== 'undefined' && globalThis.TextDecoder) {
+        return new globalThis.TextDecoder();
+    }
+    throw new Error('No TextDecoder implementation found');
+}
+
+exports.getTextDecoder = getTextDecoder;

package/dist/links/internals/getTextDecoder.mjs

@@ -0,0 +1,16 @@
+function getTextDecoder(customTextDecoder) {
+    if (customTextDecoder) {
+        return customTextDecoder;
+    }
+    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+    if (typeof window !== 'undefined' && window.TextDecoder) {
+        return new window.TextDecoder();
+    }
+    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+    if (typeof globalThis !== 'undefined' && globalThis.TextDecoder) {
+        return new globalThis.TextDecoder();
+    }
+    throw new Error('No TextDecoder implementation found');
+}
+
+export { getTextDecoder };

package/dist/{httpUtils-60af4c3d.js → links/internals/httpUtils.js}

@@ -1,41 +1,14 @@
 'use strict';
 
-var TRPCClientError = require('./TRPCClientError-67aefe1c.js');
-
-const isFunction = (fn)=>typeof fn === 'function';
-function getFetch(customFetchImpl) {
-    if (customFetchImpl) {
-        return customFetchImpl;
-    }
-    if (typeof window !== 'undefined' && isFunction(window.fetch)) {
-        return window.fetch;
-    }
-    if (typeof globalThis !== 'undefined' && isFunction(globalThis.fetch)) {
-        return globalThis.fetch;
-    }
-    throw new Error('No fetch implementation found');
-}
-
-function getAbortController(customAbortControllerImpl) {
-    if (customAbortControllerImpl) {
-        return customAbortControllerImpl;
-    }
-    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
-    if (typeof window !== 'undefined' && window.AbortController) {
-        return window.AbortController;
-    }
-    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
-    if (typeof globalThis !== 'undefined' && globalThis.AbortController) {
-        return globalThis.AbortController;
-    }
-    return null;
-}
+var getFetch = require('../../getFetch.js');
+var getAbortController = require('../../internals/getAbortController.js');
+var TRPCClientError = require('../../TRPCClientError.js');
 
 function resolveHTTPLinkOptions(opts) {
     return {
         url: opts.url.toString().replace(/\/$/, ''),
         fetch: opts.fetch,
-        AbortController: getAbortController(opts.AbortController)
+        AbortController: getAbortController.getAbortController(opts.AbortController)
     };
 }
 // https://github.com/trpc/trpc/pull/669
@@ -109,7 +82,7 @@ async function fetchHTTPResponse(opts, ac) {
         } : {},
         ...resolvedHeaders
     };
-    return getFetch(opts.fetch)(url, {
+    return getFetch.getFetch(opts.fetch)(url, {
         method: METHOD[type],
         signal: ac?.signal,
         body: body,
@@ -151,7 +124,6 @@ function httpRequest(opts) {
 
 exports.fetchHTTPResponse = fetchHTTPResponse;
 exports.getBody = getBody;
-exports.getFetch = getFetch;
 exports.getUrl = getUrl;
 exports.httpRequest = httpRequest;
 exports.jsonHttpRequester = jsonHttpRequester;

package/dist/{httpUtils-82ae6a64.mjs → links/internals/httpUtils.mjs}

@@ -1,33 +1,6 @@
-import { T as TRPCClientError } from './TRPCClientError-3414c3d5.mjs';
-
-const isFunction = (fn)=>typeof fn === 'function';
-function getFetch(customFetchImpl) {
-    if (customFetchImpl) {
-        return customFetchImpl;
-    }
-    if (typeof window !== 'undefined' && isFunction(window.fetch)) {
-        return window.fetch;
-    }
-    if (typeof globalThis !== 'undefined' && isFunction(globalThis.fetch)) {
-        return globalThis.fetch;
-    }
-    throw new Error('No fetch implementation found');
-}
-
-function getAbortController(customAbortControllerImpl) {
-    if (customAbortControllerImpl) {
-        return customAbortControllerImpl;
-    }
-    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
-    if (typeof window !== 'undefined' && window.AbortController) {
-        return window.AbortController;
-    }
-    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
-    if (typeof globalThis !== 'undefined' && globalThis.AbortController) {
-        return globalThis.AbortController;
-    }
-    return null;
-}
+import { getFetch } from '../../getFetch.mjs';
+import { getAbortController } from '../../internals/getAbortController.mjs';
+import { TRPCClientError } from '../../TRPCClientError.mjs';
 
 function resolveHTTPLinkOptions(opts) {
     return {
@@ -147,4 +120,4 @@ function httpRequest(opts) {
     };
 }
 
-export { getBody as a, getFetch as b, fetchHTTPResponse as f, getUrl as g, httpRequest as h, jsonHttpRequester as j, resolveHTTPLinkOptions as r };
+export { fetchHTTPResponse, getBody, getUrl, httpRequest, jsonHttpRequester, resolveHTTPLinkOptions };

package/dist/links/internals/parseJSONStream.js

@@ -0,0 +1,118 @@
+'use strict';
+
+var httpUtils = require('./httpUtils.js');
+
+// 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
+    };
+};
+
+exports.parseJSONStream = parseJSONStream;
+exports.streamingJsonHttpRequester = streamingJsonHttpRequester;

package/dist/links/internals/parseJSONStream.mjs

@@ -0,0 +1,115 @@
+import { fetchHTTPResponse, getUrl, getBody } from './httpUtils.mjs';
+
+// 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 = fetchHTTPResponse({
+        ...opts,
+        contentTypeHeader: 'application/json',
+        batchModeHeader: 'stream',
+        getUrl,
+        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
+    };
+};
+
+export { parseJSONStream, streamingJsonHttpRequester };

package/dist/links/loggerLink.js

@@ -1,10 +1,12 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var core = require('@trpc/core');
 
 /// <reference lib="dom.iterable" />
+// `dom.iterable` types are explicitly required for extracting `FormData` values,
+// as all implementations of `Symbol.iterable` are separated from the main `dom` types.
+// Using triple-slash directive makes sure that it will be available,
+// even if end-user `tsconfig.json` omits it in the `lib` array.
 function isFormData(value) {
     if (typeof FormData === 'undefined') {
         // FormData is not supported

package/dist/links/loggerLink.mjs

@@ -1,6 +1,10 @@
 import { observable, tap } from '@trpc/core';
 
 /// <reference lib="dom.iterable" />
+// `dom.iterable` types are explicitly required for extracting `FormData` values,
+// as all implementations of `Symbol.iterable` are separated from the main `dom` types.
+// Using triple-slash directive makes sure that it will be available,
+// even if end-user `tsconfig.json` omits it in the `lib` array.
 function isFormData(value) {
     if (typeof FormData === 'undefined') {
         // FormData is not supported

package/dist/links/splitLink.js

@@ -1,10 +1,27 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
+var core = require('@trpc/core');
+var createChain = require('./internals/createChain.js');
 
-require('@trpc/core');
-var links_splitLink = require('../splitLink-f52aa788.js');
+function asArray(value) {
+    return Array.isArray(value) ? value : [
+        value
+    ];
+}
+function splitLink(opts) {
+    return (runtime)=>{
+        const yes = asArray(opts.true).map((link)=>link(runtime));
+        const no = asArray(opts.false).map((link)=>link(runtime));
+        return (props)=>{
+            return core.observable((observer)=>{
+                const links = opts.condition(props.op) ? yes : no;
+                return createChain.createChain({
+                    op: props.op,
+                    links
+                }).subscribe(observer);
+            });
+        };
+    };
+}
 
-
-
-exports.splitLink = links_splitLink.splitLink;
+exports.splitLink = splitLink;

package/dist/links/splitLink.mjs

@@ -1,2 +1,25 @@
-import '@trpc/core';
-export { s as splitLink } from '../splitLink-47716d78.mjs';
+import { observable } from '@trpc/core';
+import { createChain } from './internals/createChain.mjs';
+
+function asArray(value) {
+    return Array.isArray(value) ? value : [
+        value
+    ];
+}
+function splitLink(opts) {
+    return (runtime)=>{
+        const yes = asArray(opts.true).map((link)=>link(runtime));
+        const no = asArray(opts.false).map((link)=>link(runtime));
+        return (props)=>{
+            return observable((observer)=>{
+                const links = opts.condition(props.op) ? yes : no;
+                return createChain({
+                    op: props.op,
+                    links
+                }).subscribe(observer);
+            });
+        };
+    };
+}
+
+export { splitLink };

package/dist/links/wsLink.js

@@ -1,9 +1,7 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var core = require('@trpc/core');
-var TRPCClientError = require('../TRPCClientError-67aefe1c.js');
+var TRPCClientError = require('../TRPCClientError.js');
 
 const run = (fn)=>fn();
 const exponentialBackoff = (attemptIndex)=>attemptIndex === 0 ? 0 : Math.min(1000 * 2 ** attemptIndex, 30000);

package/dist/links/wsLink.mjs

@@ -1,5 +1,5 @@
 import { observable, transformResult } from '@trpc/core';
-import { T as TRPCClientError } from '../TRPCClientError-3414c3d5.mjs';
+import { TRPCClientError } from '../TRPCClientError.mjs';
 
 const run = (fn)=>fn();
 const exponentialBackoff = (attemptIndex)=>attemptIndex === 0 ? 0 : Math.min(1000 * 2 ** attemptIndex, 30000);