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

package/dist/router-5a3e1181.mjs

@@ -0,0 +1,252 @@
+import { c as createRecursiveProxy } from './createProxy-f7ba8b4d.mjs';
+import { T as TRPCError } from './TRPCError-54f51dec.mjs';
+import { i as isObject, m as mergeWithoutOverrides, o as omitPrototype } from './rootConfig-7d3e1fc8.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 };

package/dist/router-5e93cd14.js

@@ -0,0 +1,259 @@
+import { c as createRecursiveProxy } from './createProxy-72161f42.js';
+import { T as TRPCError } from './TRPCError-792b0901.js';
+import { i as isObject, m as mergeWithoutOverrides, o as omitPrototype } from './rootConfig-52aed7d7.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 };