@trpc/server 11.0.0-next.91 → 11.0.0-rc.329

package/dist/observable/operators/tap.d.ts

@@ -1,3 +0,0 @@
-import { MonoTypeOperatorFunction, Observer } from '../types';
-export declare function tap<TValue, TError>(observer: Partial<Observer<TValue, TError>>): MonoTypeOperatorFunction<TValue, TError>;
-//# sourceMappingURL=tap.d.ts.map

package/dist/observable/operators/tap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tap.d.ts","sourceRoot":"","sources":["../../../src/observable/operators/tap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAE9D,wBAAgB,GAAG,CAAC,MAAM,EAAE,MAAM,EAChC,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAC1C,wBAAwB,CAAC,MAAM,EAAE,MAAM,CAAC,CAqB1C"}

package/dist/observable-15588f28.js

@@ -1,83 +0,0 @@
-function identity(x) {
-    return x;
-}
-
-/** @internal */
-function pipeFromArray(fns) {
-    if (fns.length === 0) {
-        return identity;
-    }
-    if (fns.length === 1) {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        return fns[0];
-    }
-    return function piped(input) {
-        return fns.reduce((prev, fn) => fn(prev), input);
-    };
-}
-
-function isObservable(x) {
-    return typeof x === 'object' && x !== null && 'subscribe' in x;
-}
-function observable(subscribe) {
-    const self = {
-        subscribe(observer) {
-            let teardownRef = null;
-            let isDone = false;
-            let unsubscribed = false;
-            let teardownImmediately = false;
-            function unsubscribe() {
-                if (teardownRef === null) {
-                    teardownImmediately = true;
-                    return;
-                }
-                if (unsubscribed) {
-                    return;
-                }
-                unsubscribed = true;
-                if (typeof teardownRef === 'function') {
-                    teardownRef();
-                }
-                else if (teardownRef) {
-                    teardownRef.unsubscribe();
-                }
-            }
-            teardownRef = subscribe({
-                next(value) {
-                    if (isDone) {
-                        return;
-                    }
-                    observer.next?.(value);
-                },
-                error(err) {
-                    if (isDone) {
-                        return;
-                    }
-                    isDone = true;
-                    observer.error?.(err);
-                    unsubscribe();
-                },
-                complete() {
-                    if (isDone) {
-                        return;
-                    }
-                    isDone = true;
-                    observer.complete?.();
-                    unsubscribe();
-                },
-            });
-            if (teardownImmediately) {
-                unsubscribe();
-            }
-            return {
-                unsubscribe,
-            };
-        },
-        pipe(...operations) {
-            return pipeFromArray(operations)(self);
-        },
-    };
-    return self;
-}
-
-export { isObservable as i, observable as o };

package/dist/resolveHTTPResponse-8d474952.js

@@ -1,267 +0,0 @@
-import { b as callProcedure } from './router-a1635eab.js';
-import { T as TRPCError, g as getTRPCErrorFromUnknown } from './TRPCError-efecb077.js';
-import './config-5de7eae5.js';
-import { t as transformTRPCResponse, g as getErrorShape } from './transformTRPCResponse-20ce3b68.js';
-import { g as getJsonContentTypeInputs } from './contentType-9940f5d7.js';
-import { b as getHTTPStatusCode } from './index-46cb3130.js';
-
-const HTTP_METHOD_PROCEDURE_TYPE_MAP = {
-    GET: 'query',
-    POST: 'mutation',
-};
-const fallbackContentTypeHandler = {
-    getInputs: getJsonContentTypeInputs,
-};
-function initResponse(initOpts) {
-    const { ctx, paths, type, responseMeta, untransformedJSON, errors = [], } = initOpts;
-    let status = untransformedJSON ? 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 callProcedure({
-            procedures: opts.router._def.procedures,
-            path,
-            getRawInput: async () => input,
-            ctx,
-            type,
-        });
-        return {
-            result: {
-                data,
-            },
-        };
-    }
-    catch (cause) {
-        const error = getTRPCErrorFromUnknown(cause);
-        opts.onError?.({ error, path, input, ctx, type: type, req: opts.req });
-        return {
-            error: getErrorShape({
-                config: opts.router._def._config,
-                error,
-                type,
-                path,
-                input,
-                ctx,
-            }),
-        };
-    }
-}
-function caughtErrorToData(cause, errorOpts) {
-    const { router, req, onError } = errorOpts.opts;
-    const error = getTRPCErrorFromUnknown(cause);
-    onError?.({
-        error,
-        path: errorOpts.path,
-        input: errorOpts.input,
-        ctx: errorOpts.ctx,
-        type: errorOpts.type,
-        req,
-    });
-    const untransformedJSON = {
-        error: getErrorShape({
-            config: router._def._config,
-            error,
-            type: errorOpts.type,
-            path: errorOpts.path,
-            input: errorOpts.input,
-            ctx: errorOpts.ctx,
-        }),
-    };
-    const transformedJSON = transformTRPCResponse(router._def._config, untransformedJSON);
-    const body = JSON.stringify(transformedJSON);
-    return {
-        error,
-        untransformedJSON,
-        body,
-    };
-}
-// implementation
-async function resolveHTTPResponse(opts) {
-    const { router, 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({
-                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 inputs = await contentTypeHandler.getInputs({
-            isBatchCall,
-            req,
-            router,
-            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 headResponse = initResponse({
-                ctx,
-                paths,
-                type,
-                responseMeta: opts.responseMeta,
-                untransformedJSON,
-                errors,
-            });
-            unstable_onHead?.(headResponse, 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 = transformTRPCResponse(router._def._config, result);
-            const body = JSON.stringify(transformedJSON);
-            unstable_onChunk?.([-1, body]);
-            return {
-                status: headResponse.status,
-                headers: headResponse.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 headResponse = initResponse({
-            ctx,
-            paths,
-            type,
-            responseMeta: opts.responseMeta,
-        });
-        unstable_onHead(headResponse, true);
-        const indexedPromises = new Map(promises.map((promise, index) => [
-            index,
-            promise.then((r) => [index, r]),
-        ]));
-        for (const _ of paths) {
-            const [index, untransformedJSON] = await Promise.race(indexedPromises.values());
-            indexedPromises.delete(index);
-            try {
-                const transformedJSON = transformTRPCResponse(router._def._config, untransformedJSON);
-                const body = JSON.stringify(transformedJSON);
-                unstable_onChunk([index, body]);
-            }
-            catch (cause) {
-                const path = paths[index];
-                const input = inputs[index];
-                const { body } = caughtErrorToData(cause, {
-                    opts,
-                    ctx,
-                    type,
-                    path,
-                    input,
-                });
-                unstable_onChunk([index, body]);
-            }
-        }
-        return;
-    }
-    catch (cause) {
-        // 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, body } = caughtErrorToData(cause, {
-            opts,
-            ctx,
-            type,
-        });
-        const headResponse = initResponse({
-            ctx,
-            paths,
-            type,
-            responseMeta: opts.responseMeta,
-            untransformedJSON,
-            errors: [error],
-        });
-        unstable_onHead?.(headResponse, false);
-        unstable_onChunk?.([-1, body]);
-        return {
-            status: headResponse.status,
-            headers: headResponse.headers,
-            body,
-        };
-    }
-}
-
-export { resolveHTTPResponse as r };

package/dist/router-3c22fe56.js

@@ -1,159 +0,0 @@
-'use strict';
-
-var TRPCError = require('./TRPCError-ae7b67e8.js');
-var index = require('./index-784ff647.js');
-var codes = require('./codes-87f6824b.js');
-
-/**
- * @public
- */ /**
- * @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
-    }
-};
-
-const defaultFormatter = ({ shape  })=>{
-    return shape;
-};
-
-/**
- * Create an object without inheriting anything from `Object.prototype`
- * @internal
- */ function omitPrototype(obj) {
-    return Object.assign(Object.create(null), obj);
-}
-
-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 = index.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;
-            },
-            getErrorShape (opts) {
-                const { path , error  } = opts;
-                const { code  } = opts.error;
-                const shape = {
-                    message: error.message,
-                    code: codes.TRPC_ERROR_CODES_BY_KEY[code],
-                    data: {
-                        code,
-                        httpStatus: index.getHTTPStatusCodeFromError(error)
-                    }
-                };
-                if (config.isDev && typeof opts.error.stack === 'string') {
-                    shape.data.stack = opts.error.stack;
-                }
-                if (typeof path === 'string') {
-                    shape.data.path = path;
-                }
-                return this._def._config.errorFormatter({
-                    ...opts,
-                    shape
-                });
-            }
-        };
-        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.TRPCError({
-            code: 'NOT_FOUND',
-            message: `No "${type}"-procedure on path "${path}"`
-        });
-    }
-    return proc(opts);
-}
-
-exports.callProcedure = callProcedure;
-exports.createRouterFactory = createRouterFactory;
-exports.defaultFormatter = defaultFormatter;
-exports.defaultTransformer = defaultTransformer;
-exports.getDataTransformer = getDataTransformer;

package/dist/router-5274e533.mjs

@@ -1,153 +0,0 @@
-import { T as TRPCError } from './TRPCError-816ff32e.mjs';
-import { a as createRecursiveProxy, g as getHTTPStatusCodeFromError } from './index-f91d720c.mjs';
-import { T as TRPC_ERROR_CODES_BY_KEY } from './codes-c924c3db.mjs';
-
-/**
- * @public
- */ /**
- * @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
-    }
-};
-
-const defaultFormatter = ({ shape  })=>{
-    return shape;
-};
-
-/**
- * Create an object without inheriting anything from `Object.prototype`
- * @internal
- */ function omitPrototype(obj) {
-    return Object.assign(Object.create(null), obj);
-}
-
-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;
-            },
-            getErrorShape (opts) {
-                const { path , error  } = opts;
-                const { code  } = opts.error;
-                const shape = {
-                    message: error.message,
-                    code: TRPC_ERROR_CODES_BY_KEY[code],
-                    data: {
-                        code,
-                        httpStatus: getHTTPStatusCodeFromError(error)
-                    }
-                };
-                if (config.isDev && typeof opts.error.stack === 'string') {
-                    shape.data.stack = opts.error.stack;
-                }
-                if (typeof path === 'string') {
-                    shape.data.path = path;
-                }
-                return this._def._config.errorFormatter({
-                    ...opts,
-                    shape
-                });
-            }
-        };
-        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);
-}
-
-export { defaultTransformer as a, callProcedure as b, createRouterFactory as c, defaultFormatter as d, getDataTransformer as g };