@trpc/server 11.0.0-rc.592 → 11.0.0-rc.593

package/dist/observable/operators.js

@@ -93,7 +93,42 @@ function tap(observer) {
         });
     };
 }
+const distinctUnsetMarker = Symbol();
+function distinctUntilChanged(compare = (a, b)=>a === b) {
+    return (source)=>{
+        return observable.observable((destination)=>{
+            let lastValue = distinctUnsetMarker;
+            return source.subscribe({
+                next (value) {
+                    if (lastValue !== distinctUnsetMarker && compare(lastValue, value)) {
+                        return;
+                    }
+                    lastValue = value;
+                    destination.next(value);
+                },
+                error (error) {
+                    destination.error(error);
+                },
+                complete () {
+                    destination.complete();
+                }
+            });
+        });
+    };
+}
+const isDeepEqual = (a, b)=>{
+    if (a === b) {
+        return true;
+    }
+    const bothAreObjects = a && b && typeof a === 'object' && typeof b === 'object';
+    return !!bothAreObjects && Object.keys(a).length === Object.keys(b).length && Object.entries(a).every(([k, v])=>isDeepEqual(v, b[k]));
+};
+function distinctUntilDeepChanged() {
+    return distinctUntilChanged(isDeepEqual);
+}
 
+exports.distinctUntilChanged = distinctUntilChanged;
+exports.distinctUntilDeepChanged = distinctUntilDeepChanged;
 exports.map = map;
 exports.share = share;
 exports.tap = tap;

package/dist/observable/operators.mjs

@@ -91,5 +91,38 @@ function tap(observer) {
         });
     };
 }
+const distinctUnsetMarker = Symbol();
+function distinctUntilChanged(compare = (a, b)=>a === b) {
+    return (source)=>{
+        return observable((destination)=>{
+            let lastValue = distinctUnsetMarker;
+            return source.subscribe({
+                next (value) {
+                    if (lastValue !== distinctUnsetMarker && compare(lastValue, value)) {
+                        return;
+                    }
+                    lastValue = value;
+                    destination.next(value);
+                },
+                error (error) {
+                    destination.error(error);
+                },
+                complete () {
+                    destination.complete();
+                }
+            });
+        });
+    };
+}
+const isDeepEqual = (a, b)=>{
+    if (a === b) {
+        return true;
+    }
+    const bothAreObjects = a && b && typeof a === 'object' && typeof b === 'object';
+    return !!bothAreObjects && Object.keys(a).length === Object.keys(b).length && Object.entries(a).every(([k, v])=>isDeepEqual(v, b[k]));
+};
+function distinctUntilDeepChanged() {
+    return distinctUntilChanged(isDeepEqual);
+}
 
-export { map, share, tap };
+export { distinctUntilChanged, distinctUntilDeepChanged, map, share, tap };

package/dist/unstable-core-do-not-import/http/resolveResponse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolveResponse.d.ts","sourceRoot":"","sources":["../../../src/unstable-core-do-not-import/http/resolveResponse.ts"],"names":[],"mappings":"AAMA,OAAO,EAA2B,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAExE,OAAO,EACL,KAAK,SAAS,EAGf,MAAM,WAAW,CAAC;AAQnB,OAAO,KAAK,EACV,sBAAsB,EACtB,kCAAkC,EAEnC,MAAM,SAAS,CAAC;AA0BjB,UAAU,yBAAyB,CAAC,OAAO,SAAS,SAAS,CAC3D,SAAQ,sBAAsB,CAAC,OAAO,EAAE,OAAO,CAAC;IAChD,aAAa,EAAE,kCAAkC,CAAC,OAAO,CAAC,CAAC;IAC3D,GAAG,EAAE,OAAO,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;CACzB;AAyID,wBAAsB,eAAe,CAAC,OAAO,SAAS,SAAS,EAC7D,IAAI,EAAE,yBAAyB,CAAC,OAAO,CAAC,GACvC,OAAO,CAAC,QAAQ,CAAC,CAmcnB"}
+{"version":3,"file":"resolveResponse.d.ts","sourceRoot":"","sources":["../../../src/unstable-core-do-not-import/http/resolveResponse.ts"],"names":[],"mappings":"AAMA,OAAO,EAA2B,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAExE,OAAO,EACL,KAAK,SAAS,EAGf,MAAM,WAAW,CAAC;AAanB,OAAO,KAAK,EACV,sBAAsB,EACtB,kCAAkC,EAEnC,MAAM,SAAS,CAAC;AAqCjB,UAAU,yBAAyB,CAAC,OAAO,SAAS,SAAS,CAC3D,SAAQ,sBAAsB,CAAC,OAAO,EAAE,OAAO,CAAC;IAChD,aAAa,EAAE,kCAAkC,CAAC,OAAO,CAAC,CAAC;IAC3D,GAAG,EAAE,OAAO,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;CACzB;AA2ID,wBAAsB,eAAe,CAAC,OAAO,SAAS,SAAS,EAC7D,IAAI,EAAE,yBAAyB,CAAC,OAAO,CAAC,GACvC,OAAO,CAAC,QAAQ,CAAC,CAyfnB"}

package/dist/unstable-core-do-not-import/http/resolveResponse.js

@@ -10,6 +10,17 @@ var utils = require('../utils.js');
 var contentType = require('./contentType.js');
 var getHTTPStatusCode = require('./getHTTPStatusCode.js');
 
+function errorToAsyncIterable(err) {
+    return {
+        [Symbol.asyncIterator]: ()=>{
+            return {
+                next () {
+                    throw err;
+                }
+            };
+        }
+    };
+}
 const TYPE_ACCEPTED_METHOD_MAP = {
     mutation: [
         'POST'
@@ -137,8 +148,62 @@ async function resolveResponse(opts) {
     }
     const allowBatching = opts.allowBatching ?? opts.batching?.enabled ?? true;
     const allowMethodOverride = (opts.allowMethodOverride ?? false) && req.method === 'POST';
-    let ctx = undefined;
-    let info = undefined;
+    const infoTuple = utils.run(()=>{
+        try {
+            return [
+                undefined,
+                contentType.getRequestInfo({
+                    req,
+                    path: decodeURIComponent(opts.path),
+                    router,
+                    searchParams: url.searchParams,
+                    headers: opts.req.headers
+                })
+            ];
+        } catch (cause) {
+            return [
+                TRPCError.getTRPCErrorFromUnknown(cause),
+                undefined
+            ];
+        }
+    });
+    const ctxManager = utils.run(()=>{
+        let result = undefined;
+        return {
+            valueOrUndefined: ()=>{
+                if (!result) {
+                    return undefined;
+                }
+                return result[1];
+            },
+            value: ()=>{
+                const [err, ctx] = result;
+                if (err) {
+                    throw err;
+                }
+                return ctx;
+            },
+            create: async (info)=>{
+                if (result) {
+                    throw new Error('This should only be called once - report a bug in tRPC');
+                }
+                try {
+                    const ctx = await opts.createContext({
+                        info
+                    });
+                    result = [
+                        undefined,
+                        ctx
+                    ];
+                } catch (cause) {
+                    result = [
+                        TRPCError.getTRPCErrorFromUnknown(cause),
+                        undefined
+                    ];
+                }
+            }
+        };
+    });
     const methodMapper = allowMethodOverride ? TYPE_ACCEPTED_METHOD_MAP_WITH_METHOD_OVERRIDE : TYPE_ACCEPTED_METHOD_MAP;
     /**
    * @deprecated
@@ -146,19 +211,9 @@ async function resolveResponse(opts) {
     const experimentalIterablesAndDeferreds = router._def._config.experimental?.iterablesAndDeferreds ?? true;
     const experimentalSSE = router._def._config.experimental?.sseSubscriptions?.enabled ?? true;
     try {
-        info = contentType.getRequestInfo({
-            req,
-            path: decodeURIComponent(opts.path),
-            router,
-            searchParams: url.searchParams,
-            headers: opts.req.headers
-        });
-        // we create context early so that error handlers may access context information
-        ctx = await opts.createContext({
-            info
-        });
-        if (opts.error) {
-            throw opts.error;
+        const [infoError, info] = infoTuple;
+        if (infoError) {
+            throw infoError;
         }
         if (info.isBatchCall && !allowBatching) {
             throw new TRPCError.TRPCError({
@@ -172,9 +227,13 @@ async function resolveResponse(opts) {
                 code: 'BAD_REQUEST'
             });
         }
+        await ctxManager.create(info);
         const rpcCalls = info.calls.map(async (call)=>{
             const proc = call.procedure;
             try {
+                if (opts.error) {
+                    throw opts.error;
+                }
                 if (!proc) {
                     throw new TRPCError.TRPCError({
                         code: 'NOT_FOUND',
@@ -187,7 +246,6 @@ async function resolveResponse(opts) {
                         message: `Unsupported ${req.method}-request to ${proc._def.type} procedure at path "${call.path}"`
                     });
                 }
-                let abortCtrl;
                 if (proc._def.type === 'subscription') {
                     /* istanbul ignore if -- @preserve */ if (info.isBatchCall) {
                         throw new TRPCError.TRPCError({
@@ -195,19 +253,20 @@ async function resolveResponse(opts) {
                             message: `Cannot batch subscription calls`
                         });
                     }
-                    abortCtrl = new AbortController();
                 }
+                const abortCtrl = new AbortController();
                 const data = await proc({
                     path: call.path,
                     getRawInput: call.getRawInput,
-                    ctx,
+                    ctx: ctxManager.value(),
                     type: proc._def.type,
-                    signal: abortCtrl ? utils.abortSignalsAnyPonyfill([
+                    signal: utils.abortSignalsAnyPonyfill([
                         opts.req.signal,
                         abortCtrl.signal
-                    ]) : opts.req.signal
+                    ])
                 });
                 return [
+                    undefined,
                     {
                         data,
                         abortCtrl
@@ -220,20 +279,20 @@ async function resolveResponse(opts) {
                     error,
                     path: call.path,
                     input,
-                    ctx,
+                    ctx: ctxManager.valueOrUndefined(),
                     type: call.procedure?._def.type ?? 'unknown',
                     req: opts.req
                 });
                 return [
-                    null,
-                    error
+                    error,
+                    undefined
                 ];
             }
         });
         // ----------- response handlers -----------
         if (!info.isBatchCall) {
             const [call] = info.calls;
-            const [result, error] = await rpcCalls[0];
+            const [error, result] = await rpcCalls[0];
             switch(info.type){
                 case 'unknown':
                 case 'mutation':
@@ -250,7 +309,7 @@ async function resolveResponse(opts) {
                         const res = error ? {
                             error: getErrorShape.getErrorShape({
                                 config,
-                                ctx,
+                                ctx: ctxManager.valueOrUndefined(),
                                 error,
                                 input: call.result(),
                                 path: call.path,
@@ -262,7 +321,7 @@ async function resolveResponse(opts) {
                             }
                         };
                         const headResponse = initResponse({
-                            ctx,
+                            ctx: ctxManager.valueOrUndefined(),
                             info,
                             responseMeta: opts.responseMeta,
                             errors: error ? [
@@ -281,48 +340,49 @@ async function resolveResponse(opts) {
                 case 'subscription':
                     {
                         // httpSubscriptionLink
-                        if (!experimentalSSE) {
-                            throw new TRPCError.TRPCError({
-                                code: 'METHOD_NOT_SUPPORTED',
-                                message: 'Missing experimental flag "sseSubscriptions"'
-                            });
-                        }
-                        if (error) {
-                            throw error;
-                        }
-                        const { data , abortCtrl  } = result;
-                        utils.assert(abortCtrl !== undefined, 'subscription type must have an AbortController');
-                        if (!observable.isObservable(data) && !utils.isAsyncIterable(data)) {
-                            throw new TRPCError.TRPCError({
-                                message: `Subscription ${call.path} did not return an observable or a AsyncGenerator`,
-                                code: 'INTERNAL_SERVER_ERROR'
-                            });
-                        }
-                        const dataAsIterable = observable.isObservable(data) ? observable.observableToAsyncIterable(data) : data;
+                        const iterable = utils.run(()=>{
+                            if (error) {
+                                return errorToAsyncIterable(error);
+                            }
+                            if (!experimentalSSE) {
+                                return errorToAsyncIterable(new TRPCError.TRPCError({
+                                    code: 'METHOD_NOT_SUPPORTED',
+                                    message: 'Missing experimental flag "sseSubscriptions"'
+                                }));
+                            }
+                            if (!observable.isObservable(result.data) && !utils.isAsyncIterable(result.data)) {
+                                return errorToAsyncIterable(new TRPCError.TRPCError({
+                                    message: `Subscription ${call.path} did not return an observable or a AsyncGenerator`,
+                                    code: 'INTERNAL_SERVER_ERROR'
+                                }));
+                            }
+                            const dataAsIterable = observable.isObservable(result.data) ? observable.observableToAsyncIterable(result.data) : result.data;
+                            return dataAsIterable;
+                        });
                         const stream = sse.sseStreamProducer({
                             ...config.experimental?.sseSubscriptions,
-                            data: dataAsIterable,
-                            abortCtrl,
+                            data: iterable,
+                            abortCtrl: result?.abortCtrl ?? new AbortController(),
                             serialize: (v)=>config.transformer.output.serialize(v),
                             formatError (errorOpts) {
                                 const error = TRPCError.getTRPCErrorFromUnknown(errorOpts.error);
                                 const input = call?.result();
                                 const path = call?.path;
                                 const type = call?.procedure?._def.type ?? 'unknown';
-                                const shape = getErrorShape.getErrorShape({
-                                    config,
-                                    ctx,
+                                opts.onError?.({
                                     error,
-                                    input,
                                     path,
+                                    input,
+                                    ctx: ctxManager.valueOrUndefined(),
+                                    req: opts.req,
                                     type
                                 });
-                                opts.onError?.({
+                                const shape = getErrorShape.getErrorShape({
+                                    config,
+                                    ctx: ctxManager.valueOrUndefined(),
                                     error,
-                                    path,
                                     input,
-                                    ctx,
-                                    req: opts.req,
+                                    path,
                                     type
                                 });
                                 return shape;
@@ -332,7 +392,7 @@ async function resolveResponse(opts) {
                             headers.set(key, value);
                         }
                         const headResponse1 = initResponse({
-                            ctx,
+                            ctx: ctxManager.valueOrUndefined(),
                             info,
                             responseMeta: opts.responseMeta,
                             errors: [],
@@ -352,7 +412,7 @@ async function resolveResponse(opts) {
             headers.set('content-type', 'application/json');
             headers.set('transfer-encoding', 'chunked');
             const headResponse2 = initResponse({
-                ctx,
+                ctx: ctxManager.valueOrUndefined(),
                 info,
                 responseMeta: opts.responseMeta,
                 errors: [],
@@ -374,13 +434,13 @@ async function resolveResponse(opts) {
          * }
          */ maxDepth: experimentalIterablesAndDeferreds ? 4 : 3,
                 data: rpcCalls.map(async (res)=>{
-                    const [result, error] = await res;
+                    const [error, result] = await res;
                     const call = info.calls[0];
                     if (error) {
                         return {
                             error: getErrorShape.getErrorShape({
                                 config,
-                                ctx,
+                                ctx: ctxManager.valueOrUndefined(),
                                 error,
                                 input: call.result(),
                                 path: call.path,
@@ -388,14 +448,13 @@ async function resolveResponse(opts) {
                             })
                         };
                     }
-                    const { data  } = result;
                     /**
            * Not very pretty, but we need to wrap nested data in promises
            * Our stream producer will only resolve top-level async values or async values that are directly nested in another async value
-           */ const dataAsPromiseOrIterable = observable.isObservable(data) ? observable.observableToAsyncIterable(data) : Promise.resolve(data);
+           */ const iterable = observable.isObservable(result.data) ? observable.observableToAsyncIterable(result.data) : Promise.resolve(result.data);
                     return {
                         result: Promise.resolve({
-                            data: dataAsPromiseOrIterable
+                            data: iterable
                         })
                     };
                 }),
@@ -405,20 +464,25 @@ async function resolveResponse(opts) {
                         error: TRPCError.getTRPCErrorFromUnknown(cause),
                         path: undefined,
                         input: undefined,
-                        ctx,
+                        ctx: ctxManager.valueOrUndefined(),
                         req: opts.req,
                         type: info?.type ?? 'unknown'
                     });
                 },
                 formatError (errorOpts) {
                     const call = info?.calls[errorOpts.path[0]];
+                    const error = TRPCError.getTRPCErrorFromUnknown(errorOpts.error);
+                    const input = call?.result();
+                    const path = call?.path;
+                    const type = call?.procedure?._def.type ?? 'unknown';
+                    // no need to call `onError` here as it will be propagated through the stream itself
                     const shape = getErrorShape.getErrorShape({
                         config,
-                        ctx,
-                        error: TRPCError.getTRPCErrorFromUnknown(errorOpts.error),
-                        input: call?.result(),
-                        path: call?.path,
-                        type: call?.procedure?._def.type ?? 'unknown'
+                        ctx: ctxManager.valueOrUndefined(),
+                        error,
+                        input,
+                        path,
+                        type
                     });
                     return shape;
                 }
@@ -436,28 +500,28 @@ async function resolveResponse(opts) {
      * - return a complete HTTPResponse
      */ headers.set('content-type', 'application/json');
         const results = (await Promise.all(rpcCalls)).map((res)=>{
-            const [result, error] = res;
+            const [error, result] = res;
             if (error) {
                 return res;
             }
             if (isDataStream(result.data)) {
                 return [
-                    null,
                     new TRPCError.TRPCError({
                         code: 'UNSUPPORTED_MEDIA_TYPE',
                         message: 'Cannot use stream-like response in non-streaming request - use httpBatchStreamLink'
-                    })
+                    }),
+                    undefined
                 ];
             }
             return res;
         });
-        const resultAsRPCResponse = results.map(([result, error], index)=>{
+        const resultAsRPCResponse = results.map(([error, result], index)=>{
             const call = info.calls[index];
             if (error) {
                 return {
                     error: getErrorShape.getErrorShape({
                         config,
-                        ctx,
+                        ctx: ctxManager.valueOrUndefined(),
                         error,
                         input: call.result(),
                         path: call.path,
@@ -471,9 +535,9 @@ async function resolveResponse(opts) {
                 }
             };
         });
-        const errors = results.map(([_, error])=>error).filter(Boolean);
+        const errors = results.map(([error])=>error).filter(Boolean);
         const headResponse3 = initResponse({
-            ctx,
+            ctx: ctxManager.valueOrUndefined(),
             info,
             responseMeta: opts.responseMeta,
             untransformedJSON: resultAsRPCResponse,
@@ -485,6 +549,8 @@ async function resolveResponse(opts) {
             headers
         });
     } catch (cause) {
+        const [_infoError, info1] = infoTuple;
+        const ctx = ctxManager.valueOrUndefined();
         // we get here if
         // - batching is called when it's not enabled
         // - `createContext()` throws
@@ -494,12 +560,12 @@ async function resolveResponse(opts) {
         // - `errorFormatter` return value is malformed
         const { error: error1 , untransformedJSON , body  } = caughtErrorToData(cause, {
             opts,
-            ctx,
-            type: info?.type ?? 'unknown'
+            ctx: ctxManager.valueOrUndefined(),
+            type: info1?.type ?? 'unknown'
         });
         const headResponse4 = initResponse({
             ctx,
-            info,
+            info: info1,
             responseMeta: opts.responseMeta,
             untransformedJSON,
             errors: [