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

package/dist/internals.d.ts

@@ -3,9 +3,8 @@
  */
 export type { DefaultErrorShape } from './error/formatter';
 export type { mergeRoutersGeneric } from './core/internals/__generated__/mergeRoutersGeneric';
-export type { ProcedureBuilder } from './core/internals/procedureBuilder';
+export type { ProcedureBuilder, BuildProcedure, } from './core/internals/procedureBuilder';
 export type { Overwrite, unsetMarker } from './core/internals/utils';
 export type { MiddlewareFunction } from './core/middleware';
 export type { Router, RouterDef } from './core/router';
-export type { MutationProcedure, QueryProcedure, SubscriptionProcedure, } from './core/procedure';
 //# sourceMappingURL=internals.d.ts.map

package/dist/internals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"internals.d.ts","sourceRoot":"","sources":["../src/internals.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,YAAY,EAAE,mBAAmB,EAAE,MAAM,oDAAoD,CAAC;AAC9F,YAAY,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrE,YAAY,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AACvD,YAAY,EACV,iBAAiB,EACjB,cAAc,EACd,qBAAqB,GACtB,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"internals.d.ts","sourceRoot":"","sources":["../src/internals.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,YAAY,EAAE,mBAAmB,EAAE,MAAM,oDAAoD,CAAC;AAC9F,YAAY,EACV,gBAAgB,EAChB,cAAc,GACf,MAAM,mCAAmC,CAAC;AAC3C,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrE,YAAY,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC"}

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

@@ -1,5 +1,5 @@
-import { b as assertNotBrowser, r as resolveHTTPResponse } from './resolveHTTPResponse-75ea5653.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-831afd20.js → nodeHTTPRequestHandler-efc38711.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var resolveHTTPResponse = require('./resolveHTTPResponse-190892ac.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) {