@mstuercke/api-utils 6.0.0 → 6.0.2

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

@@ -1,66 +1,71 @@
-import {PostToConnectionCommand} from '@aws-sdk/client-apigatewaymanagementapi';
-import {AnyTRPCRouter, callTRPCProcedure, inferRouterContext} from '@trpc/server';
-import {APIGatewayProxyEvent, APIGatewayProxyResult, Context} from 'aws-lambda';
-import {getApiGatewayManagementApiClient} from '../getApiGatewayManagementApiClient';
-import {getConnection} from '../getConnection';
-import {TrpcSubscriptionRequest} from './TrpcSubscriptionRequest';
-import {TrpcSubscriptionResponse} from './TrpcSubscriptionResponse';
-import {isObservable} from './isObservable';
+import {GetConnectionCommand, GoneException, PostToConnectionCommand} from '@aws-sdk/client-apigatewaymanagementapi'
+import {type AnyTRPCRouter, callTRPCProcedure, type inferRouterContext} from '@trpc/server'
+import type {APIGatewayProxyEvent, APIGatewayProxyResult, Context} from 'aws-lambda'
+import {getApiGatewayManagementApiClient} from '../getApiGatewayManagementApiClient'
+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
   createContext?: (event: APIGatewayProxyEvent) => inferRouterContext<Router> | Promise<inferRouterContext<Router>>
 }) => {
-  const {router, createContext} = opts;
+  const {router, createContext} = opts
 
   return async (event: APIGatewayProxyEvent, context: Context): Promise<APIGatewayProxyResult> => {
-    context.callbackWaitsForEmptyEventLoop = false;
-    const connection = getConnection(event);
+    context.callbackWaitsForEmptyEventLoop = false
+    const connection = getConnection(event)
 
-    if (!event.body || event.body === '[]')
-      return {statusCode: 200, body: '{}'};
+    if (!event.body || event.body === '[]') return {statusCode: 200, body: '{}'}
 
-    const request = (JSON.parse(event.body) as TrpcSubscriptionRequest);
+    const request = JSON.parse(event.body) as TrpcSubscriptionRequest
 
     const sendMessage = async (response: TrpcSubscriptionResponse) => {
       await getApiGatewayManagementApiClient(connection.endpoint).send(
-          new PostToConnectionCommand({
-            ConnectionId: connection.connectionId,
-            Data: JSON.stringify(response),
-          }),
-      );
-    };
+        new PostToConnectionCommand({
+          ConnectionId: connection.connectionId,
+          Data: JSON.stringify(response),
+        }),
+      )
+    }
+    const isConnected = async (): Promise<boolean> => {
+      return getApiGatewayManagementApiClient(connection.endpoint)
+        .send(new GetConnectionCommand({ConnectionId: connection.connectionId}))
+        .then(() => true)
+        .catch(() => false)
+    }
     const stopConnection = async (): Promise<void> => {
       await sendMessage({
         id: request.id,
         result: {type: 'stopped'},
-      });
-    };
+      })
+    }
 
     try {
-      const messageQueue: TrpcSubscriptionResponse[] = [];
+      const messageQueue: TrpcSubscriptionResponse[] = []
 
       if (request.method === 'subscription.stop') {
-        await stopConnection();
+        await stopConnection()
       }
 
       if (request.method === 'subscription') {
         messageQueue.push({
           id: request.id,
           result: {type: 'started'},
-        });
+        })
 
-        const procedure = (await callTRPCProcedure({
+        const procedure = await callTRPCProcedure({
           procedures: router._def.procedures,
           path: request.params.path,
           type: 'subscription',
-          ctx: await createContext?.(event) || {},
+          ctx: (await createContext?.(event)) || {},
           getRawInput: async () => request.params.input,
-        }));
+        })
 
         if (!isObservable(procedure)) {
-          console.error(`observable`, procedure);
-          throw `Procedure is not an observable!`;
+          console.error(`observable`, procedure)
+          throw `Procedure is not an observable!`
         }
 
         procedure.subscribe({
@@ -71,44 +76,56 @@ export const awsLambdaTrpcSubscriptionRequestHandler = <Router extends AnyTRPCRo
                 type: 'data',
                 data: data,
               },
-            });
+            })
           },
           error: (err) => {
-            console.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;
+        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;
+          if (messageQueue.length === 0) await new Promise((resolve) => setTimeout(resolve, 10))
+          const message = messageQueue.shift()
+          if (!message) continue
 
-          await sendMessage(message);
+          await sendMessage(message)
 
-          stopped = message.result.type === 'stopped';
+          stopped = message.result.type === 'stopped'
+
+          if (Date.now() > lastPing + pingIntervalMs) {
+            if (!(await isConnected())) {
+              console.info('Connection closed by client')
+              stopped = true
+            }
+            lastPing = Date.now()
+          }
         }
       }
     } catch (err) {
-      console.error(err);
-      await stopConnection();
+      if (err instanceof GoneException) {
+        console.info('Connection closed by client')
+      } else {
+        console.error(err)
+        await stopConnection()
+      }
     }
 
     return {
       statusCode: 200,
       body: '{}',
-    };
-  };
-};
+    }
+  }
+}

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

@@ -1,8 +1,5 @@
-import type {Observable} from '@trpc/server/observable';
+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;
-};
+  return !!value && typeof value === 'object' && `subscribe` in value && `pipe` in value
+}

package/src/ws/types/WsApiRequestHandler.ts

@@ -1,15 +1,16 @@
-import {OmitNever} from '../../types/OmitNever';
-import {WsApiConnection} from './WsApiConnection';
-import {WsApiAction, WsApiRequest, WsApiResponse} from './common';
+import type {OmitNever} from '../../types/OmitNever'
+import type {WsApiConnection} from './WsApiConnection'
+import type {WsApiAction, WsApiRequest, WsApiResponse} from './common'
 
 export type WsApiRequestHandler<
-    Action extends WsApiAction,
-    Request extends WsApiRequest<Action>,
-    Response extends WsApiResponse,
-> = (request: Request & { action: Action }, responseActions: OmitNever<{
-  connection: WsApiConnection
-  sendResponse: [Response] extends [never] ? never : (response: Response) => Promise<void>
-  closeConnection: () => Promise<void>
-}>) => Promise<void>;
-
-
+  Action extends WsApiAction,
+  Request extends WsApiRequest<Action>,
+  Response extends WsApiResponse,
+> = (
+  request: Request & {action: Action},
+  responseActions: OmitNever<{
+    connection: WsApiConnection
+    sendResponse: [Response] extends [never] ? never : (response: Response) => Promise<void>
+    closeConnection: () => Promise<void>
+  }>,
+) => Promise<void>

package/src/ws/types/WsApiRoute.ts

@@ -1,9 +1,9 @@
-import {WsApiAction, WsApiRequest, WsApiResponse} from './common';
+import type {WsApiAction, WsApiRequest, WsApiResponse} from './common'
 
 export type WsApiRoute<
-    Action extends WsApiAction,
-    Request extends WsApiRequest<Action>,
-    Response extends WsApiResponse,
+  Action extends WsApiAction,
+  Request extends WsApiRequest<Action>,
+  Response extends WsApiResponse,
 > = {
   action: Action
 
@@ -11,7 +11,5 @@ export type WsApiRoute<
   __types?: {
     Request: Request
     Response: Response
-  };
-};
-
-
+  }
+}

package/src/ws/types/WsApiRouteHandler.ts

@@ -1,14 +1,12 @@
-import {WsApiRequestHandler} from './WsApiRequestHandler';
-import {WsApiRoute} from './WsApiRoute';
-import {WsApiAction, WsApiRequest, WsApiResponse} from './common';
+import type {WsApiRequestHandler} from './WsApiRequestHandler'
+import type {WsApiRoute} from './WsApiRoute'
+import type {WsApiAction, WsApiRequest, WsApiResponse} from './common'
 
 export type WsApiRouteHandler<
-    Action extends WsApiAction,
-    Request extends WsApiRequest<Action>,
-    Response extends WsApiResponse,
+  Action extends WsApiAction,
+  Request extends WsApiRequest<Action>,
+  Response extends WsApiResponse,
 > = {
-  route: WsApiRoute<Action, Request, Response>,
+  route: WsApiRoute<Action, Request, Response>
   requestHandler: WsApiRequestHandler<Action, Request, Response>
 }
-
-

package/src/ws/types/common/WsApiRequest.ts

@@ -1,3 +1,3 @@
-import {WsApiAction} from './WsApiAction';
+import type {WsApiAction} from './WsApiAction'
 
-export type WsApiRequest<Action extends WsApiAction> = { action: Action }
+export type WsApiRequest<Action extends WsApiAction> = {action: Action}

package/src/ws/types/index.ts

@@ -1,5 +1,5 @@
-export * from './common';
-export * from './WsApiConnection';
-export * from './WsApiRequestHandler';
-export * from './WsApiRoute';
-export * from './WsApiRouteHandler';
+export * from './common'
+export * from './WsApiConnection'
+export * from './WsApiRequestHandler'
+export * from './WsApiRoute'
+export * from './WsApiRouteHandler'