@trpc/server 11.0.0-alpha-tmp-export-from-main-nuke-core.219 → 11.0.0-alpha-tmp-export-from-main.211

package/dist/resolveHTTPResponse-9e260431.js

@@ -1,293 +0,0 @@
-'use strict';
-
-var createProxy = require('./createProxy-c5cd21e8.js');
-var TRPCError = require('./TRPCError-57838b33.js');
-var router = require('./router-7a7bb4fd.js');
-var contentType = require('./contentType-b31eab56.js');
-
-const HTTP_METHOD_PROCEDURE_TYPE_MAP = {
-    GET: 'query',
-    POST: 'mutation'
-};
-const fallbackContentTypeHandler = {
-    getInputs: contentType.getJsonContentTypeInputs
-};
-function initResponse(initOpts) {
-    const { ctx , paths , type , responseMeta , untransformedJSON , errors =[] ,  } = initOpts;
-    let status = untransformedJSON ? createProxy.getHTTPStatusCode(untransformedJSON) : 200;
-    const headers = {
-        'Content-Type': 'application/json'
-    };
-    const eagerGeneration = !untransformedJSON;
-    const data = eagerGeneration ? [] : Array.isArray(untransformedJSON) ? untransformedJSON : [
-        untransformedJSON
-    ];
-    const meta = responseMeta?.({
-        ctx,
-        paths,
-        type,
-        data,
-        errors,
-        eagerGeneration
-    }) ?? {};
-    for (const [key, value] of Object.entries(meta.headers ?? {})){
-        headers[key] = value;
-    }
-    if (meta.status) {
-        status = meta.status;
-    }
-    return {
-        status,
-        headers
-    };
-}
-async function inputToProcedureCall(procedureOpts) {
-    const { opts , ctx , type , input , path  } = procedureOpts;
-    try {
-        const data = await router.callProcedure({
-            procedures: opts.router._def.procedures,
-            path,
-            getRawInput: async ()=>input,
-            ctx,
-            type
-        });
-        return {
-            result: {
-                data
-            }
-        };
-    } catch (cause) {
-        const error = TRPCError.getTRPCErrorFromUnknown(cause);
-        opts.onError?.({
-            error,
-            path,
-            input,
-            ctx,
-            type: type,
-            req: opts.req
-        });
-        return {
-            error: createProxy.getErrorShape({
-                config: opts.router._def._config,
-                error,
-                type,
-                path,
-                input,
-                ctx
-            })
-        };
-    }
-}
-function caughtErrorToData(cause, errorOpts) {
-    const { router: router$1 , req , onError  } = errorOpts.opts;
-    const error = TRPCError.getTRPCErrorFromUnknown(cause);
-    onError?.({
-        error,
-        path: errorOpts.path,
-        input: errorOpts.input,
-        ctx: errorOpts.ctx,
-        type: errorOpts.type,
-        req
-    });
-    const untransformedJSON = {
-        error: createProxy.getErrorShape({
-            config: router$1._def._config,
-            error,
-            type: errorOpts.type,
-            path: errorOpts.path,
-            input: errorOpts.input,
-            ctx: errorOpts.ctx
-        })
-    };
-    const transformedJSON = router.transformTRPCResponse(router$1._def._config, untransformedJSON);
-    const body = JSON.stringify(transformedJSON);
-    return {
-        error,
-        untransformedJSON,
-        body
-    };
-}
-// implementation
-async function resolveHTTPResponse(opts) {
-    const { router: router$1 , req , unstable_onHead , unstable_onChunk  } = opts;
-    if (req.method === 'HEAD') {
-        // can be used for lambda warmup
-        const headResponse = {
-            status: 204
-        };
-        unstable_onHead?.(headResponse, false);
-        unstable_onChunk?.([
-            -1,
-            ''
-        ]);
-        return headResponse;
-    }
-    const contentTypeHandler = opts.contentTypeHandler ?? fallbackContentTypeHandler;
-    const batchingEnabled = opts.batching?.enabled ?? true;
-    const type = HTTP_METHOD_PROCEDURE_TYPE_MAP[req.method] ?? 'unknown';
-    let ctx = undefined;
-    let paths;
-    const isBatchCall = !!req.query.get('batch');
-    const isStreamCall = isBatchCall && unstable_onHead && unstable_onChunk && req.headers['trpc-batch-mode'] === 'stream';
-    try {
-        if (opts.error) {
-            throw opts.error;
-        }
-        if (isBatchCall && !batchingEnabled) {
-            throw new Error(`Batching is not enabled on the server`);
-        }
-        /* istanbul ignore if -- @preserve */ 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 inputs = await contentTypeHandler.getInputs({
-            isBatchCall,
-            req,
-            router: router$1,
-            preprocessedBody: opts.preprocessedBody ?? false
-        });
-        paths = isBatchCall ? decodeURIComponent(opts.path).split(',') : [
-            opts.path
-        ];
-        const info = {
-            isBatchCall,
-            calls: paths.map((path, idx)=>({
-                    path,
-                    type,
-                    input: inputs[idx] ?? undefined
-                }))
-        };
-        ctx = await opts.createContext({
-            info
-        });
-        const promises = paths.map((path, index)=>inputToProcedureCall({
-                opts,
-                ctx,
-                type,
-                input: inputs[index],
-                path
-            }));
-        if (!isStreamCall) {
-            /**
-       * Non-streaming response:
-       * - await all responses in parallel, blocking on the slowest one
-       * - create headers with known response body
-       * - return a complete HTTPResponse
-       */ const untransformedJSON = await Promise.all(promises);
-            const errors = untransformedJSON.flatMap((response)=>'error' in response ? [
-                    response.error
-                ] : []);
-            const headResponse1 = initResponse({
-                ctx,
-                paths,
-                type,
-                responseMeta: opts.responseMeta,
-                untransformedJSON,
-                errors
-            });
-            unstable_onHead?.(headResponse1, false);
-            // return body stuff
-            const result = isBatchCall ? untransformedJSON : untransformedJSON[0]; // eslint-disable-line @typescript-eslint/no-non-null-assertion -- `untransformedJSON` should be the length of `paths` which should be at least 1 otherwise there wouldn't be a request at all
-            const transformedJSON = router.transformTRPCResponse(router$1._def._config, result);
-            const body = JSON.stringify(transformedJSON);
-            unstable_onChunk?.([
-                -1,
-                body
-            ]);
-            return {
-                status: headResponse1.status,
-                headers: headResponse1.headers,
-                body
-            };
-        }
-        /**
-     * Streaming response:
-     * - block on none, call `onChunk` as soon as each response is ready
-     * - create headers with minimal data (cannot know the response body in advance)
-     * - return void
-     */ const headResponse2 = initResponse({
-            ctx,
-            paths,
-            type,
-            responseMeta: opts.responseMeta
-        });
-        unstable_onHead(headResponse2, true);
-        const indexedPromises = new Map(promises.map((promise, index)=>[
-                index,
-                promise.then((r)=>[
-                        index,
-                        r
-                    ])
-            ]));
-        for (const _ of paths){
-            const [index, untransformedJSON1] = await Promise.race(indexedPromises.values());
-            indexedPromises.delete(index);
-            try {
-                const transformedJSON1 = router.transformTRPCResponse(router$1._def._config, untransformedJSON1);
-                const body1 = JSON.stringify(transformedJSON1);
-                unstable_onChunk([
-                    index,
-                    body1
-                ]);
-            } catch (cause) {
-                const path = paths[index];
-                const input = inputs[index];
-                const { body: body2  } = caughtErrorToData(cause, {
-                    opts,
-                    ctx,
-                    type,
-                    path,
-                    input
-                });
-                unstable_onChunk([
-                    index,
-                    body2
-                ]);
-            }
-        }
-        return;
-    } catch (cause1) {
-        // we get here if
-        // - batching is called when it's not enabled
-        // - `createContext()` throws
-        // - `router._def._config.transformer.output.serialize()` throws
-        // - post body is too large
-        // - input deserialization fails
-        // - `errorFormatter` return value is malformed
-        const { error , untransformedJSON: untransformedJSON2 , body: body3  } = caughtErrorToData(cause1, {
-            opts,
-            ctx,
-            type
-        });
-        const headResponse3 = initResponse({
-            ctx,
-            paths,
-            type,
-            responseMeta: opts.responseMeta,
-            untransformedJSON: untransformedJSON2,
-            errors: [
-                error
-            ]
-        });
-        unstable_onHead?.(headResponse3, false);
-        unstable_onChunk?.([
-            -1,
-            body3
-        ]);
-        return {
-            status: headResponse3.status,
-            headers: headResponse3.headers,
-            body: body3
-        };
-    }
-}
-
-exports.resolveHTTPResponse = resolveHTTPResponse;

package/dist/rootConfig-a1ad09d0.js

@@ -1,48 +0,0 @@
-import { i as invert } from './utils-e1d51fac.js';
-
-// reference: https://www.jsonrpc.org/specification
-/**
- * JSON-RPC 2.0 Error codes
- *
- * `-32000` to `-32099` are reserved for implementation-defined server-errors.
- * For tRPC we're copying the last digits of HTTP 4XX errors.
- */
-const TRPC_ERROR_CODES_BY_KEY = {
-    /**
-     * Invalid JSON was received by the server.
-     * An error occurred on the server while parsing the JSON text.
-     */
-    PARSE_ERROR: -32700,
-    /**
-     * The JSON sent is not a valid Request object.
-     */
-    BAD_REQUEST: -32600, // 400
-    // Internal JSON-RPC error
-    INTERNAL_SERVER_ERROR: -32603,
-    NOT_IMPLEMENTED: -32603,
-    // Implementation specific errors
-    UNAUTHORIZED: -32001, // 401
-    FORBIDDEN: -32003, // 403
-    NOT_FOUND: -32004, // 404
-    METHOD_NOT_SUPPORTED: -32005, // 405
-    TIMEOUT: -32008, // 408
-    CONFLICT: -32009, // 409
-    PRECONDITION_FAILED: -32012, // 412
-    PAYLOAD_TOO_LARGE: -32013, // 413
-    UNPROCESSABLE_CONTENT: -32022, // 422
-    TOO_MANY_REQUESTS: -32029, // 429
-    CLIENT_CLOSED_REQUEST: -32099, // 499
-};
-const TRPC_ERROR_CODES_BY_NUMBER = invert(TRPC_ERROR_CODES_BY_KEY);
-
-/**
- * The default check to see if we're in a server
- */
-const isServerDefault = typeof window === 'undefined' ||
-    'Deno' in window ||
-    // eslint-disable-next-line @typescript-eslint/dot-notation
-    globalThis.process?.env?.['NODE_ENV'] === 'test' ||
-    !!globalThis.process?.env?.['JEST_WORKER_ID'] ||
-    !!globalThis.process?.env?.['VITEST_WORKER_ID'];
-
-export { TRPC_ERROR_CODES_BY_NUMBER as T, TRPC_ERROR_CODES_BY_KEY as a, isServerDefault as i };

package/dist/rootConfig-db88d377.js

@@ -1,44 +0,0 @@
-'use strict';
-
-var utils = require('./utils-42a3ba6d.js');
-
-// reference: https://www.jsonrpc.org/specification
-/**
- * JSON-RPC 2.0 Error codes
- *
- * `-32000` to `-32099` are reserved for implementation-defined server-errors.
- * For tRPC we're copying the last digits of HTTP 4XX errors.
- */ const TRPC_ERROR_CODES_BY_KEY = {
-    /**
-   * Invalid JSON was received by the server.
-   * An error occurred on the server while parsing the JSON text.
-   */ PARSE_ERROR: -32700,
-    /**
-   * The JSON sent is not a valid Request object.
-   */ BAD_REQUEST: -32600,
-    // Internal JSON-RPC error
-    INTERNAL_SERVER_ERROR: -32603,
-    NOT_IMPLEMENTED: -32603,
-    // Implementation specific errors
-    UNAUTHORIZED: -32001,
-    FORBIDDEN: -32003,
-    NOT_FOUND: -32004,
-    METHOD_NOT_SUPPORTED: -32005,
-    TIMEOUT: -32008,
-    CONFLICT: -32009,
-    PRECONDITION_FAILED: -32012,
-    PAYLOAD_TOO_LARGE: -32013,
-    UNPROCESSABLE_CONTENT: -32022,
-    TOO_MANY_REQUESTS: -32029,
-    CLIENT_CLOSED_REQUEST: -32099
-};
-const TRPC_ERROR_CODES_BY_NUMBER = utils.invert(TRPC_ERROR_CODES_BY_KEY);
-
-/**
- * The default check to see if we're in a server
- */ const isServerDefault = typeof window === 'undefined' || 'Deno' in window || // eslint-disable-next-line @typescript-eslint/dot-notation
-globalThis.process?.env?.['NODE_ENV'] === 'test' || !!globalThis.process?.env?.['JEST_WORKER_ID'] || !!globalThis.process?.env?.['VITEST_WORKER_ID'];
-
-exports.TRPC_ERROR_CODES_BY_KEY = TRPC_ERROR_CODES_BY_KEY;
-exports.TRPC_ERROR_CODES_BY_NUMBER = TRPC_ERROR_CODES_BY_NUMBER;
-exports.isServerDefault = isServerDefault;

package/dist/rootConfig-f741a4e7.mjs

@@ -1,40 +0,0 @@
-import { i as invert } from './utils-cf6178ec.mjs';
-
-// reference: https://www.jsonrpc.org/specification
-/**
- * JSON-RPC 2.0 Error codes
- *
- * `-32000` to `-32099` are reserved for implementation-defined server-errors.
- * For tRPC we're copying the last digits of HTTP 4XX errors.
- */ const TRPC_ERROR_CODES_BY_KEY = {
-    /**
-   * Invalid JSON was received by the server.
-   * An error occurred on the server while parsing the JSON text.
-   */ PARSE_ERROR: -32700,
-    /**
-   * The JSON sent is not a valid Request object.
-   */ BAD_REQUEST: -32600,
-    // Internal JSON-RPC error
-    INTERNAL_SERVER_ERROR: -32603,
-    NOT_IMPLEMENTED: -32603,
-    // Implementation specific errors
-    UNAUTHORIZED: -32001,
-    FORBIDDEN: -32003,
-    NOT_FOUND: -32004,
-    METHOD_NOT_SUPPORTED: -32005,
-    TIMEOUT: -32008,
-    CONFLICT: -32009,
-    PRECONDITION_FAILED: -32012,
-    PAYLOAD_TOO_LARGE: -32013,
-    UNPROCESSABLE_CONTENT: -32022,
-    TOO_MANY_REQUESTS: -32029,
-    CLIENT_CLOSED_REQUEST: -32099
-};
-const TRPC_ERROR_CODES_BY_NUMBER = invert(TRPC_ERROR_CODES_BY_KEY);
-
-/**
- * The default check to see if we're in a server
- */ const isServerDefault = typeof window === 'undefined' || 'Deno' in window || // eslint-disable-next-line @typescript-eslint/dot-notation
-globalThis.process?.env?.['NODE_ENV'] === 'test' || !!globalThis.process?.env?.['JEST_WORKER_ID'] || !!globalThis.process?.env?.['VITEST_WORKER_ID'];
-
-export { TRPC_ERROR_CODES_BY_NUMBER as T, TRPC_ERROR_CODES_BY_KEY as a, isServerDefault as i };

package/dist/router-68063d64.mjs

@@ -1,252 +0,0 @@
-import { c as createRecursiveProxy } from './createProxy-7293f632.mjs';
-import { T as TRPCError } from './TRPCError-af754aba.mjs';
-import { a as isObject, m as mergeWithoutOverrides, o as omitPrototype } from './utils-cf6178ec.mjs';
-
-const defaultFormatter = ({ shape  })=>{
-    return shape;
-};
-
-/**
- * @internal
- */ function getDataTransformer(transformer) {
-    if ('input' in transformer) {
-        return transformer;
-    }
-    return {
-        input: transformer,
-        output: transformer
-    };
-}
-/**
- * @internal
- */ const defaultTransformer = {
-    _default: true,
-    input: {
-        serialize: (obj)=>obj,
-        deserialize: (obj)=>obj
-    },
-    output: {
-        serialize: (obj)=>obj,
-        deserialize: (obj)=>obj
-    }
-};
-function transformTRPCResponseItem(config, item) {
-    if ('error' in item) {
-        return {
-            ...item,
-            error: config.transformer.output.serialize(item.error)
-        };
-    }
-    if ('data' in item.result) {
-        return {
-            ...item,
-            result: {
-                ...item.result,
-                data: config.transformer.output.serialize(item.result.data)
-            }
-        };
-    }
-    return item;
-}
-/**
- * Takes a unserialized `TRPCResponse` and serializes it with the router's transformers
- **/ function transformTRPCResponse(config, itemOrItems) {
-    return Array.isArray(itemOrItems) ? itemOrItems.map((item)=>transformTRPCResponseItem(config, item)) : transformTRPCResponseItem(config, itemOrItems);
-}
-// FIXME:
-// - the generics here are probably unnecessary
-// - the RPC-spec could probably be simplified to combine HTTP + WS
-/** @internal */ function transformResultInner(response, transformer) {
-    if ('error' in response) {
-        const error = transformer.deserialize(response.error);
-        return {
-            ok: false,
-            error: {
-                ...response,
-                error
-            }
-        };
-    }
-    const result = {
-        ...response.result,
-        ...(!response.result.type || response.result.type === 'data') && {
-            type: 'data',
-            data: transformer.deserialize(response.result.data)
-        }
-    };
-    return {
-        ok: true,
-        result
-    };
-}
-class TransformResultError extends Error {
-    constructor(){
-        super('Unable to transform response from server');
-    }
-}
-/**
- * Transforms and validates that the result is a valid TRPCResponse
- * @internal
- */ function transformResult(response, transformer) {
-    let result;
-    try {
-        // Use the data transformers on the JSON-response
-        result = transformResultInner(response, transformer);
-    } catch (err) {
-        throw new TransformResultError();
-    }
-    // check that output of the transformers is a valid TRPCResponse
-    if (!result.ok && (!isObject(result.error.error) || typeof result.error.error['code'] !== 'number')) {
-        throw new TransformResultError();
-    }
-    if (result.ok && !isObject(result.result)) {
-        throw new TransformResultError();
-    }
-    return result;
-}
-
-function isRouter(procedureOrRouter) {
-    return 'router' in procedureOrRouter._def;
-}
-const emptyRouter = {
-    _ctx: null,
-    _errorShape: null,
-    _meta: null,
-    queries: {},
-    mutations: {},
-    subscriptions: {},
-    errorFormatter: defaultFormatter,
-    transformer: defaultTransformer
-};
-/**
- * Reserved words that can't be used as router or procedure names
- */ const reservedWords = [
-    /**
-   * Then is a reserved word because otherwise we can't return a promise that returns a Proxy
-   * since JS will think that `.then` is something that exists
-   */ 'then'
-];
-/**
- * @internal
- */ function createRouterFactory(config) {
-    return function createRouterInner(procedures) {
-        const reservedWordsUsed = new Set(Object.keys(procedures).filter((v)=>reservedWords.includes(v)));
-        if (reservedWordsUsed.size > 0) {
-            throw new Error('Reserved words used in `router({})` call: ' + Array.from(reservedWordsUsed).join(', '));
-        }
-        const routerProcedures = omitPrototype({});
-        function recursiveGetPaths(procedures, path = '') {
-            for (const [key, procedureOrRouter] of Object.entries(procedures ?? {})){
-                const newPath = `${path}${key}`;
-                if (isRouter(procedureOrRouter)) {
-                    recursiveGetPaths(procedureOrRouter._def.procedures, `${newPath}.`);
-                    continue;
-                }
-                if (routerProcedures[newPath]) {
-                    throw new Error(`Duplicate key: ${newPath}`);
-                }
-                routerProcedures[newPath] = procedureOrRouter;
-            }
-        }
-        recursiveGetPaths(procedures);
-        const _def = {
-            _config: config,
-            router: true,
-            procedures: routerProcedures,
-            ...emptyRouter,
-            record: procedures
-        };
-        const router = {
-            ...procedures,
-            _def,
-            createCaller (ctx) {
-                const proxy = createRecursiveProxy(({ path , args  })=>{
-                    const fullPath = path.join('.');
-                    const procedure = _def.procedures[fullPath];
-                    return procedure({
-                        path: fullPath,
-                        getRawInput: async ()=>args[0],
-                        ctx,
-                        type: procedure._def.type
-                    });
-                });
-                return proxy;
-            }
-        };
-        return router;
-    };
-}
-function isProcedure(procedureOrRouter) {
-    return !!procedureOrRouter._def.procedure;
-}
-/**
- * @internal
- */ function callProcedure(opts) {
-    const { type , path  } = opts;
-    const proc = opts.procedures[path];
-    if (!proc || !isProcedure(proc) || proc._def.type !== type) {
-        throw new TRPCError({
-            code: 'NOT_FOUND',
-            message: `No "${type}"-procedure on path "${path}"`
-        });
-    }
-    return proc(opts);
-}
-function createCallerFactory() {
-    return function createCallerInner(router) {
-        const _def = router._def;
-        return function createCaller(maybeContext) {
-            const proxy = createRecursiveProxy(({ path , args  })=>{
-                const fullPath = path.join('.');
-                const procedure = _def.procedures[fullPath];
-                const callProc = (ctx)=>procedure({
-                        path: fullPath,
-                        getRawInput: async ()=>args[0],
-                        ctx,
-                        type: procedure._def.type
-                    });
-                if (typeof maybeContext === 'function') {
-                    const context = maybeContext();
-                    if (context instanceof Promise) {
-                        return context.then(callProc);
-                    }
-                    return callProc(context);
-                }
-                return callProc(maybeContext);
-            });
-            return proxy;
-        };
-    };
-}
-function mergeRouters(...routerList) {
-    const record = mergeWithoutOverrides({}, ...routerList.map((r)=>r._def.record));
-    const errorFormatter = routerList.reduce((currentErrorFormatter, nextRouter)=>{
-        if (nextRouter._def._config.errorFormatter && nextRouter._def._config.errorFormatter !== defaultFormatter) {
-            if (currentErrorFormatter !== defaultFormatter && currentErrorFormatter !== nextRouter._def._config.errorFormatter) {
-                throw new Error('You seem to have several error formatters');
-            }
-            return nextRouter._def._config.errorFormatter;
-        }
-        return currentErrorFormatter;
-    }, defaultFormatter);
-    const transformer = routerList.reduce((prev, current)=>{
-        if (current._def._config.transformer && current._def._config.transformer !== defaultTransformer) {
-            if (prev !== defaultTransformer && prev !== current._def._config.transformer) {
-                throw new Error('You seem to have several transformers');
-            }
-            return current._def._config.transformer;
-        }
-        return prev;
-    }, defaultTransformer);
-    const router = createRouterFactory({
-        errorFormatter,
-        transformer,
-        isDev: routerList.some((r)=>r._def._config.isDev),
-        allowOutsideOfServer: routerList.some((r)=>r._def._config.allowOutsideOfServer),
-        isServer: routerList.some((r)=>r._def._config.isServer),
-        $types: routerList[0]?._def._config.$types
-    })(record);
-    return router;
-}
-
-export { defaultTransformer as a, createRouterFactory as b, callProcedure as c, defaultFormatter as d, createCallerFactory as e, transformResult as f, getDataTransformer as g, mergeRouters as m, transformTRPCResponse as t };