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

package/dist/router-3344b52a.js

@@ -1,262 +0,0 @@
-'use strict';
-
-var createProxy = require('./createProxy-7e413449.js');
-var TRPCError = require('./TRPCError-e2c8eb77.js');
-var rootConfig = require('./rootConfig-3371c473.js');
-
-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 && (!rootConfig.isObject(result.error.error) || typeof result.error.error['code'] !== 'number')) {
-        throw new TransformResultError();
-    }
-    if (result.ok && !rootConfig.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 = rootConfig.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 = createProxy.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.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 = createProxy.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 = rootConfig.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;
-}
-
-exports.callProcedure = callProcedure;
-exports.createCallerFactory = createCallerFactory;
-exports.createRouterFactory = createRouterFactory;
-exports.defaultFormatter = defaultFormatter;
-exports.defaultTransformer = defaultTransformer;
-exports.getDataTransformer = getDataTransformer;
-exports.mergeRouters = mergeRouters;
-exports.transformResult = transformResult;
-exports.transformTRPCResponse = transformTRPCResponse;

package/dist/router-919c37eb.js

@@ -1,259 +0,0 @@
-import { c as createRecursiveProxy } from './createProxy-dce0c414.js';
-import { T as TRPCError } from './TRPCError-10da405a.js';
-import { i as isObject, m as mergeWithoutOverrides, o as omitPrototype } from './rootConfig-571c9267.js';
-
-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 };