@trpc/server 10.0.0-proxy-alpha.76 → 10.0.0-proxy-alpha.78

package/src/deprecated/interop.ts

@@ -9,11 +9,11 @@ import {
 } from '../core/middleware';
 import {
   MutationProcedure,
-  Procedure as NewProcedure,
   QueryProcedure,
   SubscriptionProcedure,
 } from '../core/procedure';
 import {
+  ProcedureRecord as NewProcedureRecord,
   Router as NewRouter,
   RouterDef,
   createRouterFactory,
@@ -53,26 +53,16 @@ type convertProcedureParams<
     >
   : never;
 
-/**
- * @deprecated
- */
-export type LegacyV9ProcedureTag = {
-  _old: true;
-};
-
 type MigrateProcedure<
   TConfig extends RootConfig,
   TProcedure extends AnyOldProcedure,
   TType extends ProcedureType,
 > = TType extends 'query'
-  ? QueryProcedure<convertProcedureParams<TConfig, TProcedure>> &
-      LegacyV9ProcedureTag
+  ? QueryProcedure<convertProcedureParams<TConfig, TProcedure>>
   : TType extends 'mutation'
-  ? MutationProcedure<convertProcedureParams<TConfig, TProcedure>> &
-      LegacyV9ProcedureTag
+  ? MutationProcedure<convertProcedureParams<TConfig, TProcedure>>
   : TType extends 'subscription'
-  ? SubscriptionProcedure<convertProcedureParams<TConfig, TProcedure>> &
-      LegacyV9ProcedureTag
+  ? SubscriptionProcedure<convertProcedureParams<TConfig, TProcedure>>
   : never;
 
 export type MigrateProcedureRecord<
@@ -117,43 +107,7 @@ export type MigrateRouter<
   TErrorShape extends TRPCErrorShape<any>,
 > = NewRouter<
   {
-    legacy: {
-      queries: MigrateProcedureRecord<
-        CreateRootConfig<{
-          ctx: TInputContext;
-          errorShape: TErrorShape;
-          meta: TMeta;
-          transformer: CombinedDataTransformer;
-        }>,
-        TQueries,
-        'query'
-      >;
-      mutations: MigrateProcedureRecord<
-        CreateRootConfig<{
-          ctx: TInputContext;
-          errorShape: TErrorShape;
-          meta: TMeta;
-          transformer: CombinedDataTransformer;
-        }>,
-        TMutations,
-        'mutation'
-      >;
-      subscriptions: MigrateProcedureRecord<
-        CreateRootConfig<{
-          ctx: TInputContext;
-          errorShape: TErrorShape;
-          meta: TMeta;
-          transformer: CombinedDataTransformer;
-        }>,
-        TSubscriptions,
-        'subscription'
-      >;
-    };
-  } & RouterDef<
-    TInputContext,
-    TErrorShape,
-    TMeta,
-    MigrateProcedureRecord<
+    queries: MigrateProcedureRecord<
       CreateRootConfig<{
         ctx: TInputContext;
         errorShape: TErrorShape;
@@ -162,28 +116,28 @@ export type MigrateRouter<
       }>,
       TQueries,
       'query'
-    > &
-      MigrateProcedureRecord<
-        CreateRootConfig<{
-          ctx: TInputContext;
-          errorShape: TErrorShape;
-          meta: TMeta;
-          transformer: CombinedDataTransformer;
-        }>,
-        TMutations,
-        'mutation'
-      > &
-      MigrateProcedureRecord<
-        CreateRootConfig<{
-          ctx: TInputContext;
-          errorShape: TErrorShape;
-          meta: TMeta;
-          transformer: CombinedDataTransformer;
-        }>,
-        TSubscriptions,
-        'subscription'
-      >
-  >
+    >;
+    mutations: MigrateProcedureRecord<
+      CreateRootConfig<{
+        ctx: TInputContext;
+        errorShape: TErrorShape;
+        meta: TMeta;
+        transformer: CombinedDataTransformer;
+      }>,
+      TMutations,
+      'mutation'
+    >;
+    subscriptions: MigrateProcedureRecord<
+      CreateRootConfig<{
+        ctx: TInputContext;
+        errorShape: TErrorShape;
+        meta: TMeta;
+        transformer: CombinedDataTransformer;
+      }>,
+      TSubscriptions,
+      'subscription'
+    >;
+  } & RouterDef<TInputContext, TErrorShape, TMeta, {}>
 >;
 
 export type MigrateOldRouter<TRouter extends AnyOldRouter> =
@@ -242,11 +196,9 @@ export function migrateRouter<TOldRouter extends AnyOldRouter>(
   const errorFormatter = oldRouter._def.errorFormatter;
   const transformer = oldRouter._def.transformer;
 
-  type ProcRecord = Record<string, NewProcedure<any>>;
-
-  const queries: ProcRecord = {};
-  const mutations: ProcRecord = {};
-  const subscriptions: ProcRecord = {};
+  const queries: NewProcedureRecord = {};
+  const mutations: NewProcedureRecord = {};
+  const subscriptions: NewProcedureRecord = {};
   for (const [name, procedure] of Object.entries(oldRouter._def.queries)) {
     queries[name] = migrateProcedure(procedure as any, 'query');
   }

package/src/http/resolveHTTPResponse.ts

@@ -2,6 +2,7 @@
 import {
   AnyRouter,
   ProcedureType,
+  callProcedure,
   inferRouterContext,
   inferRouterError,
 } from '../core';
@@ -180,8 +181,13 @@ export async function resolveHTTPResponse<
         const input = inputs[index];
 
         try {
-          const caller = router.createCaller(ctx);
-          const output = await caller[type](path, input as any);
+          const output = await callProcedure({
+            procedures: router._def.procedures,
+            path,
+            rawInput: input,
+            ctx,
+            type,
+          });
           return {
             input,
             path,

package/src/shared/index.ts

@@ -1,3 +1 @@
 export * from './createProxy';
-
-export type { LegacyV9ProcedureTag } from '../deprecated/interop';

package/src/types.ts

@@ -63,15 +63,3 @@ type FilterKeys<T extends object, K> = {
  * @internal
  */
 export type Filter<T extends object, K> = Pick<T, FilterKeys<T, K>>;
-
-/**
- * @internal
- */
-export type NeverKeys<T> = {
-  [TKey in keyof T]: T[TKey] extends never ? TKey : never;
-}[keyof T];
-
-/**
- * @internal
- */
-export type OmitNeverKeys<T> = Omit<T, NeverKeys<T>>;

package/dist/resolveHTTPResponse-1b339cff.mjs

@@ -1,260 +0,0 @@
-import { T as TRPCError, g as getTRPCErrorFromUnknown, a as getCauseFromUnknown } from './TRPCError-281ac25a.mjs';
-import { t as transformTRPCResponse } from './transformTRPCResponse-c8138d5f.mjs';
-import { T as TRPC_ERROR_CODES_BY_KEY } from './codes-aaa7d554.mjs';
-
-/* istanbul ignore file */ function assertNotBrowser() {
-    if (typeof window !== 'undefined' && !('Deno' in window) && process.env.NODE_ENV !== 'test' && process.env.JEST_WORKER_ID === undefined) {
-        throw new Error('Imported server-only code in the browser');
-    }
-}
-
-function invert(obj) {
-    const newObj = Object.create(null);
-    for(const key in obj){
-        const v = obj[key];
-        newObj[v] = key;
-    }
-    return newObj;
-}
-
-const TRPC_ERROR_CODES_BY_NUMBER = invert(TRPC_ERROR_CODES_BY_KEY);
-const JSONRPC2_TO_HTTP_CODE = {
-    PARSE_ERROR: 400,
-    BAD_REQUEST: 400,
-    NOT_FOUND: 404,
-    INTERNAL_SERVER_ERROR: 500,
-    UNAUTHORIZED: 401,
-    FORBIDDEN: 403,
-    TIMEOUT: 408,
-    CONFLICT: 409,
-    CLIENT_CLOSED_REQUEST: 499,
-    PRECONDITION_FAILED: 412,
-    PAYLOAD_TOO_LARGE: 413,
-    METHOD_NOT_SUPPORTED: 405
-};
-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) {
-    const { code  } = error;
-    return getStatusCodeFromKey(code);
-}
-
-const HTTP_METHOD_PROCEDURE_TYPE_MAP = {
-    GET: 'query',
-    POST: 'mutation'
-};
-function getRawProcedureInputOrThrow(req) {
-    try {
-        if (req.method === 'GET') {
-            if (!req.query.has('input')) {
-                return undefined;
-            }
-            const raw = req.query.get('input');
-            return JSON.parse(raw);
-        }
-        if (typeof req.body === 'string') {
-            // A mutation with no inputs will have req.body === ''
-            return req.body.length === 0 ? undefined : JSON.parse(req.body);
-        }
-        return req.body;
-    } catch (err) {
-        throw new TRPCError({
-            code: 'PARSE_ERROR',
-            cause: getCauseFromUnknown(err)
-        });
-    }
-}
-async function resolveHTTPResponse(opts) {
-    const { createContext , onError , router , req  } = opts;
-    const batchingEnabled = opts.batching?.enabled ?? true;
-    if (req.method === 'HEAD') {
-        // can be used for lambda warmup
-        return {
-            status: 204
-        };
-    }
-    const type = HTTP_METHOD_PROCEDURE_TYPE_MAP[req.method] ?? 'unknown';
-    let ctx = undefined;
-    let paths = undefined;
-    const isBatchCall = !!req.query.get('batch');
-    function endResponse(untransformedJSON, errors) {
-        let status = getHTTPStatusCode(untransformedJSON);
-        const headers = {
-            'Content-Type': 'application/json'
-        };
-        const meta = opts.responseMeta?.({
-            ctx,
-            paths,
-            type,
-            data: Array.isArray(untransformedJSON) ? untransformedJSON : [
-                untransformedJSON
-            ],
-            errors
-        }) ?? {};
-        for (const [key, value] of Object.entries(meta.headers ?? {})){
-            headers[key] = value;
-        }
-        if (meta.status) {
-            status = meta.status;
-        }
-        const transformedJSON = transformTRPCResponse(router, untransformedJSON);
-        const body = JSON.stringify(transformedJSON);
-        return {
-            body,
-            status,
-            headers
-        };
-    }
-    try {
-        if (opts.error) {
-            throw opts.error;
-        }
-        if (isBatchCall && !batchingEnabled) {
-            throw new Error(`Batching is not enabled on the server`);
-        }
-        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 rawInput = getRawProcedureInputOrThrow(req);
-        paths = isBatchCall ? opts.path.split(',') : [
-            opts.path
-        ];
-        ctx = await createContext();
-        const deserializeInputValue = (rawValue)=>{
-            return typeof rawValue !== 'undefined' ? router._def.transformer.input.deserialize(rawValue) : rawValue;
-        };
-        const getInputs = ()=>{
-            if (!isBatchCall) {
-                return {
-                    0: deserializeInputValue(rawInput)
-                };
-            }
-            if (rawInput == null || typeof rawInput !== 'object' || Array.isArray(rawInput)) {
-                throw new TRPCError({
-                    code: 'BAD_REQUEST',
-                    message: '"input" needs to be an object when doing a batch call'
-                });
-            }
-            const input = {};
-            for(const key in rawInput){
-                const k = key;
-                const rawValue = rawInput[k];
-                const value = deserializeInputValue(rawValue);
-                input[k] = value;
-            }
-            return input;
-        };
-        const inputs = getInputs();
-        const rawResults = await Promise.all(paths.map(async (path, index)=>{
-            const input = inputs[index];
-            try {
-                const caller = router.createCaller(ctx);
-                const output = await caller[type](path, input);
-                return {
-                    input,
-                    path,
-                    data: output
-                };
-            } catch (cause) {
-                const error = getTRPCErrorFromUnknown(cause);
-                onError?.({
-                    error,
-                    path,
-                    input,
-                    ctx,
-                    type: type,
-                    req
-                });
-                return {
-                    input,
-                    path,
-                    error
-                };
-            }
-        }));
-        const errors = rawResults.flatMap((obj)=>obj.error ? [
-                obj.error
-            ] : []);
-        const resultEnvelopes = rawResults.map((obj)=>{
-            const { path , input  } = obj;
-            if (obj.error) {
-                return {
-                    error: router.getErrorShape({
-                        error: obj.error,
-                        type,
-                        path,
-                        input,
-                        ctx
-                    })
-                };
-            } else {
-                return {
-                    result: {
-                        data: obj.data
-                    }
-                };
-            }
-        });
-        const result = isBatchCall ? resultEnvelopes : resultEnvelopes[0];
-        return endResponse(result, errors);
-    } catch (cause) {
-        // we get here if
-        // - batching is called when it's not enabled
-        // - `createContext()` throws
-        // - post body is too large
-        // - input deserialization fails
-        const error = getTRPCErrorFromUnknown(cause);
-        onError?.({
-            error,
-            path: undefined,
-            input: undefined,
-            ctx,
-            type: type,
-            req
-        });
-        return endResponse({
-            error: router.getErrorShape({
-                error,
-                type,
-                path: undefined,
-                input: undefined,
-                ctx
-            })
-        }, [
-            error
-        ]);
-    }
-}
-
-export { assertNotBrowser as a, getHTTPStatusCodeFromError as g, resolveHTTPResponse as r };