@trpc/server 10.0.0-proxy-alpha.76 → 10.0.0-proxy-alpha.78

package/dist/resolveHTTPResponse-d7a8a210.js

@@ -1,264 +0,0 @@
-'use strict';
-
-var TRPCError = require('./TRPCError-fe9113e5.js');
-var transformTRPCResponse = require('./transformTRPCResponse-11ac69cc.js');
-var codes = require('./codes-1c24d919.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');
-    }
-}
-
-function invert(obj) {
-    const newObj = Object.create(null);
-    for(const key in obj){
-        const v = obj[key];
-        newObj[v] = key;
-    }
-    return newObj;
-}
-
-const TRPC_ERROR_CODES_BY_NUMBER = invert(codes.TRPC_ERROR_CODES_BY_KEY);
-const JSONRPC2_TO_HTTP_CODE = {
-    PARSE_ERROR: 400,
-    BAD_REQUEST: 400,
-    NOT_FOUND: 404,
-    INTERNAL_SERVER_ERROR: 500,
-    UNAUTHORIZED: 401,
-    FORBIDDEN: 403,
-    TIMEOUT: 408,
-    CONFLICT: 409,
-    CLIENT_CLOSED_REQUEST: 499,
-    PRECONDITION_FAILED: 412,
-    PAYLOAD_TOO_LARGE: 413,
-    METHOD_NOT_SUPPORTED: 405
-};
-function getStatusCodeFromKey(code) {
-    return JSONRPC2_TO_HTTP_CODE[code] ?? 500;
-}
-function getHTTPStatusCode(json) {
-    const arr = Array.isArray(json) ? json : [
-        json
-    ];
-    const httpStatuses = new Set(arr.map((res)=>{
-        if ('error' in res) {
-            const data = res.error.data;
-            if (typeof data.httpStatus === 'number') {
-                return data.httpStatus;
-            }
-            const code = TRPC_ERROR_CODES_BY_NUMBER[res.error.code];
-            return getStatusCodeFromKey(code);
-        }
-        return 200;
-    }));
-    if (httpStatuses.size !== 1) {
-        return 207;
-    }
-    const httpStatus = httpStatuses.values().next().value;
-    return httpStatus;
-}
-function getHTTPStatusCodeFromError(error) {
-    const { code  } = error;
-    return getStatusCodeFromKey(code);
-}
-
-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 = 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 caller = router.createCaller(ctx);
-                const output = await caller[type](path, input);
-                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.assertNotBrowser = assertNotBrowser;
-exports.getHTTPStatusCodeFromError = getHTTPStatusCodeFromError;
-exports.resolveHTTPResponse = resolveHTTPResponse;