Enhanced API surface

Author: Florian Rappl

src/server/core/recorder.ts

@@ -4,6 +4,7 @@ import { KrasRecorder, KrasRequest, KrasAnswer, RecordedRequest, RecordedError,
 
 export class Recorder extends EventEmitter implements KrasRecorder {
   private readonly maximum: number;
+  private enabled = true;
   readonly requests: Array<RecordedRequest> = [];
   readonly errors: Array<RecordedError> = [];
   readonly messages: Array<RecordedMessage> = [];
@@ -13,47 +14,57 @@ export class Recorder extends EventEmitter implements KrasRecorder {
     this.maximum = maximum;
   }
 
+  disable() {
+    this.enabled = false;
+  }
+
   hit(start: Date, end: Date, request: KrasRequest, response: KrasAnswer) {
-    const requests = this.requests;
-    const id = uuid();
-    const item = {
-      id,
-      start,
-      end,
-      request,
-      response,
-    };
-
-    if (requests.length === this.maximum) {
-      requests.shift();
-    }
+    if (this.enabled) {
+      const requests = this.requests;
+      const id = uuid();
+      const item = {
+        id,
+        start,
+        end,
+        request,
+        response,
+      };
 
-    this.requests.push(item);
-    this.emit('recorded-request', item);
+      if (requests.length === this.maximum) {
+        requests.shift();
+      }
+
+      this.requests.push(item);
+      this.emit('recorded-request', item);
+    }
   }
 
   message(time: Date, data: { content: string, from: string, to: string }) {
-    const id = uuid();
-    const item = {
-      id,
-      time,
-      ...data,
-    };
-
-    this.messages.push(item);
-    this.emit('recorded-message', item);
+    if (this.enabled) {
+      const id = uuid();
+      const item = {
+        id,
+        time,
+        ...data,
+      };
+
+      this.messages.push(item);
+      this.emit('recorded-message', item);
+    }
   }
 
   miss(start: Date, end: Date, request: KrasRequest) {
-    const id = uuid();
-    const item = {
-      id,
-      start,
-      end,
-      request,
-    };
-
-    this.errors.push(item);
-    this.emit('recorded-miss', item);
+    if (this.enabled) {
+      const id = uuid();
+      const item = {
+        id,
+        start,
+        end,
+        request,
+      };
+
+      this.errors.push(item);
+      this.emit('recorded-miss', item);
+    }
   }
 }

src/server/core/webserver.ts

@@ -75,12 +75,14 @@ export class WebServer extends EventEmitter implements BaseKrasServer {
         ws,
         target,
         url,
+        req,
       });
       ws.on('close', () => this.emit('user-disconnected', {
         id,
         ws,
         target,
         url,
+        req,
       }));
     }));
   }

src/server/helpers/middlewares.ts

@@ -6,22 +6,22 @@ interface RequestHandlerCreator {
   (...args: Array<any>): KrasServerHandler;
 }
 
-function findMiddleware(modulePath: string): RequestHandlerCreator {
-  try {
-    const middlewareCreator = require(modulePath);
-
-    if (typeof middlewareCreator === 'function') {
-      return middlewareCreator;
-    }
-  } catch (e) {}
+interface RequestHandlerInitializer {
+  setup?(server: KrasServer, config: KrasConfiguration): void;
+}
 
-  return undefined;
+function findMiddleware(modulePath: string): RequestHandlerCreator | RequestHandlerInitializer {
+  try {
+    return require(modulePath);
+  } catch (e) {
+    return undefined;
+  }
 }
 
-function createMiddleware(source: string, options: Array<any>) {
+function createMiddleware(server: KrasServer, config: KrasConfiguration, source: string, options: Array<any>) {
   const creator = findMiddleware(source);
 
-  if (creator) {
+  if (typeof creator === 'function') {
     const handler = creator(...options);
 
     if (typeof handler === 'function') {
@@ -32,6 +32,8 @@ function createMiddleware(source: string, options: Array<any>) {
         handler,
       };
     }
+  } else if (creator && typeof creator.setup === 'function') {
+    creator.setup(server, config);
   }
 
   return undefined;
@@ -53,7 +55,7 @@ export function withMiddlewares(server: KrasServer, config: KrasConfiguration) {
   for (const definition of middlewareDefinitions) {
     const source = definition.source;
     const options = definition.options || [];
-    const middleware = createMiddleware(source, options);
+    const middleware = createMiddleware(server, config, source, options);
 
     if (middleware) {
       server.middlewares.push(middleware);

src/server/injectors/proxy-injector.ts

@@ -17,6 +17,21 @@ interface WebSocketSessions {
   [id: string]: WebSocket;
 }
 
+interface BufferEntry {
+  time: number;
+  data: WebSocket.Data;
+}
+
+function releaseFrom(buffer: Array<BufferEntry>, ws: WebSocket) {
+    const item = buffer.shift();
+    ws.send(item.data);
+
+    if (buffer.length) {
+      const diff = buffer[0].time - item.time;
+      setTimeout(() => releaseFrom(buffer, ws), diff);
+    }
+}
+
 export default class ProxyInjector implements KrasInjector {
   private readonly sessions: WebSocketSessions = {};
   private readonly options: KrasInjectorConfig & ProxyInjectorConfig;
@@ -32,16 +47,37 @@ export default class ProxyInjector implements KrasInjector {
 
     core.on('user-connected', e => {
       const url = this.map[e.target] + e.url;
+      let open = false;
+      const buffer: Array<BufferEntry> = [];
       const ws = new WebSocket(url, {
         rejectUnauthorized: false,
+        protocol: e.ws.protocol,
+      });
+      ws.on('open', () => {
+        open = true;
+
+        if (buffer.length) {
+          releaseFrom(buffer, ws);
+        }
+      });
+      ws.on('close', e => {
+        core.emit('ws-closed', { reason: e });
       });
       ws.on('message', data => {
         core.emit('message', { content: data, from: url, to: e.id });
         e.ws.send(data, (err: Error) => core.emit('error', err));
       });
       e.ws.on('message', (data: WebSocket.Data) => {
         core.emit('message', { content: data, to: url, from: e.id });
-        ws.send(data, (err: Error) => core.emit('error', err));
+
+        if (open) {
+          ws.send(data, (err: Error) => core.emit('error', err));
+        } else {
+          buffer.push({
+            time: Date.now(),
+            data,
+          })
+        }
       });
       ws.on('error', err => core.emit('error', err.error));
       this.sessions[e.id] = ws;

src/server/injectors/script-injector.ts

@@ -2,7 +2,7 @@ import { asScript, watch, Watcher } from '../helpers/io';
 import { basename } from 'path';
 import { editFileOption, editDirectoryOption } from '../helpers/build-options';
 import { fromJson } from '../helpers/build-response';
-import { KrasRequest, KrasConfiguration, Headers, StoredFileEntry, KrasInjectorConfig, KrasInjector, KrasAnswer, KrasInjectorOptions } from '../types';
+import { KrasRequest, KrasConfiguration, StoredFileEntry, KrasInjectorConfig, KrasInjector, KrasAnswer, KrasInjectorOptions, ScriptResponseBuilder } from '../types';
 import { EventEmitter } from 'events';
 
 function errorHandler(): undefined {
@@ -27,17 +27,6 @@ export interface DynamicScriptInjectorConfig {
   }>;
 }
 
-export interface ScriptResponseBuilderData {
-  statusCode: number;
-  statusText: string;
-  headers: Headers;
-  content: string;
-}
-
-export interface ScriptResponseBuilder {
-  (data: ScriptResponseBuilderData): KrasAnswer;
-}
-
 export interface ScriptFileEntry {
   active: boolean;
   file?: string;

src/server/kras.ts

@@ -7,12 +7,49 @@ import { withFiles } from './helpers/files';
 import { withMiddlewares } from './helpers/middlewares';
 import { runWith, configureHandler } from './helpers/fluent';
 import { currentDir } from './core/info';
-import { KrasConfiguration, KrasServer, LogEntry, LogEntryType, LogLevel, KrasInjector, KrasServerMethods, KrasServerHandler, KrasHandlerConfiguration, KrasRunner, KrasMiddleware } from './types';
-import { buildConfiguration, mergeConfiguration, readConfiguration, ConfigurationOptions } from './core/config';
-export { KrasRequestHandler, KrasInjectorOptions, KrasInjectorOption, KrasInjectorConfig, KrasRequest, KrasResponse, KrasAnswer } from './types';
-export { KrasInjector, KrasConfiguration, KrasServerMethods, KrasServerHandler, KrasHandlerConfiguration, KrasRunner };
+import {
+  KrasConfiguration,
+  KrasServer,
+  LogEntry,
+  LogEntryType,
+  LogLevel,
+  KrasInjector,
+  KrasServerMethods,
+  KrasServerHandler,
+  KrasHandlerConfiguration,
+  KrasRunner,
+  KrasMiddleware
+} from './types';
+import {
+  buildConfiguration,
+  mergeConfiguration,
+  readConfiguration,
+  ConfigurationOptions
+} from './core/config';
+export {
+  KrasRequestHandler,
+  KrasInjectorOptions,
+  KrasInjectorOption,
+  KrasInjectorConfig,
+  KrasRequest,
+  KrasResponse,
+  KrasAnswer,
+  Dict,
+  Headers,
+  ScriptResponseBuilder,
+  ScriptResponseBuilderData
+} from './types';
+export {
+  KrasInjector,
+  KrasConfiguration,
+  KrasServerMethods,
+  KrasServerHandler,
+  KrasHandlerConfiguration,
+  KrasRunner
+};
 
-export type KrasRuntimeConfiguration = Partial<KrasConfiguration> & KrasHandlerConfiguration;
+export type KrasRuntimeConfiguration = Partial<KrasConfiguration> &
+  KrasHandlerConfiguration;
 
 export const krasrc = '.krasrc';
 
@@ -32,7 +69,11 @@ export class MockServer extends MockServerCore implements KrasServer {
     super(config);
 
     this.logLevel = config.logLevel || 'error';
-    this.on('error', (e) => this.log('error', e));
+    this.on('error', e => this.log('error', e));
+
+    if (config.api === false) {
+      this.recorder.disable();
+    }
 
     withManagement(this, config);
     withInjectors(this, config);
@@ -41,15 +82,14 @@ export class MockServer extends MockServerCore implements KrasServer {
   }
 
   stop() {
-    return super.stop()
-      .then(() => this.injectors.forEach(disposeInjector));
+    return super.stop().then(() => this.injectors.forEach(disposeInjector));
   }
 
   private log(type: LogEntryType, data: any) {
     const item: LogEntry = {
       type,
       data,
-      time: new Date(),
+      time: new Date()
     };
     this.logs.push(item);
     this.emit('logged', item);
@@ -62,7 +102,7 @@ export function readKrasConfig(options?: ConfigurationOptions, file?: string) {
     options,
     readConfiguration(homedir(), krasrc),
     readConfiguration(dir, krasrc),
-    readConfiguration(dir, file),
+    readConfiguration(dir, file)
   );
 }
 

src/server/types/index.ts

@@ -9,3 +9,4 @@ export { BaseKrasServer, KrasServer, KrasServerMethods } from './kras-server';
 export { KrasServerHandler, KrasServerHook, KrasWebSocket, KrasServerConnector } from './kras-express';
 export { KrasHandlerConfiguration, KrasConfigurator, KrasRunner } from './kras-handler';
 export { UserCredentials } from './kras-auth';
+export { ScriptResponseBuilder, ScriptResponseBuilderData } from './kras-script-injector';

src/server/types/kras-script-injector.ts

@@ -0,0 +1,13 @@
+import { KrasAnswer } from './kras-injector';
+import { Headers } from './kras-basics';
+
+export interface ScriptResponseBuilderData {
+  statusCode: number;
+  statusText: string;
+  headers: Headers;
+  content: string;
+}
+
+export interface ScriptResponseBuilder {
+  (data: ScriptResponseBuilderData): KrasAnswer;
+}