@trpc/server 10.0.0-proxy-beta.13 → 10.0.0-proxy-beta.14

package/dist/{nodeHTTPRequestHandler-1bf460cc.mjs → nodeHTTPRequestHandler-205f7545.mjs}

@@ -1,5 +1,5 @@
-import { b as assertNotBrowser, r as resolveHTTPResponse } from './resolveHTTPResponse-f2b378b6.mjs';
-import { T as TRPCError } from './TRPCError-281ac25a.mjs';
+import { r as resolveHTTPResponse } from './resolveHTTPResponse-4ceb1785.mjs';
+import { T as TRPCError } from './TRPCError-e99e7cbe.mjs';
 
 async function getPostBody({ req , maxBodySize  }) {
     return new Promise((resolve)=>{
@@ -34,7 +34,6 @@ async function getPostBody({ req , maxBodySize  }) {
     });
 }
 
-assertNotBrowser();
 async function nodeHTTPRequestHandler(opts) {
     const createContext = async function _createContext() {
         return await opts.createContext?.(opts);

package/dist/{nodeHTTPRequestHandler-71717219.js → nodeHTTPRequestHandler-efc38711.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var resolveHTTPResponse = require('./resolveHTTPResponse-c6e31b55.js');
+var resolveHTTPResponse = require('./resolveHTTPResponse-bf4c6ceb.js');
 var TRPCError = require('./TRPCError-fe9113e5.js');
 
 async function getPostBody({ req , maxBodySize  }) {
@@ -36,7 +36,6 @@ async function getPostBody({ req , maxBodySize  }) {
     });
 }
 
-resolveHTTPResponse.assertNotBrowser();
 async function nodeHTTPRequestHandler(opts) {
     const createContext = async function _createContext() {
         return await opts.createContext?.(opts);

package/dist/resolveHTTPResponse-4ceb1785.mjs

@@ -0,0 +1,205 @@
+import { e as callProcedure, f as getHTTPStatusCode, t as transformTRPCResponse } from './transformTRPCResponse-959de787.mjs';
+import { T as TRPCError, a as getTRPCErrorFromUnknown, g as getCauseFromUnknown } from './TRPCError-e99e7cbe.mjs';
+
+const HTTP_METHOD_PROCEDURE_TYPE_MAP = {
+    GET: 'query',
+    POST: 'mutation'
+};
+function getRawProcedureInputOrThrow(req) {
+    try {
+        if (req.method === 'GET') {
+            if (!req.query.has('input')) {
+                return undefined;
+            }
+            const raw = req.query.get('input');
+            return JSON.parse(raw);
+        }
+        if (typeof req.body === 'string') {
+            // A mutation with no inputs will have req.body === ''
+            return req.body.length === 0 ? undefined : JSON.parse(req.body);
+        }
+        return req.body;
+    } catch (err) {
+        throw new TRPCError({
+            code: 'PARSE_ERROR',
+            cause: getCauseFromUnknown(err)
+        });
+    }
+}
+async function resolveHTTPResponse(opts) {
+    const { createContext , onError , router , req  } = opts;
+    const batchingEnabled = opts.batching?.enabled ?? true;
+    if (req.method === 'HEAD') {
+        // can be used for lambda warmup
+        return {
+            status: 204
+        };
+    }
+    const type = HTTP_METHOD_PROCEDURE_TYPE_MAP[req.method] ?? 'unknown';
+    let ctx = undefined;
+    let paths = undefined;
+    const isBatchCall = !!req.query.get('batch');
+    function endResponse(untransformedJSON, errors) {
+        let status = getHTTPStatusCode(untransformedJSON);
+        const headers = {
+            'Content-Type': 'application/json'
+        };
+        const meta = opts.responseMeta?.({
+            ctx,
+            paths,
+            type,
+            data: Array.isArray(untransformedJSON) ? untransformedJSON : [
+                untransformedJSON
+            ],
+            errors
+        }) ?? {};
+        for (const [key, value] of Object.entries(meta.headers ?? {})){
+            headers[key] = value;
+        }
+        if (meta.status) {
+            status = meta.status;
+        }
+        const transformedJSON = transformTRPCResponse(router, untransformedJSON);
+        const body = JSON.stringify(transformedJSON);
+        return {
+            body,
+            status,
+            headers
+        };
+    }
+    try {
+        if (opts.error) {
+            throw opts.error;
+        }
+        if (isBatchCall && !batchingEnabled) {
+            throw new Error(`Batching is not enabled on the server`);
+        }
+        if (type === 'subscription') {
+            throw new TRPCError({
+                message: 'Subscriptions should use wsLink',
+                code: 'METHOD_NOT_SUPPORTED'
+            });
+        }
+        if (type === 'unknown') {
+            throw new TRPCError({
+                message: `Unexpected request method ${req.method}`,
+                code: 'METHOD_NOT_SUPPORTED'
+            });
+        }
+        const rawInput = getRawProcedureInputOrThrow(req);
+        paths = isBatchCall ? opts.path.split(',') : [
+            opts.path
+        ];
+        ctx = await createContext();
+        const deserializeInputValue = (rawValue)=>{
+            return typeof rawValue !== 'undefined' ? router._def.transformer.input.deserialize(rawValue) : rawValue;
+        };
+        const getInputs = ()=>{
+            if (!isBatchCall) {
+                return {
+                    0: deserializeInputValue(rawInput)
+                };
+            }
+            if (rawInput == null || typeof rawInput !== 'object' || Array.isArray(rawInput)) {
+                throw new TRPCError({
+                    code: 'BAD_REQUEST',
+                    message: '"input" needs to be an object when doing a batch call'
+                });
+            }
+            const input = {};
+            for(const key in rawInput){
+                const k = key;
+                const rawValue = rawInput[k];
+                const value = deserializeInputValue(rawValue);
+                input[k] = value;
+            }
+            return input;
+        };
+        const inputs = getInputs();
+        const rawResults = await Promise.all(paths.map(async (path, index)=>{
+            const input = inputs[index];
+            try {
+                const output = await callProcedure({
+                    procedures: router._def.procedures,
+                    path,
+                    rawInput: input,
+                    ctx,
+                    type
+                });
+                return {
+                    input,
+                    path,
+                    data: output
+                };
+            } catch (cause) {
+                const error = getTRPCErrorFromUnknown(cause);
+                onError?.({
+                    error,
+                    path,
+                    input,
+                    ctx,
+                    type: type,
+                    req
+                });
+                return {
+                    input,
+                    path,
+                    error
+                };
+            }
+        }));
+        const errors = rawResults.flatMap((obj)=>obj.error ? [
+                obj.error
+            ] : []);
+        const resultEnvelopes = rawResults.map((obj)=>{
+            const { path , input  } = obj;
+            if (obj.error) {
+                return {
+                    error: router.getErrorShape({
+                        error: obj.error,
+                        type,
+                        path,
+                        input,
+                        ctx
+                    })
+                };
+            } else {
+                return {
+                    result: {
+                        data: obj.data
+                    }
+                };
+            }
+        });
+        const result = isBatchCall ? resultEnvelopes : resultEnvelopes[0];
+        return endResponse(result, errors);
+    } catch (cause) {
+        // we get here if
+        // - batching is called when it's not enabled
+        // - `createContext()` throws
+        // - post body is too large
+        // - input deserialization fails
+        const error = getTRPCErrorFromUnknown(cause);
+        onError?.({
+            error,
+            path: undefined,
+            input: undefined,
+            ctx,
+            type: type,
+            req
+        });
+        return endResponse({
+            error: router.getErrorShape({
+                error,
+                type,
+                path: undefined,
+                input: undefined,
+                ctx
+            })
+        }, [
+            error
+        ]);
+    }
+}
+
+export { resolveHTTPResponse as r };

package/dist/resolveHTTPResponse-bf4c6ceb.js

@@ -0,0 +1,207 @@
+'use strict';
+
+var transformTRPCResponse = require('./transformTRPCResponse-05aa84c1.js');
+var TRPCError = require('./TRPCError-fe9113e5.js');
+
+const HTTP_METHOD_PROCEDURE_TYPE_MAP = {
+    GET: 'query',
+    POST: 'mutation'
+};
+function getRawProcedureInputOrThrow(req) {
+    try {
+        if (req.method === 'GET') {
+            if (!req.query.has('input')) {
+                return undefined;
+            }
+            const raw = req.query.get('input');
+            return JSON.parse(raw);
+        }
+        if (typeof req.body === 'string') {
+            // A mutation with no inputs will have req.body === ''
+            return req.body.length === 0 ? undefined : JSON.parse(req.body);
+        }
+        return req.body;
+    } catch (err) {
+        throw new TRPCError.TRPCError({
+            code: 'PARSE_ERROR',
+            cause: TRPCError.getCauseFromUnknown(err)
+        });
+    }
+}
+async function resolveHTTPResponse(opts) {
+    const { createContext , onError , router , req  } = opts;
+    const batchingEnabled = opts.batching?.enabled ?? true;
+    if (req.method === 'HEAD') {
+        // can be used for lambda warmup
+        return {
+            status: 204
+        };
+    }
+    const type = HTTP_METHOD_PROCEDURE_TYPE_MAP[req.method] ?? 'unknown';
+    let ctx = undefined;
+    let paths = undefined;
+    const isBatchCall = !!req.query.get('batch');
+    function endResponse(untransformedJSON, errors) {
+        let status = transformTRPCResponse.getHTTPStatusCode(untransformedJSON);
+        const headers = {
+            'Content-Type': 'application/json'
+        };
+        const meta = opts.responseMeta?.({
+            ctx,
+            paths,
+            type,
+            data: Array.isArray(untransformedJSON) ? untransformedJSON : [
+                untransformedJSON
+            ],
+            errors
+        }) ?? {};
+        for (const [key, value] of Object.entries(meta.headers ?? {})){
+            headers[key] = value;
+        }
+        if (meta.status) {
+            status = meta.status;
+        }
+        const transformedJSON = transformTRPCResponse.transformTRPCResponse(router, untransformedJSON);
+        const body = JSON.stringify(transformedJSON);
+        return {
+            body,
+            status,
+            headers
+        };
+    }
+    try {
+        if (opts.error) {
+            throw opts.error;
+        }
+        if (isBatchCall && !batchingEnabled) {
+            throw new Error(`Batching is not enabled on the server`);
+        }
+        if (type === 'subscription') {
+            throw new TRPCError.TRPCError({
+                message: 'Subscriptions should use wsLink',
+                code: 'METHOD_NOT_SUPPORTED'
+            });
+        }
+        if (type === 'unknown') {
+            throw new TRPCError.TRPCError({
+                message: `Unexpected request method ${req.method}`,
+                code: 'METHOD_NOT_SUPPORTED'
+            });
+        }
+        const rawInput = getRawProcedureInputOrThrow(req);
+        paths = isBatchCall ? opts.path.split(',') : [
+            opts.path
+        ];
+        ctx = await createContext();
+        const deserializeInputValue = (rawValue)=>{
+            return typeof rawValue !== 'undefined' ? router._def.transformer.input.deserialize(rawValue) : rawValue;
+        };
+        const getInputs = ()=>{
+            if (!isBatchCall) {
+                return {
+                    0: deserializeInputValue(rawInput)
+                };
+            }
+            if (rawInput == null || typeof rawInput !== 'object' || Array.isArray(rawInput)) {
+                throw new TRPCError.TRPCError({
+                    code: 'BAD_REQUEST',
+                    message: '"input" needs to be an object when doing a batch call'
+                });
+            }
+            const input = {};
+            for(const key in rawInput){
+                const k = key;
+                const rawValue = rawInput[k];
+                const value = deserializeInputValue(rawValue);
+                input[k] = value;
+            }
+            return input;
+        };
+        const inputs = getInputs();
+        const rawResults = await Promise.all(paths.map(async (path, index)=>{
+            const input = inputs[index];
+            try {
+                const output = await transformTRPCResponse.callProcedure({
+                    procedures: router._def.procedures,
+                    path,
+                    rawInput: input,
+                    ctx,
+                    type
+                });
+                return {
+                    input,
+                    path,
+                    data: output
+                };
+            } catch (cause) {
+                const error = TRPCError.getTRPCErrorFromUnknown(cause);
+                onError?.({
+                    error,
+                    path,
+                    input,
+                    ctx,
+                    type: type,
+                    req
+                });
+                return {
+                    input,
+                    path,
+                    error
+                };
+            }
+        }));
+        const errors = rawResults.flatMap((obj)=>obj.error ? [
+                obj.error
+            ] : []);
+        const resultEnvelopes = rawResults.map((obj)=>{
+            const { path , input  } = obj;
+            if (obj.error) {
+                return {
+                    error: router.getErrorShape({
+                        error: obj.error,
+                        type,
+                        path,
+                        input,
+                        ctx
+                    })
+                };
+            } else {
+                return {
+                    result: {
+                        data: obj.data
+                    }
+                };
+            }
+        });
+        const result = isBatchCall ? resultEnvelopes : resultEnvelopes[0];
+        return endResponse(result, errors);
+    } catch (cause) {
+        // we get here if
+        // - batching is called when it's not enabled
+        // - `createContext()` throws
+        // - post body is too large
+        // - input deserialization fails
+        const error = TRPCError.getTRPCErrorFromUnknown(cause);
+        onError?.({
+            error,
+            path: undefined,
+            input: undefined,
+            ctx,
+            type: type,
+            req
+        });
+        return endResponse({
+            error: router.getErrorShape({
+                error,
+                type,
+                path: undefined,
+                input: undefined,
+                ctx
+            })
+        }, [
+            error
+        ]);
+    }
+}
+
+exports.resolveHTTPResponse = resolveHTTPResponse;

package/dist/subscription.mjs

@@ -1,4 +1,4 @@
-import { g as getTRPCErrorFromUnknown } from './TRPCError-281ac25a.mjs';
+import { a as getTRPCErrorFromUnknown } from './TRPCError-e99e7cbe.mjs';
 import { o as observable } from './observable-e129ac9d.mjs';
 
 function subscriptionPullFactory(opts) {

package/dist/{resolveHTTPResponse-c6e31b55.js → transformTRPCResponse-05aa84c1.js}

@@ -3,13 +3,6 @@
 var TRPCError = require('./TRPCError-fe9113e5.js');
 var codes = require('./codes-76c38a34.js');
 var index = require('./index-62d46c97.js');
-var transformTRPCResponse = require('./transformTRPCResponse-11ac69cc.js');
-
-/* istanbul ignore file */ function assertNotBrowser() {
-    if (typeof window !== 'undefined' && !('Deno' in window) && process.env.NODE_ENV !== 'test' && process.env.JEST_WORKER_ID === undefined) {
-        throw new Error('Imported server-only code in the browser');
-    }
-}
 
 const defaultFormatter = ({ shape  })=>{
     return shape;
@@ -255,214 +248,42 @@ const emptyRouter = {
     return procedure(opts);
 }
 
-const HTTP_METHOD_PROCEDURE_TYPE_MAP = {
-    GET: 'query',
-    POST: 'mutation'
-};
-function getRawProcedureInputOrThrow(req) {
-    try {
-        if (req.method === 'GET') {
-            if (!req.query.has('input')) {
-                return undefined;
-            }
-            const raw = req.query.get('input');
-            return JSON.parse(raw);
-        }
-        if (typeof req.body === 'string') {
-            // A mutation with no inputs will have req.body === ''
-            return req.body.length === 0 ? undefined : JSON.parse(req.body);
-        }
-        return req.body;
-    } catch (err) {
-        throw new TRPCError.TRPCError({
-            code: 'PARSE_ERROR',
-            cause: TRPCError.getCauseFromUnknown(err)
-        });
-    }
-}
-async function resolveHTTPResponse(opts) {
-    const { createContext , onError , router , req  } = opts;
-    const batchingEnabled = opts.batching?.enabled ?? true;
-    if (req.method === 'HEAD') {
-        // can be used for lambda warmup
+/**
+ * The default check to see if we're in a server
+ */ const isServerDefault = typeof window === 'undefined' || 'Deno' in window || process.env.NODE_ENV === 'test' || !!process.env.JEST_WORKER_ID;
+
+function transformTRPCResponseItem(router, item) {
+    if ('error' in item) {
         return {
-            status: 204
+            ...item,
+            error: router._def.transformer.output.serialize(item.error)
         };
     }
-    const type = HTTP_METHOD_PROCEDURE_TYPE_MAP[req.method] ?? 'unknown';
-    let ctx = undefined;
-    let paths = undefined;
-    const isBatchCall = !!req.query.get('batch');
-    function endResponse(untransformedJSON, errors) {
-        let status = getHTTPStatusCode(untransformedJSON);
-        const headers = {
-            'Content-Type': 'application/json'
-        };
-        const meta = opts.responseMeta?.({
-            ctx,
-            paths,
-            type,
-            data: Array.isArray(untransformedJSON) ? untransformedJSON : [
-                untransformedJSON
-            ],
-            errors
-        }) ?? {};
-        for (const [key, value] of Object.entries(meta.headers ?? {})){
-            headers[key] = value;
-        }
-        if (meta.status) {
-            status = meta.status;
-        }
-        const transformedJSON = transformTRPCResponse.transformTRPCResponse(router, untransformedJSON);
-        const body = JSON.stringify(transformedJSON);
+    if ('data' in item.result) {
         return {
-            body,
-            status,
-            headers
-        };
-    }
-    try {
-        if (opts.error) {
-            throw opts.error;
-        }
-        if (isBatchCall && !batchingEnabled) {
-            throw new Error(`Batching is not enabled on the server`);
-        }
-        if (type === 'subscription') {
-            throw new TRPCError.TRPCError({
-                message: 'Subscriptions should use wsLink',
-                code: 'METHOD_NOT_SUPPORTED'
-            });
-        }
-        if (type === 'unknown') {
-            throw new TRPCError.TRPCError({
-                message: `Unexpected request method ${req.method}`,
-                code: 'METHOD_NOT_SUPPORTED'
-            });
-        }
-        const rawInput = getRawProcedureInputOrThrow(req);
-        paths = isBatchCall ? opts.path.split(',') : [
-            opts.path
-        ];
-        ctx = await createContext();
-        const deserializeInputValue = (rawValue)=>{
-            return typeof rawValue !== 'undefined' ? router._def.transformer.input.deserialize(rawValue) : rawValue;
-        };
-        const getInputs = ()=>{
-            if (!isBatchCall) {
-                return {
-                    0: deserializeInputValue(rawInput)
-                };
-            }
-            if (rawInput == null || typeof rawInput !== 'object' || Array.isArray(rawInput)) {
-                throw new TRPCError.TRPCError({
-                    code: 'BAD_REQUEST',
-                    message: '"input" needs to be an object when doing a batch call'
-                });
-            }
-            const input = {};
-            for(const key in rawInput){
-                const k = key;
-                const rawValue = rawInput[k];
-                const value = deserializeInputValue(rawValue);
-                input[k] = value;
+            ...item,
+            result: {
+                ...item.result,
+                data: router._def.transformer.output.serialize(item.result.data)
             }
-            return input;
         };
-        const inputs = getInputs();
-        const rawResults = await Promise.all(paths.map(async (path, index)=>{
-            const input = inputs[index];
-            try {
-                const output = await callProcedure({
-                    procedures: router._def.procedures,
-                    path,
-                    rawInput: input,
-                    ctx,
-                    type
-                });
-                return {
-                    input,
-                    path,
-                    data: output
-                };
-            } catch (cause) {
-                const error = TRPCError.getTRPCErrorFromUnknown(cause);
-                onError?.({
-                    error,
-                    path,
-                    input,
-                    ctx,
-                    type: type,
-                    req
-                });
-                return {
-                    input,
-                    path,
-                    error
-                };
-            }
-        }));
-        const errors = rawResults.flatMap((obj)=>obj.error ? [
-                obj.error
-            ] : []);
-        const resultEnvelopes = rawResults.map((obj)=>{
-            const { path , input  } = obj;
-            if (obj.error) {
-                return {
-                    error: router.getErrorShape({
-                        error: obj.error,
-                        type,
-                        path,
-                        input,
-                        ctx
-                    })
-                };
-            } else {
-                return {
-                    result: {
-                        data: obj.data
-                    }
-                };
-            }
-        });
-        const result = isBatchCall ? resultEnvelopes : resultEnvelopes[0];
-        return endResponse(result, errors);
-    } catch (cause) {
-        // we get here if
-        // - batching is called when it's not enabled
-        // - `createContext()` throws
-        // - post body is too large
-        // - input deserialization fails
-        const error = TRPCError.getTRPCErrorFromUnknown(cause);
-        onError?.({
-            error,
-            path: undefined,
-            input: undefined,
-            ctx,
-            type: type,
-            req
-        });
-        return endResponse({
-            error: router.getErrorShape({
-                error,
-                type,
-                path: undefined,
-                input: undefined,
-                ctx
-            })
-        }, [
-            error
-        ]);
     }
+    return item;
+}
+/**
+ * Takes a unserialized `TRPCResponse` and serializes it with the router's transformers
+ **/ function transformTRPCResponse(router, itemOrItems) {
+    return Array.isArray(itemOrItems) ? itemOrItems.map((item)=>transformTRPCResponseItem(router, item)) : transformTRPCResponseItem(router, itemOrItems);
 }
 
-exports.assertNotBrowser = assertNotBrowser;
 exports.callProcedure = callProcedure;
 exports.createRouterFactory = createRouterFactory;
 exports.defaultFormatter = defaultFormatter;
 exports.defaultTransformer = defaultTransformer;
 exports.getDataTransformer = getDataTransformer;
+exports.getHTTPStatusCode = getHTTPStatusCode;
 exports.getHTTPStatusCodeFromError = getHTTPStatusCodeFromError;
+exports.isServerDefault = isServerDefault;
 exports.mergeWithoutOverrides = mergeWithoutOverrides;
 exports.procedureTypes = procedureTypes;
-exports.resolveHTTPResponse = resolveHTTPResponse;
+exports.transformTRPCResponse = transformTRPCResponse;