@trpc/server 11.0.0-alpha-tmp-export-from-main-nuke-core.236 → 11.0.0-alpha-tmp-export-from-main.217

package/dist/unstable-core-do-not-import/http/getHTTPStatusCode.mjs

@@ -1,48 +0,0 @@
-import { TRPC_ERROR_CODES_BY_NUMBER } from '../rpc/codes.mjs';
-
-const JSONRPC2_TO_HTTP_CODE = {
-    PARSE_ERROR: 400,
-    BAD_REQUEST: 400,
-    UNAUTHORIZED: 401,
-    NOT_FOUND: 404,
-    FORBIDDEN: 403,
-    METHOD_NOT_SUPPORTED: 405,
-    TIMEOUT: 408,
-    CONFLICT: 409,
-    PRECONDITION_FAILED: 412,
-    PAYLOAD_TOO_LARGE: 413,
-    UNPROCESSABLE_CONTENT: 422,
-    TOO_MANY_REQUESTS: 429,
-    CLIENT_CLOSED_REQUEST: 499,
-    INTERNAL_SERVER_ERROR: 500,
-    NOT_IMPLEMENTED: 501
-};
-function getStatusCodeFromKey(code) {
-    return JSONRPC2_TO_HTTP_CODE[code] ?? 500;
-}
-function getHTTPStatusCode(json) {
-    const arr = Array.isArray(json) ? json : [
-        json
-    ];
-    const httpStatuses = new Set(arr.map((res)=>{
-        if ('error' in res) {
-            const data = res.error.data;
-            if (typeof data['httpStatus'] === 'number') {
-                return data['httpStatus'];
-            }
-            const code = TRPC_ERROR_CODES_BY_NUMBER[res.error.code];
-            return getStatusCodeFromKey(code);
-        }
-        return 200;
-    }));
-    if (httpStatuses.size !== 1) {
-        return 207;
-    }
-    const httpStatus = httpStatuses.values().next().value;
-    return httpStatus;
-}
-function getHTTPStatusCodeFromError(error) {
-    return getStatusCodeFromKey(error.code);
-}
-
-export { getHTTPStatusCode, getHTTPStatusCodeFromError };

package/dist/unstable-core-do-not-import/http/index.d.ts

@@ -1,7 +0,0 @@
-export { getHTTPStatusCode, getHTTPStatusCodeFromError, } from './getHTTPStatusCode';
-export { resolveHTTPResponse } from './resolveHTTPResponse';
-export type { BaseHandlerOptions, HTTPBaseHandlerOptions, HTTPHeaders, HTTPRequest, HTTPResponse, OnErrorFunction, ProcedureCall, ResolveHTTPRequestOptionsContextFn, ResponseChunk, ResponseMeta, ResponseMetaFn, TRPCRequestInfo, } from './types';
-export { getBatchStreamFormatter } from './batchStreamFormatter';
-export type { BaseContentTypeHandler, BodyResult } from './contentType';
-export { getJsonContentTypeInputs } from './contentType';
-//# sourceMappingURL=index.d.ts.map

package/dist/unstable-core-do-not-import/http/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/unstable-core-do-not-import/http/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,0BAA0B,GAC3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,YAAY,EACV,kBAAkB,EAClB,sBAAsB,EACtB,WAAW,EACX,WAAW,EACX,YAAY,EACZ,eAAe,EACf,aAAa,EACb,kCAAkC,EAClC,aAAa,EACb,YAAY,EACZ,cAAc,EACd,eAAe,GAChB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACjE,YAAY,EAAE,sBAAsB,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC"}

package/dist/unstable-core-do-not-import/http/resolveHTTPResponse.d.ts

@@ -1,51 +0,0 @@
-import { TRPCError } from '../error/TRPCError';
-import type { AnyRouter } from '../router';
-import type { Maybe } from '../types';
-import type { BaseContentTypeHandler } from './contentType';
-import type { HTTPBaseHandlerOptions, HTTPRequest, HTTPResponse, ResolveHTTPRequestOptionsContextFn, ResponseChunk } from './types';
-interface ResolveHTTPRequestOptions<TRouter extends AnyRouter, TRequest extends HTTPRequest> extends HTTPBaseHandlerOptions<TRouter, TRequest> {
-    createContext: ResolveHTTPRequestOptionsContextFn<TRouter>;
-    req: TRequest;
-    path: string;
-    error?: Maybe<TRPCError>;
-    contentTypeHandler?: BaseContentTypeHandler<any>;
-    preprocessedBody?: boolean;
-    /**
-     * Called as soon as the response head is known.
-     * When streaming, headers will have been generated
-     * **without** knowing the response body.
-     *
-     * Without this callback, streaming is disabled.
-     */
-    unstable_onHead: (headResponse: Omit<HTTPResponse, 'body'>, isStreaming: boolean) => void;
-    /**
-     * Called for every procedure with `[index, result]`.
-     *
-     * Will be called a single time with `index = -1` if
-     * - response is an error
-     * - response is empty (HEAD request)
-     *
-     * Without this callback, streaming is disabled.
-     */
-    unstable_onChunk: (chunk: ResponseChunk) => void;
-}
-/**
- * Since `resolveHTTPResponse` is a public API (community adapters),
- * let's give it a strong type signature to increase discoverability.
- */
-/**
- * Non-streaming signature for `resolveHTTPResponse`:
- * @param opts.unstable_onHead `undefined`
- * @param opts.unstable_onChunk `undefined`
- * @returns `Promise<HTTPResponse>`
- */
-export declare function resolveHTTPResponse<TRouter extends AnyRouter, TRequest extends HTTPRequest>(opts: Omit<ResolveHTTPRequestOptions<TRouter, TRequest>, 'unstable_onChunk' | 'unstable_onHead'>): Promise<HTTPResponse>;
-/**
- * Streaming signature for `resolveHTTPResponse`:
- * @param opts.unstable_onHead called as soon as the response head is known
- * @param opts.unstable_onChunk called for every procedure with `[index, result]`
- * @returns `Promise<void>` since the response is streamed
- */
-export declare function resolveHTTPResponse<TRouter extends AnyRouter, TRequest extends HTTPRequest>(opts: ResolveHTTPRequestOptions<TRouter, TRequest>): Promise<void>;
-export {};
-//# sourceMappingURL=resolveHTTPResponse.d.ts.map

package/dist/unstable-core-do-not-import/http/resolveHTTPResponse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolveHTTPResponse.d.ts","sourceRoot":"","sources":["../../../src/unstable-core-do-not-import/http/resolveHTTPResponse.ts"],"names":[],"mappings":"AACA,OAAO,EAA2B,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAExE,OAAO,KAAK,EACV,SAAS,EAGV,MAAM,WAAW,CAAC;AAInB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAG5D,OAAO,KAAK,EACV,sBAAsB,EAEtB,WAAW,EACX,YAAY,EACZ,kCAAkC,EAClC,aAAa,EAEd,MAAM,SAAS,CAAC;AAoBjB,UAAU,yBAAyB,CACjC,OAAO,SAAS,SAAS,EACzB,QAAQ,SAAS,WAAW,CAC5B,SAAQ,sBAAsB,CAAC,OAAO,EAAE,QAAQ,CAAC;IACjD,aAAa,EAAE,kCAAkC,CAAC,OAAO,CAAC,CAAC;IAC3D,GAAG,EAAE,QAAQ,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IACzB,kBAAkB,CAAC,EAAE,sBAAsB,CAAC,GAAG,CAAC,CAAC;IACjD,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;;OAMG;IACH,eAAe,EAAE,CACf,YAAY,EAAE,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,EACxC,WAAW,EAAE,OAAO,KACjB,IAAI,CAAC;IACV;;;;;;;;OAQG;IACH,gBAAgB,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;CAClD;AAyJD;;;GAGG;AAEH;;;;;GAKG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,SAAS,SAAS,EACzB,QAAQ,SAAS,WAAW,EAE5B,IAAI,EAAE,IAAI,CACR,yBAAyB,CAAC,OAAO,EAAE,QAAQ,CAAC,EAC5C,kBAAkB,GAAG,iBAAiB,CACvC,GACA,OAAO,CAAC,YAAY,CAAC,CAAC;AACzB;;;;;GAKG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,SAAS,SAAS,EACzB,QAAQ,SAAS,WAAW,EAC5B,IAAI,EAAE,yBAAyB,CAAC,OAAO,EAAE,QAAQ,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC"}

package/dist/unstable-core-do-not-import/http/resolveHTTPResponse.js

@@ -1,295 +0,0 @@
-'use strict';
-
-var getErrorShape = require('../error/getErrorShape.js');
-var TRPCError = require('../error/TRPCError.js');
-var router = require('../router.js');
-var transformer = require('../transformer.js');
-var contentType = require('./contentType.js');
-var getHTTPStatusCode = require('./getHTTPStatusCode.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 ? getHTTPStatusCode.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: getErrorShape.getErrorShape({
-                config: opts.router._def._config,
-                error,
-                type,
-                path,
-                input,
-                ctx
-            })
-        };
-    }
-}
-function caughtErrorToData(cause, errorOpts) {
-    const { router , 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: getErrorShape.getErrorShape({
-            config: router._def._config,
-            error,
-            type: errorOpts.type,
-            path: errorOpts.path,
-            input: errorOpts.input,
-            ctx: errorOpts.ctx
-        })
-    };
-    const transformedJSON = transformer.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.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,
-            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 = transformer.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 = transformer.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
-        };
-    }
-}
-
-exports.resolveHTTPResponse = resolveHTTPResponse;