fix: gatwayHandler types are now more narrow

lib/gateway.ts

@@ -1,6 +1,6 @@
-import { Handler } from 'aws-lambda'
 import { GRAPHQL_TRANSPORT_WS_PROTOCOL, MessageType } from 'graphql-ws'
 import {
+  ApiGatewayHandler,
   APIGatewayWebSocketEvent,
   ServerClosure,
   WebsocketResponse,
@@ -13,7 +13,7 @@ import { connection_init } from './messages/connection_init'
 import { pong } from './messages/pong'
 
 export const handleGatewayEvent =
-  (server: ServerClosure): Handler<APIGatewayWebSocketEvent, WebsocketResponse> =>
+  (server: ServerClosure): ApiGatewayHandler<APIGatewayWebSocketEvent, WebsocketResponse> =>
     async (event) => {
       if (!event.requestContext) {
         return {

lib/index-test.ts

@@ -0,0 +1,25 @@
+import { assert } from 'chai'
+import { Handler } from 'aws-lambda'
+import { tables } from '@architect/sandbox'
+import { createInstance } from '.'
+import { mockServerArgs } from './test/mockServer'
+import { APIGatewayWebSocketEvent, WebsocketResponse } from './types'
+
+describe('createInstance', () => {
+  describe('gatewayHandler', () => {
+    before(async () => {
+      await tables.start({ cwd: './mocks/arc-basic-events', quiet: true })
+    })
+
+    after(async () => {
+      tables.end()
+    })
+
+    it('is type compatible with aws-lambda handler', async () => {
+      const server = createInstance(await mockServerArgs())
+
+      const gatewayHandler: Handler<APIGatewayWebSocketEvent, WebsocketResponse> = server.gatewayHandler
+      assert.ok(gatewayHandler)
+    })
+  })
+})

lib/messages/subscribe-test.ts

@@ -1,7 +1,7 @@
 import { assert } from 'chai'
 import { tables } from '@architect/sandbox'
 import { subscribe } from './subscribe'
-import { mockServerContext } from '../test/mockServerContext'
+import { mockServerContext } from '../test/mockServer'
 import { connection_init } from './connection_init'
 import { equals } from '@aws/dynamodb-expressions'
 import { collect } from 'streaming-iterables'

lib/test/mockServerContext.ts → lib/test/mockServer.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
 import { makeExecutableSchema } from '@graphql-tools/schema'
 import { tables as arcTables } from '@architect/functions'
 import { makeServerClosure } from '../makeServerClosure'
@@ -33,26 +34,33 @@ const schema = makeExecutableSchema({
   resolvers,
 })
 
+const ensureName = (tables: any, table: string) => {
+  const actualTableName = tables.name(table)
+  if (!actualTableName) {
+    throw new Error(`No table found for ${table}`)
+  }
+  return actualTableName
+}
 
-export const mockServerContext = async (args: Partial<ServerArgs>): Promise<ServerClosure> => {
+export const mockServerArgs = async (args: Partial<ServerArgs> = {}): Promise<ServerArgs> => {
   const tables = await arcTables()
 
-  const ensureName = (table) => {
-    const actualTableName = tables.name(table)
-    if (!actualTableName) {
-      throw new Error(`No table found for ${table}`)
-    }
-    return actualTableName
-  }
-
-  return makeServerClosure({
+  return {
     dynamodb: arcTables.db,
     schema,
     tableNames: {
-      connections: ensureName('Connection'),
-      subscriptions: ensureName('Subscription'),
+      connections: ensureName(tables, 'Connection'),
+      subscriptions: ensureName(tables, 'Subscription'),
+    },
+    apiGatewayManagementApi: {
+      postToConnection: () => ({ promise: async () => { } }),
+      deleteConnection: () => ({ promise: async () => { } }),
     },
     onError: (err) => { console.log('onError'); throw err },
     ...args,
-  })
+  }
+}
+
+export const mockServerContext = async (args?: Partial<ServerArgs>): Promise<ServerClosure> => {
+  return makeServerClosure(await mockServerArgs(args))
 }

lib/types.ts

@@ -2,7 +2,7 @@
 /* eslint-disable @typescript-eslint/ban-types */
 import { ConnectionInitMessage, PingMessage, PongMessage } from 'graphql-ws'
 import { DataMapper } from '@aws/dynamodb-data-mapper'
-import { APIGatewayEventRequestContext, APIGatewayProxyEvent, Handler } from 'aws-lambda'
+import { APIGatewayEventRequestContext, APIGatewayProxyEvent } from 'aws-lambda'
 import { GraphQLResolveInfo, GraphQLSchema } from 'graphql'
 import { DynamoDB } from 'aws-sdk'
 import { Subscription } from './model/Subscription'
@@ -48,7 +48,7 @@ export type ServerClosure = {
 } & Omit<ServerArgs, 'tableNames'>
 
 export interface ServerInstance {
-  gatewayHandler: Handler<APIGatewayWebSocketEvent, WebsocketResponse>
+  gatewayHandler: ApiGatewayHandler<APIGatewayWebSocketEvent, WebsocketResponse>
   stateMachineHandler: (input: StateFunctionInput) => Promise<StateFunctionInput>
   publish: (event: PubSubEvent) => Promise<void>
   complete: (event: PubSubEvent) => Promise<void>
@@ -123,3 +123,5 @@ export interface SubscribeOptions {
   onComplete?: (...args: SubscribeArgs) => void | Promise<void>
   onAfterSubscribe?: (...args: SubscribeArgs) => PubSubEvent | Promise<PubSubEvent> | undefined | Promise<undefined>
 }
+
+export type ApiGatewayHandler<TEvent = any, TResult = any> = (event: TEvent) => void | Promise<TResult>