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

package/dist/adapters/ws.js

@@ -1,20 +1,25 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var core = require('@trpc/core');
+var getErrorShape = require('../unstable-core-do-not-import/error/getErrorShape.js');
+var TRPCError = require('../unstable-core-do-not-import/error/TRPCError.js');
+require('../unstable-core-do-not-import/rootConfig.js');
+var router = require('../unstable-core-do-not-import/router.js');
+var transformer = require('../unstable-core-do-not-import/transformer.js');
+require('../unstable-core-do-not-import/rpc/codes.js');
+var parseTRPCMessage = require('../unstable-core-do-not-import/rpc/parseTRPCMessage.js');
+var observable = require('../observable/observable.js');
 
 /**
  * Importing ws causes a build error
  * @link https://github.com/trpc/trpc/pull/5279
  */ const WEBSOCKET_OPEN = 1; /* ws.WebSocket.OPEN */ 
 function applyWSSHandler(opts) {
-    const { wss , createContext , router  } = opts;
-    const { transformer  } = router._def._config;
+    const { wss , createContext , router: router$1  } = opts;
+    const { transformer: transformer$1  } = router$1._def._config;
     wss.on('connection', async (client, req)=>{
         const clientSubscriptions = new Map();
         function respond(untransformedJSON) {
-            client.send(JSON.stringify(core.transformTRPCResponse(router._def._config, untransformedJSON)));
+            client.send(JSON.stringify(transformer.transformTRPCResponse(router$1._def._config, untransformedJSON)));
         }
         function stopSubscription(subscription, { id , jsonrpc  }) {
             subscription.unsubscribe();
@@ -34,7 +39,7 @@ function applyWSSHandler(opts) {
         async function handleRequest(msg) {
             const { id , jsonrpc  } = msg;
             /* istanbul ignore next -- @preserve */ if (id === null) {
-                throw new core.TRPCError({
+                throw new TRPCError.TRPCError({
                     code: 'BAD_REQUEST',
                     message: '`id` is required'
                 });
@@ -54,16 +59,16 @@ function applyWSSHandler(opts) {
             const type = msg.method;
             try {
                 await ctxPromise; // asserts context has been set
-                const result = await core.callProcedure({
-                    procedures: router._def.procedures,
+                const result = await router.callProcedure({
+                    procedures: router$1._def.procedures,
                     path,
                     getRawInput: async ()=>input,
                     ctx,
                     type
                 });
                 if (type === 'subscription') {
-                    if (!core.isObservable(result)) {
-                        throw new core.TRPCError({
+                    if (!observable.isObservable(result)) {
+                        throw new TRPCError.TRPCError({
                             message: `Subscription ${path} did not return an observable`,
                             code: 'INTERNAL_SERVER_ERROR'
                         });
@@ -80,8 +85,8 @@ function applyWSSHandler(opts) {
                     });
                     return;
                 }
-                const observable = result;
-                const sub1 = observable.subscribe({
+                const observable$1 = result;
+                const sub1 = observable$1.subscribe({
                     next (data) {
                         respond({
                             id,
@@ -93,7 +98,7 @@ function applyWSSHandler(opts) {
                         });
                     },
                     error (err) {
-                        const error = core.getTRPCErrorFromUnknown(err);
+                        const error = TRPCError.getTRPCErrorFromUnknown(err);
                         opts.onError?.({
                             error,
                             path,
@@ -105,8 +110,8 @@ function applyWSSHandler(opts) {
                         respond({
                             id,
                             jsonrpc,
-                            error: core.getErrorShape({
-                                config: router._def._config,
+                            error: getErrorShape.getErrorShape({
+                                config: router$1._def._config,
                                 error,
                                 type,
                                 path,
@@ -137,7 +142,7 @@ function applyWSSHandler(opts) {
                         id,
                         jsonrpc
                     });
-                    throw new core.TRPCError({
+                    throw new TRPCError.TRPCError({
                         message: `Duplicate id ${id}`,
                         code: 'BAD_REQUEST'
                     });
@@ -152,7 +157,7 @@ function applyWSSHandler(opts) {
                 });
             } catch (cause) /* istanbul ignore next -- @preserve */ {
                 // procedure threw an error
-                const error = core.getTRPCErrorFromUnknown(cause);
+                const error = TRPCError.getTRPCErrorFromUnknown(cause);
                 opts.onError?.({
                     error,
                     path,
@@ -164,8 +169,8 @@ function applyWSSHandler(opts) {
                 respond({
                     id,
                     jsonrpc,
-                    error: core.getErrorShape({
-                        config: router._def._config,
+                    error: getErrorShape.getErrorShape({
+                        config: router$1._def._config,
                         error,
                         type,
                         path,
@@ -182,17 +187,17 @@ function applyWSSHandler(opts) {
                 const msgs = Array.isArray(msgJSON) ? msgJSON : [
                     msgJSON
                 ];
-                const promises = msgs.map((raw)=>core.parseTRPCMessage(raw, transformer)).map(handleRequest);
+                const promises = msgs.map((raw)=>parseTRPCMessage.parseTRPCMessage(raw, transformer$1)).map(handleRequest);
                 await Promise.all(promises);
             } catch (cause) {
-                const error = new core.TRPCError({
+                const error = new TRPCError.TRPCError({
                     code: 'PARSE_ERROR',
                     cause
                 });
                 respond({
                     id: null,
-                    error: core.getErrorShape({
-                        config: router._def._config,
+                    error: getErrorShape.getErrorShape({
+                        config: router$1._def._config,
                         error,
                         type: 'unknown',
                         path: undefined,
@@ -209,7 +214,7 @@ function applyWSSHandler(opts) {
         client.on('error', (cause)=>{
             opts.onError?.({
                 ctx,
-                error: core.getTRPCErrorFromUnknown(cause),
+                error: TRPCError.getTRPCErrorFromUnknown(cause),
                 input: undefined,
                 path: undefined,
                 type: 'unknown',
@@ -226,7 +231,7 @@ function applyWSSHandler(opts) {
             try {
                 ctx = await ctxPromise;
             } catch (cause) {
-                const error = core.getTRPCErrorFromUnknown(cause);
+                const error = TRPCError.getTRPCErrorFromUnknown(cause);
                 opts.onError?.({
                     error,
                     path: undefined,
@@ -237,8 +242,8 @@ function applyWSSHandler(opts) {
                 });
                 respond({
                     id: null,
-                    error: core.getErrorShape({
-                        config: router._def._config,
+                    error: getErrorShape.getErrorShape({
+                        config: router$1._def._config,
                         error,
                         type: 'unknown',
                         path: undefined,

package/dist/adapters/ws.mjs

@@ -1,4 +1,11 @@
-import { parseTRPCMessage, TRPCError, getErrorShape, getTRPCErrorFromUnknown, transformTRPCResponse, callProcedure, isObservable } from '@trpc/core';
+import { getErrorShape } from '../unstable-core-do-not-import/error/getErrorShape.mjs';
+import { TRPCError, getTRPCErrorFromUnknown } from '../unstable-core-do-not-import/error/TRPCError.mjs';
+import '../unstable-core-do-not-import/rootConfig.mjs';
+import { callProcedure } from '../unstable-core-do-not-import/router.mjs';
+import { transformTRPCResponse } from '../unstable-core-do-not-import/transformer.mjs';
+import '../unstable-core-do-not-import/rpc/codes.mjs';
+import { parseTRPCMessage } from '../unstable-core-do-not-import/rpc/parseTRPCMessage.mjs';
+import { isObservable } from '../observable/observable.mjs';
 
 /**
  * Importing ws causes a build error