Enforce that rule part types/uiTypes match the lookup keys

This includes adding uiType fields where they were previously implicit
in serialization, and fixing up a few other types similarly.

Author: pimterry

src/model/rules/definitions/http-rule-definitions.ts

@@ -19,13 +19,13 @@ import { CUSTOM_RULE_EQUALS } from '../rules-structure';
 // Create per-method classes (that all serialize to the same MethodMatcher class + param)
 // for each supported HTTP method, as a methodName -> methodClass lookup object.
 export const MethodMatchers = _.reduce<MethodName, {
-    [key in MethodName]: { new(): httpMatchers.MethodMatcher }
+    [K in MethodName]: { new(): TypedMethodMatcher<K> }
 }>(
     MethodNames,
     (result, method) => {
         result[method] = class SpecificMethodMatcher extends httpMatchers.MethodMatcher {
 
-            uiType = method;
+            readonly uiType = method;
 
             constructor() {
                 super(Method[method]);
@@ -34,12 +34,17 @@ export const MethodMatchers = _.reduce<MethodName, {
             explain() {
                 return `${Method[this.method]} requests`;
             }
-        };
+        } as any; // Difficult to get TS to infer or accept TypedMethodMatcher<typeof method>
         return result;
     },
     {} as any
 );
 
+// Tiny interface to let us make the METHOD -> methodMatcher{ uiType: METHOD } mapping explicit
+interface TypedMethodMatcher<R extends MethodName> extends httpMatchers.MethodMatcher {
+    readonly uiType: R;
+}
+
 // Override various specific & actions, so we can inject our own specific
 // explanations for certain cases
 
@@ -51,7 +56,7 @@ export class WildcardMatcher extends httpMatchers.WildcardMatcher {
 
 export class DefaultWildcardMatcher extends httpMatchers.WildcardMatcher {
 
-    uiType = 'default-wildcard';
+    readonly uiType = 'default-wildcard';
 
     explain() {
         return 'Any other requests';
@@ -60,7 +65,7 @@ export class DefaultWildcardMatcher extends httpMatchers.WildcardMatcher {
 
 export class AmIUsingMatcher extends httpMatchers.RegexPathMatcher {
 
-    uiType = 'am-i-using';
+    readonly uiType = 'am-i-using';
 
     constructor() {
         // Optional slash is for backward compat: for server 0.1.18+ it's always present
@@ -130,6 +135,8 @@ serializr.createModelSchema(PassThroughHandler, {
 
 export class ForwardToHostHandler extends httpHandlers.PassThroughHandlerDefinition {
 
+    readonly uiType = 'forward-to-host';
+
     constructor(forwardToLocation: string, updateHostHeader: boolean, rulesStore: RulesStore) {
         super({
             ...rulesStore.activePassthroughOptions,
@@ -160,6 +167,8 @@ export type ResponseTransform = httpHandlers.ResponseTransform;
 
 export class TransformingHandler extends httpHandlers.PassThroughHandlerDefinition {
 
+    readonly uiType = 'req-res-transformer';
+
     constructor(
         rulesStore: RulesStore,
         transformRequest: RequestTransform,
@@ -225,6 +234,8 @@ serializr.createModelSchema(TransformingHandler, {
 
 export class RequestBreakpointHandler extends httpHandlers.PassThroughHandlerDefinition {
 
+    readonly uiType = 'request-breakpoint';
+
     constructor(rulesStore: RulesStore) {
         super({
             ...rulesStore.activePassthroughOptions,
@@ -244,6 +255,8 @@ serializr.createModelSchema(RequestBreakpointHandler, {
 
 export class ResponseBreakpointHandler extends httpHandlers.PassThroughHandlerDefinition {
 
+    readonly uiType = 'response-breakpoint';
+
     constructor(rulesStore: RulesStore) {
         super({
             ...rulesStore.activePassthroughOptions,
@@ -264,6 +277,8 @@ serializr.createModelSchema(ResponseBreakpointHandler, {
 
 export class RequestAndResponseBreakpointHandler extends httpHandlers.PassThroughHandlerDefinition {
 
+    readonly uiType = 'request-and-response-breakpoint';
+
     constructor(rulesStore: RulesStore) {
         super({
             ...rulesStore.activePassthroughOptions,

src/model/rules/definitions/websocket-rule-definitions.ts

@@ -14,17 +14,17 @@ import {
 
 export class WebSocketWildcardMatcher extends WildcardMatcher {
 
-    uiType = 'ws-wildcard';
+    readonly uiType = 'ws-wildcard';
 
     explain() {
         return 'Any WebSocket';
     }
 
 }
 
-export class DefaultWebSocketWildcardMatcher extends WebSocketWildcardMatcher {
+export class DefaultWebSocketWildcardMatcher extends WildcardMatcher {
 
-    uiType = 'default-ws-wildcard';
+    readonly uiType = 'default-ws-wildcard';
 
     explain() {
         return 'Any other WebSockets';
@@ -63,7 +63,9 @@ export interface WebSocketMockRule extends Omit<WebSocketRuleData, 'matchers'> {
     type: 'websocket';
     activated: boolean;
     // WebSockets use the same HTTP matchers, but require an initial WebSocket matcher:
-    matchers: Array<HttpMatcher> & { 0?: WebSocketWildcardMatcher };
+    matchers: Array<HttpMatcher> & {
+        0?: WebSocketWildcardMatcher | DefaultWebSocketWildcardMatcher
+    };
     handler: WebSocketHandler;
     completionChecker: completionCheckers.Always; // HTK rules all *always* match
 };

src/model/rules/rules.ts

@@ -20,6 +20,8 @@ import {
     WebSocketMockRule
 } from './definitions/websocket-rule-definitions';
 
+/// --- Matchers ---
+
 // Define maps to/from matcher keys to matcher classes, and
 // types for the matchers & classes themselves; both the built-in
 // ones and our own extra additions & overrides.
@@ -30,14 +32,14 @@ export const MatcherLookup = {
 
 export type MatcherClassKey = keyof typeof MatcherLookup;
 export type MatcherClass = typeof MatcherLookup[MatcherClassKey];
-export type Matcher = InstanceType<MatcherClass>;
+export type Matcher = typeof MatcherLookup extends {
+    // Enforce that keys match .type or uiType for each matcher class:
+    [K in keyof typeof MatcherLookup]: new (...args: any[]) => { type: K } | { uiType: K }
+}
+    ? InstanceType<MatcherClass>
+    : never;
 
-export const MatcherKeys = new Map<MatcherClass, MatcherClassKey>(
-    Object.entries(MatcherLookup)
-    .map(
-        ([key, matcher]) => [matcher, key]
-    ) as Array<[MatcherClass, MatcherClassKey]>
-);
+/// --- Handlers ---
 
 // Define maps to/from handler keys to handler classes, and
 // types for the handlers & classes themselves; both the built-in
@@ -47,26 +49,21 @@ export const HandlerLookup = {
     ...WebSocketHandlerLookup
 };
 
-const PaidHandlerClasses: HandlerClass[] = [
-    StaticResponseHandler,
-    FromFileResponseHandler,
-    ForwardToHostHandler,
-    TransformingHandler,
-    TimeoutHandler,
-    CloseConnectionHandler
-];
-
-export const isPaidHandler = (handler: Handler) => {
-    return _.some(PaidHandlerClasses, (cls) => handler instanceof cls);
-}
-
-export const isPaidHandlerClass = (handlerClass: HandlerClass) => {
-    return PaidHandlerClasses.includes(handlerClass);
-}
+export const MatcherKeys = new Map<MatcherClass, MatcherClassKey>(
+    Object.entries(MatcherLookup)
+    .map(
+        ([key, matcher]) => [matcher, key]
+    ) as Array<[MatcherClass, MatcherClassKey]>
+);
 
 export type HandlerClassKey = keyof typeof HandlerLookup;
 export type HandlerClass = typeof HandlerLookup[HandlerClassKey];
-export type Handler = InstanceType<HandlerClass>;
+export type Handler = typeof HandlerLookup extends {
+    // Enforce that keys match .type or uiType for each handler class:
+    [K in keyof typeof HandlerLookup]: new (...args: any[]) => { type: K } | { uiType: K }
+}
+    ? InstanceType<HandlerClass>
+    : never;
 
 export const HandlerKeys = new Map<HandlerClass, HandlerClassKey>(
     Object.entries(HandlerLookup)
@@ -75,13 +72,34 @@ export const HandlerKeys = new Map<HandlerClass, HandlerClassKey>(
     ) as Array<[HandlerClass, HandlerClassKey]>
 );
 
+/// --- Matcher/handler special categories ---
+
 export const InitialMatcherClasses = [
     WildcardMatcher,
     ...Object.values(MethodMatchers)
 ];
 export type InitialMatcherClass = typeof InitialMatcherClasses[0];
 export type InitialMatcher = InstanceType<InitialMatcherClass>;
 
+const PaidHandlerClasses: HandlerClass[] = [
+    StaticResponseHandler,
+    FromFileResponseHandler,
+    ForwardToHostHandler,
+    TransformingHandler,
+    TimeoutHandler,
+    CloseConnectionHandler
+];
+
+export const isPaidHandler = (handler: Handler) => {
+    return _.some(PaidHandlerClasses, (cls) => handler instanceof cls);
+}
+
+export const isPaidHandlerClass = (handlerClass: HandlerClass) => {
+    return PaidHandlerClasses.includes(handlerClass);
+}
+
+/// --- Rules ---
+
 export type HtkMockRule =
     | WebSocketMockRule
     | HttpMockRule;