@mstuercke/api-utils 6.0.0 → 6.0.1

package/src/rest/types/index.ts

@@ -1,8 +1,8 @@
-export * from './common';
-export * from './RestApiRequest';
-export * from './RestApiRequestHandler';
-export * from './RestApiRequestHandlerWithAuthentication';
-export * from './RestApiResponse';
-export * from './RestApiRoute';
-export * from './RestApiRouteHandler';
-export * from './RestApiRouteWithAuthentication';
+export * from './common'
+export * from './RestApiRequest'
+export * from './RestApiRequestHandler'
+export * from './RestApiRequestHandlerWithAuthentication'
+export * from './RestApiResponse'
+export * from './RestApiRoute'
+export * from './RestApiRouteHandler'
+export * from './RestApiRouteWithAuthentication'

package/src/rest/types/internal/InternalRestApiRequest.ts

@@ -1,19 +1,21 @@
-import {OmitNever} from '../../../types/OmitNever';
-import {RestApiRequest} from '../RestApiRequest';
-import {
+import type {OmitNever} from '../../../types/OmitNever'
+import type {RestApiRequest} from '../RestApiRequest'
+import type {
   RestPathParams,
   RestQueryParams,
   RestRequestBody,
   RestRequestHeaders,
   RestRequireAuthentication,
-} from '../common';
+} from '../common'
 
 export type InternalRestApiRequest<
-    PathParams extends RestPathParams = never,
-    QueryParams extends RestQueryParams = never,
-    RequestHeaders extends RestRequestHeaders = never,
-    RequestBody extends RestRequestBody = never,
-    RequireAuthentication extends RestRequireAuthentication = false> = OmitNever<
-    RestApiRequest<PathParams, QueryParams, RequestHeaders, RequestBody>
-    & { userId: RequireAuthentication extends true ? string : never }>
-
+  PathParams extends RestPathParams = never,
+  QueryParams extends RestQueryParams = never,
+  RequestHeaders extends RestRequestHeaders = never,
+  RequestBody extends RestRequestBody = never,
+  RequireAuthentication extends RestRequireAuthentication = false,
+> = OmitNever<
+  RestApiRequest<PathParams, QueryParams, RequestHeaders, RequestBody> & {
+    userId: RequireAuthentication extends true ? string : never
+  }
+>

package/src/types/OmitNever.ts

@@ -1 +1 @@
-export type OmitNever<T> = { [P in keyof T as T[P] extends never ? never : P]: T[P] };
+export type OmitNever<T> = {[P in keyof T as T[P] extends never ? never : P]: T[P]}

package/src/ws/client/useWsApi.ts

@@ -1,82 +1,93 @@
-import {useCallback, useMemo, useRef, useState} from 'react';
-import {WsApiAction, WsApiRequest, WsApiResponse, WsApiRoute} from '../types';
+import {useCallback, useMemo, useRef, useState} from 'react'
+import type {WsApiAction, WsApiRequest, WsApiResponse, WsApiRoute} from '../types'
 
-type WsApiConnection<
-    Action extends WsApiAction,
-    Request extends WsApiRequest<Action>,
-> = {
+type WsApiConnection<Action extends WsApiAction, Request extends WsApiRequest<Action>> = {
   disconnect: () => void
   sendRequest: (request: Request) => void
 }
 
 export type WsApiOptions<
-    Action extends WsApiAction,
-    Request extends WsApiRequest<Action>,
-    Response extends WsApiResponse> = {
+  Action extends WsApiAction,
+  Request extends WsApiRequest<Action>,
+  Response extends WsApiResponse,
+> = {
   onConnected?: (connection: WsApiConnection<Action, Request>) => void
   onResponse?: (response: Response, connection: WsApiConnection<Action, Request>) => void
   onError?: (error: unknown, connection: WsApiConnection<Action, Request>) => void
   onDisconnected?: () => void
 }
 export const useWsApi = <
-    Action extends WsApiAction,
-    Request extends WsApiRequest<Action>,
-    Response extends WsApiResponse
->(wsApiUrl: string, route: WsApiRoute<Action, Request, Response> | undefined) => {
-  const [error, setError] = useState<boolean>(false);
-  const [connected, setConnected] = useState<boolean>(false);
-  const webSocket = useRef<WebSocket>();
+  Action extends WsApiAction,
+  Request extends WsApiRequest<Action>,
+  Response extends WsApiResponse,
+>(
+  wsApiUrl: string,
+  route: WsApiRoute<Action, Request, Response> | undefined,
+) => {
+  const [error, setError] = useState<boolean>(false)
+  const [connected, setConnected] = useState<boolean>(false)
+  const webSocket = useRef<WebSocket>()
 
-  const sendRequest = useCallback((request: Omit<Request, 'action'>) => {
-    if (!route) throw 'Not route';
-    if (!webSocket.current) throw 'Not connected';
+  const sendRequest = useCallback(
+    (request: Omit<Request, 'action'>) => {
+      if (!route) throw 'Not route'
+      if (!webSocket.current) throw 'Not connected'
 
-    webSocket.current.send(JSON.stringify({
-      ...request,
-      action: route.action,
-    }));
-  }, [route]);
-  const disconnect = useCallback(() => webSocket.current?.close(), [webSocket]);
+      webSocket.current.send(
+        JSON.stringify({
+          ...request,
+          action: route.action,
+        }),
+      )
+    },
+    [route],
+  )
+  const disconnect = useCallback(() => webSocket.current?.close(), [])
   const connection: WsApiConnection<Action, Request> = useMemo(() => {
     return {
       disconnect,
       sendRequest,
-    };
-  }, [disconnect, sendRequest]);
+    }
+  }, [disconnect, sendRequest])
 
-  const connect = useCallback(async (options: WsApiOptions<Action, Request, Response>) => {
-    return new Promise<void>((resolve) => {
-      if (webSocket.current && (webSocket.current.readyState === WebSocket.CONNECTING || webSocket.current.readyState === WebSocket.OPEN))
-        throw 'Already connected';
+  const connect = useCallback(
+    async (options: WsApiOptions<Action, Request, Response>) => {
+      return new Promise<void>((resolve) => {
+        if (
+          webSocket.current &&
+          (webSocket.current.readyState === WebSocket.CONNECTING || webSocket.current.readyState === WebSocket.OPEN)
+        )
+          throw 'Already connected'
 
-      webSocket.current = new WebSocket(wsApiUrl);
+        webSocket.current = new WebSocket(wsApiUrl)
 
-      webSocket.current.onopen = () => {
-        setConnected(true);
-        setError(false);
-        options?.onConnected?.(connection);
-      };
+        webSocket.current.onopen = () => {
+          setConnected(true)
+          setError(false)
+          options?.onConnected?.(connection)
+        }
 
-      webSocket.current.onmessage = (ev) => {
-        if (!ev.data || ev.data === '{}')
-          return;
-        setError(false);
-        options?.onResponse?.(JSON.parse(ev.data as string), connection);
-      };
+        webSocket.current.onmessage = (ev) => {
+          if (!ev.data || ev.data === '{}') return
+          setError(false)
+          options?.onResponse?.(JSON.parse(ev.data as string), connection)
+        }
 
-      webSocket.current.onerror = (error) => {
-        setError(false);
-        options?.onError?.(error, connection);
-      };
+        webSocket.current.onerror = (error) => {
+          setError(false)
+          options?.onError?.(error, connection)
+        }
 
-      webSocket.current.onclose = () => {
-        setConnected(false);
-        options?.onDisconnected?.();
-        webSocket.current = undefined;
-        resolve();
-      };
-    });
-  }, [wsApiUrl, connection]);
+        webSocket.current.onclose = () => {
+          setConnected(false)
+          options?.onDisconnected?.()
+          webSocket.current = undefined
+          resolve()
+        }
+      })
+    },
+    [wsApiUrl, connection],
+  )
 
   return {
     connect,
@@ -84,5 +95,5 @@ export const useWsApi = <
     connection,
     error,
     disconnect,
-  };
-};
+  }
+}

package/src/ws/server/WsApi.ts

@@ -1,75 +1,73 @@
-import {APIGatewayProxyEvent, APIGatewayProxyResult} from 'aws-lambda';
-import {
+import type {APIGatewayProxyEvent, APIGatewayProxyResult} from 'aws-lambda'
+import type {
   WsApiAction,
   WsApiConnection,
   WsApiRequest,
   WsApiRequestHandler,
   WsApiResponse,
   WsApiRouteHandler,
-} from '../types';
-import {closeConnection} from './closeConnection';
-import {sendResponse} from './sendResponse';
+} from '../types'
+import {closeConnection} from './closeConnection'
+import {sendResponse} from './sendResponse'
 
 export class WsApi {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private readonly routeHandlers: { [action: WsApiAction]: WsApiRequestHandler<any, any, any> } = {
-    '$connect': () => Promise.resolve(),
-    '$disconnect': () => Promise.resolve(),
-  };
+  private readonly routeHandlers: {[action: WsApiAction]: WsApiRequestHandler<any, any, any>} = {
+    $connect: () => Promise.resolve(),
+    $disconnect: () => Promise.resolve(),
+  }
 
-  addRouteHandler<
-      Action extends WsApiAction,
-      Request extends WsApiRequest<Action>,
-      Response extends WsApiResponse
-  >(routeHandler: WsApiRouteHandler<Action, Request, Response>) {
-    this.routeHandlers[routeHandler.route.action] = routeHandler.requestHandler;
-    return this;
+  addRouteHandler<Action extends WsApiAction, Request extends WsApiRequest<Action>, Response extends WsApiResponse>(
+    routeHandler: WsApiRouteHandler<Action, Request, Response>,
+  ) {
+    this.routeHandlers[routeHandler.route.action] = routeHandler.requestHandler
+    return this
   }
 
   async handleRequest(event: APIGatewayProxyEvent): Promise<APIGatewayProxyResult> {
-    const {connectionId, domainName, stage, eventType} = event.requestContext;
+    const {connectionId, domainName, stage, eventType} = event.requestContext
 
-    if (!eventType) throw 'No eventType';
-    if (!connectionId) throw 'No connectionId';
-    if (!domainName) throw 'No domainName';
+    if (!eventType) throw 'No eventType'
+    if (!connectionId) throw 'No connectionId'
+    if (!domainName) throw 'No domainName'
 
-    let request: WsApiRequest<WsApiAction>;
+    let request: WsApiRequest<WsApiAction>
     switch (eventType) {
       case 'CONNECT':
-        request = {action: '$connect'};
-        break;
+        request = {action: '$connect'}
+        break
 
       case 'DISCONNECT':
-        request = {action: '$disconnect'};
-        break;
+        request = {action: '$disconnect'}
+        break
 
       case 'MESSAGE':
-        if (!event.body) throw 'No body';
-        request = JSON.parse(event.body) as WsApiRequest<WsApiAction>;
-        break;
+        if (!event.body) throw 'No body'
+        request = JSON.parse(event.body) as WsApiRequest<WsApiAction>
+        break
 
       default:
-        throw `Unknown eventType ${eventType}`;
+        throw `Unknown eventType ${eventType}`
     }
 
-    const endpoint = `https://${domainName}/${stage}`;
-    const connection: WsApiConnection = {endpoint, connectionId};
+    const endpoint = `https://${domainName}/${stage}`
+    const connection: WsApiConnection = {endpoint, connectionId}
 
-    const requestHandler = this.routeHandlers[request.action];
+    const requestHandler = this.routeHandlers[request.action]
     if (!requestHandler) {
-      await closeConnection(connection);
-      throw `No requestHandler found for action ${request.action}`;
+      await closeConnection(connection)
+      throw `No requestHandler found for action ${request.action}`
     }
 
     await requestHandler(request, {
       connection,
       sendResponse: async (response) => await sendResponse(connection, response),
       closeConnection: async () => await closeConnection(connection),
-    });
+    })
 
     return {
       statusCode: 200,
       body: '',
-    };
+    }
   }
 }

package/src/ws/server/buildWsApiRouteHandler.ts

@@ -1,15 +1,22 @@
-import {WsApiAction, WsApiRequest, WsApiRequestHandler, WsApiResponse, WsApiRoute, WsApiRouteHandler} from '../types';
+import type {
+  WsApiAction,
+  WsApiRequest,
+  WsApiRequestHandler,
+  WsApiResponse,
+  WsApiRoute,
+  WsApiRouteHandler,
+} from '../types'
 
 export const buildWsApiRouteHandler = <
-    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>,
-    requestHandler: WsApiRequestHandler<Action, Request, Response>,
+  route: WsApiRoute<Action, Request, Response>,
+  requestHandler: WsApiRequestHandler<Action, Request, Response>,
 ): WsApiRouteHandler<Action, Request, Response> => {
   return {
     route,
     requestHandler,
-  };
-};
+  }
+}

package/src/ws/server/closeConnection.ts

@@ -1,16 +1,13 @@
-import {DeleteConnectionCommand} from '@aws-sdk/client-apigatewaymanagementapi';
-import {WsApiConnection} from '../types';
-import {getApiGatewayManagementApiClient} from './getApiGatewayManagementApiClient';
+import {DeleteConnectionCommand} from '@aws-sdk/client-apigatewaymanagementapi'
+import type {WsApiConnection} from '../types'
+import {getApiGatewayManagementApiClient} from './getApiGatewayManagementApiClient'
 
 export const closeConnection = async ({endpoint, connectionId}: WsApiConnection) => {
   try {
-    await getApiGatewayManagementApiClient(endpoint).send(
-        new DeleteConnectionCommand({ConnectionId: connectionId}),
-    );
+    await getApiGatewayManagementApiClient(endpoint).send(new DeleteConnectionCommand({ConnectionId: connectionId}))
   } catch (err) {
-    if (err && typeof err === 'object' && 'name' in err && err?.name === 'GoneException')
-      return;
+    if (err && typeof err === 'object' && 'name' in err && err?.name === 'GoneException') return
 
-    throw err;
+    throw err
   }
-};
+}

package/src/ws/server/getApiGatewayManagementApiClient.ts

@@ -1,11 +1,10 @@
-import {ApiGatewayManagementApiClient} from '@aws-sdk/client-apigatewaymanagementapi';
+import {ApiGatewayManagementApiClient} from '@aws-sdk/client-apigatewaymanagementapi'
 
-const clients: { [endpoint: string]: ApiGatewayManagementApiClient } = {};
+const clients: {[endpoint: string]: ApiGatewayManagementApiClient} = {}
 export const getApiGatewayManagementApiClient = (endpoint: string): ApiGatewayManagementApiClient => {
-  if (clients[endpoint])
-    return clients[endpoint];
+  if (clients[endpoint]) return clients[endpoint]
 
-  const client = new ApiGatewayManagementApiClient({endpoint});
-  clients[endpoint] = client;
-  return client;
-};
+  const client = new ApiGatewayManagementApiClient({endpoint})
+  clients[endpoint] = client
+  return client
+}

package/src/ws/server/getConnection.ts

@@ -1,12 +1,11 @@
-import {APIGatewayProxyEvent} from 'aws-lambda';
-import {WsApiConnection} from '../types';
+import type {APIGatewayProxyEvent} from 'aws-lambda'
+import type {WsApiConnection} from '../types'
 
 export const getConnection = (event: APIGatewayProxyEvent): WsApiConnection => {
-  if (!event.requestContext.connectionId)
-    throw 'no connectionId';
+  if (!event.requestContext.connectionId) throw 'no connectionId'
 
   return {
     endpoint: `https://${event.requestContext.domainName}/${event.requestContext.stage}`,
     connectionId: event.requestContext.connectionId,
-  };
-};
+  }
+}

package/src/ws/server/index.ts

@@ -1,8 +1,8 @@
-export * from './trpc/TrpcSubscriptionRequest';
-export * from './trpc/TrpcSubscriptionResponse';
-export * from './trpc/awsLambdaTrpcSubscriptionRequestHandler';
-export * from './buildWsApiRouteHandler';
-export * from './closeConnection';
-export * from './getConnection';
-export * from './sendResponse';
-export * from './WsApi';
+export * from './trpc/TrpcSubscriptionRequest'
+export * from './trpc/TrpcSubscriptionResponse'
+export * from './trpc/awsLambdaTrpcSubscriptionRequestHandler'
+export * from './buildWsApiRouteHandler'
+export * from './closeConnection'
+export * from './getConnection'
+export * from './sendResponse'
+export * from './WsApi'

package/src/ws/server/sendResponse.ts

@@ -1,17 +1,15 @@
-import {PostToConnectionCommand} from '@aws-sdk/client-apigatewaymanagementapi';
-import {WsApiConnection, WsApiResponse} from '../types';
-import {getApiGatewayManagementApiClient} from './getApiGatewayManagementApiClient';
+import {PostToConnectionCommand} from '@aws-sdk/client-apigatewaymanagementapi'
+import type {WsApiConnection, WsApiResponse} from '../types'
+import {getApiGatewayManagementApiClient} from './getApiGatewayManagementApiClient'
 
-export const sendResponse = async <
-    Response extends WsApiResponse
->({
-    endpoint,
-    connectionId,
-  }: WsApiConnection, response: Response): Promise<void> => {
+export const sendResponse = async <Response extends WsApiResponse>(
+  {endpoint, connectionId}: WsApiConnection,
+  response: Response,
+): Promise<void> => {
   await getApiGatewayManagementApiClient(endpoint).send(
-      new PostToConnectionCommand({
-        ConnectionId: connectionId,
-        Data: JSON.stringify(response),
-      }),
-  );
-};
+    new PostToConnectionCommand({
+      ConnectionId: connectionId,
+      Data: JSON.stringify(response),
+    }),
+  )
+}

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

@@ -1,8 +1,10 @@
-export type TrpcSubscriptionRequest<Input = unknown> = {
-  id: number | string
-  method: 'subscription'
-  params: { path: string, input?: Input }
-} | {
-  id: number | string
-  method: 'subscription.stop'
-}
+export type TrpcSubscriptionRequest<Input = unknown> =
+  | {
+      id: number | string
+      method: 'subscription'
+      params: {path: string; input?: Input}
+    }
+  | {
+      id: number | string
+      method: 'subscription.stop'
+    }

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

@@ -1,8 +1,4 @@
 export type TrpcSubscriptionResponse<Data = unknown> = {
-  id: number | string;
-  result: (
-      | { type: 'data', data: Data }
-      | { type: 'started' }
-      | { type: 'stopped' }
-      )
+  id: number | string
+  result: {type: 'data'; data: Data} | {type: 'started'} | {type: 'stopped'}
 }