@mstuercke/api-utils 5.1.2 → 5.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mstuercke/api-utils",
-  "version": "5.1.2",
+  "version": "5.2.0",
   "type": "module",
   "main": "src/index.ts",
   "files": [
@@ -49,23 +49,23 @@
     "release": "bun run scripts/release.ts"
   },
   "dependencies": {
-    "path-to-regexp": "^6.2.1"
+    "path-to-regexp": "^6.2.2"
   },
   "peerDependencies": {
     "@aws-sdk/client-apigatewaymanagementapi": "^3.438.0",
-    "@trpc/server": "next",
-    "@types/aws-lambda": "^8.10.133"
+    "@trpc/server": "^11.0.0-rc.382",
+    "@types/aws-lambda": "^8.10.138"
   },
   "devDependencies": {
-    "@mstuercke/bun-utils": "6.0.0",
-    "@trpc/server": "next",
-    "@types/aws-lambda": "^8.10.133",
-    "@types/bun": "^1.0.11",
+    "@mstuercke/bun-utils": "6.0.2",
+    "@trpc/server": "^11.0.0-rc.382",
+    "@types/aws-lambda": "^8.10.138",
+    "@types/bun": "^1.1.3",
     "@types/path-to-regexp": "^1.7.0",
-    "@types/react": "^18.2.33",
+    "@types/react": "^18.3.3",
     "aws-sdk-client-mock": "^4.0.0",
-    "typescript": "^5.3.3",
-    "zod": "^3.22.4"
+    "typescript": "^5.4.5",
+    "zod": "^3.23.8"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"

package/src/__mocks__/ignoreConsoleErrors.ts

@@ -0,0 +1,19 @@
+import {afterEach, beforeEach} from 'bun:test';
+
+
+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;
+
+      consoleError_original(...data);
+    };
+  });
+
+  afterEach(() => {
+    console.error = consoleError_original;
+  });
+};

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

@@ -1,8 +1,8 @@
 import {PostToConnectionCommand} from '@aws-sdk/client-apigatewaymanagementapi';
 import {AnyTRPCRouter, callTRPCProcedure, inferRouterContext} from '@trpc/server';
-import type {APIGatewayResult} from '@trpc/server/adapters/aws-lambda';
-import type {Observable} from '@trpc/server/observable';
-import {APIGatewayProxyEvent} from 'aws-lambda';
+import {isObservable, Observable} from '@trpc/server/observable';
+import {isAsyncIterable} from '@trpc/server/unstable-core-do-not-import';
+import {APIGatewayProxyEvent, APIGatewayProxyResult} from 'aws-lambda';
 import {getApiGatewayManagementApiClient} from '../getApiGatewayManagementApiClient';
 import {getConnection} from '../getConnection';
 import {TrpcSubscriptionRequest} from './TrpcSubscriptionRequest';
@@ -14,7 +14,7 @@ export const awsLambdaTrpcSubscriptionRequestHandler = <Router extends AnyTRPCRo
 }) => {
   const {router, createContext} = opts;
 
-  return async (event: APIGatewayProxyEvent): Promise<APIGatewayResult> => {
+  return async (event: APIGatewayProxyEvent): Promise<APIGatewayProxyResult> => {
     const connection = getConnection(event);
 
     if (!event.body || event.body === '[]')
@@ -48,49 +48,20 @@ export const awsLambdaTrpcSubscriptionRequestHandler = <Router extends AnyTRPCRo
           result: {type: 'started'},
         });
 
-        const sub = (await callTRPCProcedure({
+        const procedure = (await callTRPCProcedure({
           procedures: router._def.procedures,
           path: request.params.path,
           type: 'subscription',
           ctx: await createContext?.(event) || {},
           getRawInput: async () => request.params.input,
-        })) as Observable<unknown, unknown>;
-
-        const messageQueue: TrpcSubscriptionResponse[] = [];
-        sub.subscribe({
-          next: (data: unknown) => {
-            messageQueue.push({
-              id: request.id,
-              result: {
-                type: 'data',
-                data: data,
-              },
-            });
-          },
-          error: (err) => {
-            console.error(err);
-            messageQueue.push({
-              id: request.id,
-              result: {type: 'stopped'},
-            });
-          },
-          complete: () => {
-            messageQueue.push({
-              id: request.id,
-              result: {type: 'stopped'},
-            });
-          },
-        });
-
-        let stopped = false;
-        while (!stopped) {
-          const message = messageQueue.shift();
-          if (!message)
-            continue;
-
-          await sendMessage(message);
+        }));
 
-          stopped = message.result.type === 'stopped';
+        if (isAsyncIterable(procedure)) {
+          await handleAsyncGenerator(procedure, request, sendMessage, stopConnection);
+        } else if (isObservable(procedure)) {
+          await handleObservable(procedure, request, sendMessage);
+        } else {
+          throw 'Unable to determine subscription type';
         }
       }
     } catch (err) {
@@ -104,3 +75,70 @@ export const awsLambdaTrpcSubscriptionRequestHandler = <Router extends AnyTRPCRo
     };
   };
 };
+
+
+const handleObservable = async (
+    observable: Observable<unknown, unknown>,
+    request: TrpcSubscriptionRequest,
+    sendMessage: (message: TrpcSubscriptionResponse) => Promise<void>,
+) => {
+  const messageQueue: TrpcSubscriptionResponse[] = [];
+  observable.subscribe({
+    next: (data: unknown) => {
+      messageQueue.push({
+        id: request.id,
+        result: {
+          type: 'data',
+          data: data,
+        },
+      });
+    },
+    error: (err) => {
+      console.error(err);
+      messageQueue.push({
+        id: request.id,
+        result: {type: 'stopped'},
+      });
+    },
+    complete: () => {
+      messageQueue.push({
+        id: request.id,
+        result: {type: 'stopped'},
+      });
+    },
+  });
+
+  let stopped = false;
+  while (!stopped) {
+    const message = messageQueue.shift();
+    if (!message)
+      continue;
+
+    await sendMessage(message);
+
+    stopped = message.result.type === 'stopped';
+  }
+};
+
+const handleAsyncGenerator = async (
+    generator: AsyncIterable<unknown>,
+    request: TrpcSubscriptionRequest,
+    sendMessage: (message: TrpcSubscriptionResponse) => Promise<void>,
+    stopConnection: () => Promise<void>
+) => {
+  try {
+    for await (const data of generator) {
+      await sendMessage({
+        id: request.id,
+        result: {
+          type: 'data',
+          data: data,
+        },
+      });
+    }
+  } catch (err) {
+    console.error(err);
+  } finally {
+    await stopConnection();
+  }
+};