@mstuercke/api-utils 5.2.0 → 5.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mstuercke/api-utils",
-  "version": "5.2.0",
+  "version": "5.2.2",
   "type": "module",
   "main": "src/index.ts",
   "files": [
@@ -53,17 +53,17 @@
   },
   "peerDependencies": {
     "@aws-sdk/client-apigatewaymanagementapi": "^3.438.0",
-    "@trpc/server": "^11.0.0-rc.382",
+    "@trpc/server": "^11.0.0-rc.390",
     "@types/aws-lambda": "^8.10.138"
   },
   "devDependencies": {
     "@mstuercke/bun-utils": "6.0.2",
-    "@trpc/server": "^11.0.0-rc.382",
+    "@trpc/server": "^11.0.0-rc.390",
     "@types/aws-lambda": "^8.10.138",
     "@types/bun": "^1.1.3",
     "@types/path-to-regexp": "^1.7.0",
     "@types/react": "^18.3.3",
-    "aws-sdk-client-mock": "^4.0.0",
+    "aws-sdk-client-mock": "^4.0.1",
     "typescript": "^5.4.5",
     "zod": "^3.23.8"
   },

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

@@ -1,12 +1,11 @@
 import {PostToConnectionCommand} from '@aws-sdk/client-apigatewaymanagementapi';
 import {AnyTRPCRouter, callTRPCProcedure, inferRouterContext} from '@trpc/server';
-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';
 import {TrpcSubscriptionResponse} from './TrpcSubscriptionResponse';
+import {isObservable} from './isObservable';
 
 export const awsLambdaTrpcSubscriptionRequestHandler = <Router extends AnyTRPCRouter>(opts: {
   router: Router
@@ -38,12 +37,14 @@ export const awsLambdaTrpcSubscriptionRequestHandler = <Router extends AnyTRPCRo
     };
 
     try {
+      const messageQueue: TrpcSubscriptionResponse[] = [];
+
       if (request.method === 'subscription.stop') {
         await stopConnection();
       }
 
       if (request.method === 'subscription') {
-        await sendMessage({
+        messageQueue.push({
           id: request.id,
           result: {type: 'started'},
         });
@@ -56,12 +57,45 @@ export const awsLambdaTrpcSubscriptionRequestHandler = <Router extends AnyTRPCRo
           getRawInput: async () => request.params.input,
         }));
 
-        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';
+        if (!isObservable(procedure)) {
+          console.error(`observable`, procedure);
+          throw `Procedure is not an observable!`;
+        }
+
+        procedure.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';
         }
       }
     } catch (err) {
@@ -75,70 +109,3 @@ 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();
-  }
-};

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

@@ -0,0 +1,8 @@
+import type {Observable} from '@trpc/server/observable';
+
+export const isObservable = (value: unknown): value is Observable<unknown, unknown> => {
+  return !!value
+      && typeof value === 'object'
+      && `subscribe` in value
+      && `pipe` in value;
+};