Drop *HandlerDefinitions export to expose defns as *Handlers directly

Previously, {request,webSocket}Handlers was the implementation
instances while *HandlerDefinitions was the remote-client side handler
definitions themselves.

This is annoying though - you never need handler implementations
outside Mockttp, so in the few cases you need this, it just makes
all the names much longer for no benefit.

As step one of a larger redesign of this API, the *Handlers export now
exposes the definitions directly, and the *HandlerDefinitions export is
removed.

Author: pimterry

src/main.browser.ts

@@ -11,34 +11,11 @@ import * as completionCheckers from './rules/completion-checkers';
 
 export {
     matchers,
-    requestHandlerDefinitions,
-    webSocketHandlerDefinitions,
+    requestHandlerDefinitions as requestHandlers,
+    webSocketHandlerDefinitions as webSocketHandlers,
     completionCheckers
 };
 
-// We re-export definitions to pretend they're real handlers in the browser. This should be safe
-// because the missing methods (i.e. handle()) were always unusable in non-Node environments anyway.
-// In practice though, new browser code using this should actively use requestHandlerDefinitions instead.
-// In future, we should probably expose definitions only for both browsers & node, but that's a
-// breaking change.
-export const requestHandlers = {
-    'SimpleHandler': requestHandlerDefinitions.SimpleHandlerDefinition,
-    'CallbackHandler': requestHandlerDefinitions.CallbackHandlerDefinition,
-    'StreamHandler': requestHandlerDefinitions.StreamHandlerDefinition,
-    'FileHandler': requestHandlerDefinitions.FileHandlerDefinition,
-    'PassThroughHandler': requestHandlerDefinitions.PassThroughHandlerDefinition,
-    'CloseConnectionHandler': requestHandlerDefinitions.CloseConnectionHandlerDefinition,
-    'TimeoutHandler': requestHandlerDefinitions.TimeoutHandlerDefinition,
-    'HandlerLookup': requestHandlerDefinitions.HandlerDefinitionLookup
-};
-
-export const webSocketHandlers = {
-    'PassThroughWebSocketHandler': webSocketHandlerDefinitions.PassThroughWebSocketHandlerDefinition,
-    'CloseConnectionHandler': webSocketHandlerDefinitions.CloseConnectionHandlerDefinition,
-    'TimeoutHandler': webSocketHandlerDefinitions.TimeoutHandlerDefinition,
-    'WsHandlerLookup': webSocketHandlerDefinitions.WsHandlerDefinitionLookup
-};
-
 export { MOCKTTP_PARAM_REF } from './rules/rule-parameters';
 
 // Export the core API:

src/main.ts

@@ -26,18 +26,19 @@ export type {
 
 // Export rule data builders & type definitions:
 import * as matchers from './rules/matchers';
-import * as requestHandlers from './rules/requests/request-handlers';
+import type { RequestHandler, RequestHandlerOptions } from './rules/requests/request-handlers';
 import * as requestHandlerDefinitions from './rules/requests/request-handler-definitions';
-import * as webSocketHandlers from './rules/websockets/websocket-handlers';
+import type { WebSocketHandler } from './rules/websockets/websocket-handlers';
 import * as webSocketHandlerDefinitions from './rules/websockets/websocket-handler-definitions';
 import * as completionCheckers from './rules/completion-checkers';
 
 export {
     matchers,
-    requestHandlers,
-    requestHandlerDefinitions,
-    webSocketHandlers,
-    webSocketHandlerDefinitions,
+    RequestHandler,
+    RequestHandlerOptions,
+    requestHandlerDefinitions as requestHandlers,
+    WebSocketHandler,
+    webSocketHandlerDefinitions as webSocketHandlers,
     completionCheckers
 };
 

test/integration/manual-rule-building.spec.ts

@@ -13,7 +13,7 @@ describe("Mockttp rule building", function () {
     it("should allow manually adding a single rule", async () => {
         await server.addRequestRules({
             matchers: [new matchers.SimplePathMatcher('/endpoint')],
-            handler: new requestHandlers.SimpleHandler(200, '', 'mock response'),
+            handler: new requestHandlers.SimpleHandlerDefinition(200, '', 'mock response'),
         });
 
         let response = await fetch(server.urlFor('/endpoint'));
@@ -28,7 +28,7 @@ describe("Mockttp rule building", function () {
         const rule = await server.addRequestRules({
             id: manualId,
             matchers: [new matchers.SimplePathMatcher('/endpoint')],
-            handler: new requestHandlers.SimpleHandler(200, '', 'mock response'),
+            handler: new requestHandlers.SimpleHandlerDefinition(200, '', 'mock response'),
         });
 
         expect(rule[0].id).to.equal(manualId);
@@ -37,11 +37,11 @@ describe("Mockttp rule building", function () {
     it("should allow repeatedly adding rules", async () => {
         await server.addRequestRules({
             matchers: [new matchers.SimplePathMatcher('/endpoint')],
-            handler: new requestHandlers.SimpleHandler(200, '', 'first mock response'),
+            handler: new requestHandlers.SimpleHandlerDefinition(200, '', 'first mock response'),
         });
         await server.addRequestRules({
             matchers: [new matchers.SimplePathMatcher('/endpoint')],
-            handler: new requestHandlers.SimpleHandler(200, '', 'second mock response'),
+            handler: new requestHandlers.SimpleHandlerDefinition(200, '', 'second mock response'),
         });
 
         let firstResponse = await fetch(server.urlFor('/endpoint'));
@@ -56,11 +56,11 @@ describe("Mockttp rule building", function () {
     it("should allow completely replacing rules", async () => {
         await server.addRequestRules({
             matchers: [new matchers.SimplePathMatcher('/endpoint')],
-            handler: new requestHandlers.SimpleHandler(200, '',  'original mock response')
+            handler: new requestHandlers.SimpleHandlerDefinition(200, '',  'original mock response')
         });
         await server.setRequestRules({
             matchers: [new matchers.SimplePathMatcher('/endpoint')],
-            handler: new requestHandlers.SimpleHandler(200, '', 'replacement mock response')
+            handler: new requestHandlers.SimpleHandlerDefinition(200, '', 'replacement mock response')
         });
 
         let firstResponse = await fetch(server.urlFor('/endpoint'));
@@ -72,7 +72,7 @@ describe("Mockttp rule building", function () {
     it("should allow adding websocket rules", async function () {
         await server.addWebSocketRules({
             matchers: [new matchers.WildcardMatcher()],
-            handler: new webSocketHandlers.PassThroughWebSocketHandler({
+            handler: new webSocketHandlers.PassThroughWebSocketHandlerDefinition({
                 forwarding: {
                     // Simple echo fixture, see websocket-test-server.js
                     targetHost: 'ws://localhost:8694'
@@ -97,7 +97,7 @@ describe("Mockttp rule building", function () {
         return expect((async () => { // Funky setup to handle sync & async failure for node & browser
             await server.addRequestRules({
                 matchers: [],
-                handler: new requestHandlers.SimpleHandler(200, 'mock response'),
+                handler: new requestHandlers.SimpleHandlerDefinition(200, 'mock response'),
             })
         })()).to.be.rejectedWith('Cannot create a rule without at least one matcher');
     });