@trpc/server 11.0.0-next-alpha.152 → 11.0.0-next-alpha.154

package/dist/procedureBuilder-cf58dadb.mjs

@@ -1,340 +0,0 @@
-import { d as defaultFormatter, a as defaultTransformer, c as createRouterFactory } from './router-f9ce121f.mjs';
-import { T as TRPCError, g as getTRPCErrorFromUnknown } from './TRPCError-7e8e2a1b.mjs';
-
-/**
- * @internal
- */ function createMiddlewareFactory() {
-    function createMiddlewareInner(middlewares) {
-        return {
-            _middlewares: middlewares,
-            unstable_pipe (middlewareBuilderOrFn) {
-                const pipedMiddleware = '_middlewares' in middlewareBuilderOrFn ? middlewareBuilderOrFn._middlewares : [
-                    middlewareBuilderOrFn
-                ];
-                return createMiddlewareInner([
-                    ...middlewares,
-                    ...pipedMiddleware
-                ]);
-            }
-        };
-    }
-    function createMiddleware(fn) {
-        return createMiddlewareInner([
-            fn
-        ]);
-    }
-    return createMiddleware;
-}
-const experimental_standaloneMiddleware = ()=>({
-        create: createMiddlewareFactory()
-    });
-function isPlainObject(obj) {
-    return obj && typeof obj === 'object' && !Array.isArray(obj);
-}
-/**
- * @internal
- * Please note, `trpc-openapi` uses this function.
- */ function createInputMiddleware(parse) {
-    const inputMiddleware = async function inputValidatorMiddleware(opts) {
-        let parsedInput;
-        const rawInput = await opts.getRawInput();
-        try {
-            parsedInput = await parse(rawInput);
-        } catch (cause) {
-            throw new TRPCError({
-                code: 'BAD_REQUEST',
-                cause
-            });
-        }
-        // Multiple input parsers
-        const combinedInput = isPlainObject(opts.input) && isPlainObject(parsedInput) ? {
-            ...opts.input,
-            ...parsedInput
-        } : parsedInput;
-        return opts.next({
-            input: combinedInput
-        });
-    };
-    inputMiddleware._type = 'input';
-    return inputMiddleware;
-}
-/**
- * @internal
- */ function createOutputMiddleware(parse) {
-    const outputMiddleware = async function outputValidatorMiddleware({ next  }) {
-        const result = await next();
-        if (!result.ok) {
-            // pass through failures without validating
-            return result;
-        }
-        try {
-            const data = await parse(result.data);
-            return {
-                ...result,
-                data
-            };
-        } catch (cause) {
-            throw new TRPCError({
-                message: 'Output validation failed',
-                code: 'INTERNAL_SERVER_ERROR',
-                cause
-            });
-        }
-    };
-    outputMiddleware._type = 'output';
-    return outputMiddleware;
-}
-
-/**
- * Ensures there are no duplicate keys when building a procedure.
- */ function mergeWithoutOverrides(obj1, ...objs) {
-    const newObj = Object.assign(Object.create(null), obj1);
-    for (const overrides of objs){
-        for(const key in overrides){
-            if (key in newObj && newObj[key] !== overrides[key]) {
-                throw new Error(`Duplicate key ${key}`);
-            }
-            newObj[key] = overrides[key];
-        }
-    }
-    return newObj;
-}
-
-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;
-}
-
-function getParseFn(procedureParser) {
-    const parser = procedureParser;
-    if (typeof parser === 'function') {
-        // ParserCustomValidatorEsque
-        return parser;
-    }
-    if (typeof parser.parseAsync === 'function') {
-        // ParserZodEsque
-        return parser.parseAsync.bind(parser);
-    }
-    if (typeof parser.parse === 'function') {
-        // ParserZodEsque
-        // ParserValibotEsque (<= v0.12.X)
-        return parser.parse.bind(parser);
-    }
-    if (typeof parser.validateSync === 'function') {
-        // ParserYupEsque
-        return parser.validateSync.bind(parser);
-    }
-    if (typeof parser.create === 'function') {
-        // ParserSuperstructEsque
-        return parser.create.bind(parser);
-    }
-    if (typeof parser.assert === 'function') {
-        // ParserScaleEsque
-        return (value)=>{
-            parser.assert(value);
-            return value;
-        };
-    }
-    throw new Error('Could not find a validator fn');
-}
-
-/**
- * @internal
- */ const middlewareMarker = 'middlewareMarker';
-/**
- * @internal
- */ const unsetMarker = Symbol('unsetMarker');
-
-function createNewBuilder(def1, def2) {
-    const { middlewares =[] , inputs , meta , ...rest } = def2;
-    // TODO: maybe have a fn here to warn about calls
-    return createBuilder({
-        ...mergeWithoutOverrides(def1, rest),
-        inputs: [
-            ...def1.inputs,
-            ...inputs ?? []
-        ],
-        middlewares: [
-            ...def1.middlewares,
-            ...middlewares
-        ],
-        meta: def1.meta && meta ? {
-            ...def1.meta,
-            ...meta
-        } : meta ?? def1.meta
-    });
-}
-function createBuilder(initDef = {}) {
-    const _def = {
-        procedure: true,
-        inputs: [],
-        middlewares: [],
-        ...initDef
-    };
-    const builder = {
-        _def,
-        input (input) {
-            const parser = getParseFn(input);
-            return createNewBuilder(_def, {
-                inputs: [
-                    input
-                ],
-                middlewares: [
-                    createInputMiddleware(parser)
-                ]
-            });
-        },
-        output (output) {
-            const parser = getParseFn(output);
-            return createNewBuilder(_def, {
-                output,
-                middlewares: [
-                    createOutputMiddleware(parser)
-                ]
-            });
-        },
-        meta (meta) {
-            return createNewBuilder(_def, {
-                meta
-            });
-        },
-        use (middlewareBuilderOrFn) {
-            // Distinguish between a middleware builder and a middleware function
-            const middlewares = '_middlewares' in middlewareBuilderOrFn ? middlewareBuilderOrFn._middlewares : [
-                middlewareBuilderOrFn
-            ];
-            return createNewBuilder(_def, {
-                middlewares: middlewares
-            });
-        },
-        query (resolver) {
-            return createResolver({
-                ..._def,
-                type: 'query'
-            }, resolver);
-        },
-        mutation (resolver) {
-            return createResolver({
-                ..._def,
-                type: 'mutation'
-            }, resolver);
-        },
-        subscription (resolver) {
-            return createResolver({
-                ..._def,
-                type: 'subscription'
-            }, resolver);
-        }
-    };
-    return builder;
-}
-function createResolver(_def, resolver) {
-    const finalBuilder = createNewBuilder(_def, {
-        resolver,
-        middlewares: [
-            async function resolveMiddleware(opts) {
-                const data = await resolver(opts);
-                return {
-                    marker: middlewareMarker,
-                    ok: true,
-                    data,
-                    ctx: opts.ctx
-                };
-            }
-        ]
-    });
-    return createProcedureCaller(finalBuilder._def);
-}
-const codeblock = `
-This is a client-only function.
-If you want to call this function on the server, see https://trpc.io/docs/server/server-side-calls
-`.trim();
-function createProcedureCaller(_def) {
-    async function procedure(opts) {
-        // is direct server-side call
-        if (!opts || !('getRawInput' in opts)) {
-            throw new Error(codeblock);
-        }
-        // run the middlewares recursively with the resolver as the last one
-        async function callRecursive(callOpts = {
-            index: 0,
-            ctx: opts.ctx
-        }) {
-            try {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                const middleware = _def.middlewares[callOpts.index];
-                const result = await middleware({
-                    ctx: callOpts.ctx,
-                    type: opts.type,
-                    path: opts.path,
-                    getRawInput: callOpts.getRawInput ?? opts.getRawInput,
-                    meta: _def.meta,
-                    input: callOpts.input,
-                    next (_nextOpts) {
-                        const nextOpts = _nextOpts;
-                        return callRecursive({
-                            index: callOpts.index + 1,
-                            ctx: nextOpts && 'ctx' in nextOpts ? {
-                                ...callOpts.ctx,
-                                ...nextOpts.ctx
-                            } : callOpts.ctx,
-                            input: nextOpts && 'input' in nextOpts ? nextOpts.input : callOpts.input,
-                            getRawInput: nextOpts && 'getRawInput' in nextOpts ? nextOpts.getRawInput : callOpts.getRawInput
-                        });
-                    }
-                });
-                return result;
-            } catch (cause) {
-                return {
-                    ok: false,
-                    error: getTRPCErrorFromUnknown(cause),
-                    marker: middlewareMarker
-                };
-            }
-        }
-        // there's always at least one "next" since we wrap this.resolver in a middleware
-        const result = await callRecursive();
-        if (!result) {
-            throw new TRPCError({
-                code: 'INTERNAL_SERVER_ERROR',
-                message: 'No result from middlewares - did you forget to `return next()`?'
-            });
-        }
-        if (!result.ok) {
-            // re-throw original error
-            throw result.error;
-        }
-        return result.data;
-    }
-    procedure._def = _def;
-    // FIXME typecast shouldn't be needed - fixittt
-    return procedure;
-}
-
-export { createMiddlewareFactory as a, createInputMiddleware as b, createBuilder as c, createOutputMiddleware as d, experimental_standaloneMiddleware as e, middlewareMarker as f, mergeRouters as m, unsetMarker as u };

package/dist/resolveHTTPResponse-3ebaa4f6.mjs

@@ -1,292 +0,0 @@
-import { e as callProcedure } from './router-f9ce121f.mjs';
-import { T as TRPCError, g as getTRPCErrorFromUnknown } from './TRPCError-7e8e2a1b.mjs';
-import './config-50853f49.mjs';
-import { t as transformTRPCResponse, g as getHTTPStatusCode, a as getErrorShape } from './transformTRPCResponse-31040a38.mjs';
-import { g as getJsonContentTypeInputs } from './contentType-31223e57.mjs';
-
-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 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 = transformTRPCResponse(router._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 = transformTRPCResponse(router._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
-        };
-    }
-}
-
-export { resolveHTTPResponse as r };