@mstuercke/api-utils 6.1.3 → 7.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mstuercke/api-utils",
-  "version": "6.1.3",
+  "version": "7.0.1",
   "type": "module",
   "main": "src/index.ts",
   "files": [
@@ -51,18 +51,18 @@
   },
   "peerDependencies": {
     "@aws-sdk/client-apigatewaymanagementapi": "^3.438.0",
-    "@trpc/server": "^11.0.0-rc.580",
-    "@types/aws-lambda": "8.10.145"
+    "@trpc/server": "^11.0.0-rc.608",
+    "@types/aws-lambda": "8.10.146"
   },
   "devDependencies": {
     "@mstuercke/bun-utils": "7.0.6",
-    "@trpc/server": "^11.0.0-rc.580",
-    "@types/aws-lambda": "8.10.145",
-    "@types/bun": "1.1.11",
+    "@trpc/server": "^11.0.0-rc.608",
+    "@types/aws-lambda": "8.10.146",
+    "@types/bun": "1.1.14",
     "@types/path-to-regexp": "1.7.0",
-    "@types/react": "18.3.11",
-    "aws-sdk-client-mock": "4.0.2",
-    "typescript": "5.6.3",
+    "@types/react": "19.0.1",
+    "aws-sdk-client-mock": "4.1.0",
+    "typescript": "5.7.2",
     "zod": "3.23.8"
   },
   "publishConfig": {

package/src/__mocks__/ignoreConsoleErrors.ts

@@ -4,10 +4,21 @@ export const ignoreConsoleErrors = (...messagesToIgnore: string[]) => {
   let consoleError_original: typeof console.error
   beforeEach(() => {
     consoleError_original = console.error
-    console.error = (...data) => {
-      if (data.length === 1 && messagesToIgnore.includes(data[0])) return
+    console.error = (...errorParams: unknown[]) => {
+      let message = ''
+      if (errorParams[0] instanceof Error) {
+        message = errorParams[0].message
+      }
 
-      consoleError_original(...data)
+      if (typeof errorParams[0] === 'string') {
+        message = errorParams[0]
+      }
+
+      if (messagesToIgnore.includes(message)) {
+        return
+      }
+
+      consoleError_original(...errorParams)
     }
   })
 

package/src/ws/client/useWsApi.ts

@@ -26,7 +26,7 @@ export const useWsApi = <
 ) => {
   const [error, setError] = useState<boolean>(false)
   const [connected, setConnected] = useState<boolean>(false)
-  const webSocket = useRef<WebSocket>()
+  const webSocket = useRef<WebSocket>(undefined)
 
   const sendRequest = useCallback(
     (request: Omit<Request, 'action'>) => {

package/src/ws/server/trpc/awsLambdaTrpcSubscriptionRequestHandler.ts

@@ -5,7 +5,6 @@ import {getApiGatewayManagementApiClient} from '../getApiGatewayManagementApiCli
 import {getConnection} from '../getConnection'
 import type {TrpcSubscriptionRequest} from './TrpcSubscriptionRequest'
 import type {TrpcSubscriptionResponse} from './TrpcSubscriptionResponse'
-import {isObservable} from './isObservable'
 
 export const awsLambdaTrpcSubscriptionRequestHandler = <Router extends AnyTRPCRouter>(opts: {
   router: Router
@@ -47,19 +46,17 @@ export const awsLambdaTrpcSubscriptionRequestHandler = <Router extends AnyTRPCRo
         }
 
         try {
-          const messageQueue: TrpcSubscriptionResponse[] = []
-
           if (request.method === 'subscription.stop') {
             await stopConnection()
           }
 
           if (request.method === 'subscription') {
-            messageQueue.push({
+            await sendMessage({
               id: request.id,
               result: {type: 'started'},
             })
 
-            const procedure = await callTRPCProcedure({
+            const procedure: AsyncGenerator = await callTRPCProcedure({
               procedures: router._def.procedures,
               path: request.params.path,
               type: 'subscription',
@@ -69,57 +66,38 @@ export const awsLambdaTrpcSubscriptionRequestHandler = <Router extends AnyTRPCRo
               signal: undefined,
             })
 
-            if (!isObservable(procedure)) {
-              console.error(`observable`, procedure)
-              throw `Procedure is not an observable!`
-            }
+            try {
+              // TODO: ping still needed?
+              const pingIntervalMs = 5_000
+              let lastPing = Date.now()
+              for await (const data of procedure) {
+                if (Date.now() > lastPing + pingIntervalMs) {
+                  if (!(await isConnected())) {
+                    console.info('Ping: Connection closed by client')
+                    return
+                  }
+                  lastPing = Date.now()
+                }
 
-            procedure.subscribe({
-              next: (data: unknown) => {
-                messageQueue.push({
+                await sendMessage({
                   id: request.id,
                   result: {
                     type: 'data',
                     data: data,
                   },
                 })
-              },
-              error: (err) => {
-                console.error(err)
-                // TODO: respond with error
-                messageQueue.push({
-                  id: request.id,
-                  result: {type: 'stopped'},
-                })
-              },
-              complete: () => {
-                messageQueue.push({
-                  id: request.id,
-                  result: {type: 'stopped'},
-                })
-              },
-            })
-
-            const pingIntervalMs = 5_000
-            let lastPing = Date.now()
-            let stopped = false
-            while (!stopped) {
-              if (messageQueue.length === 0) await new Promise((resolve) => setTimeout(resolve, 10))
-              const message = messageQueue.shift()
-              if (!message) continue
-
-              await sendMessage(message)
-
-              stopped = message.result.type === 'stopped'
-
-              if (Date.now() > lastPing + pingIntervalMs) {
-                const connected = await isConnected()
-                if (!connected) {
-                  console.info('Ping: Connection closed by client')
-                  stopped = true
-                }
-                lastPing = Date.now()
               }
+
+              await sendMessage({
+                id: request.id,
+                result: {type: 'stopped'},
+              })
+            } catch (error: unknown) {
+              console.error(error)
+              await sendMessage({
+                id: request.id,
+                result: {type: 'stopped'},
+              })
             }
           }
         } catch (err) {