@n1k1t/mock-server 0.1.59 → 0.1.61

package/src/server/transports/internal/http.transport/context.ts

@@ -0,0 +1,50 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import _ from 'lodash';
+
+import type { IServerContext } from '../../../types';
+import type { MockServer } from '../../../index';
+
+import { extractHttpIncommingContext, History, IRequestContextIncoming, RequestContext } from '../../../models';
+import { InternalHttpReply } from './reply';
+import { Logger } from '../../../../logger';
+
+const logger = Logger.build('Server.Transports.Internal.Http.Context');
+
+export class InternalHttpRequestContext<TOutgoing = unknown> extends RequestContext<IServerContext<{
+  transport: 'http';
+  event: 'connection';
+}>> {
+  public snapshot = this.compileSnapshot();
+  public reply = InternalHttpReply.build<TOutgoing>(this);
+
+  constructor(
+    public server: MockServer,
+    public incoming: IRequestContextIncoming,
+    public request: IncomingMessage,
+    public response: ServerResponse
+  ) {
+    super(server.providers.default, { transport: 'http', event: 'connection' });
+    logger.info('Incoming request', `[${incoming.method} ${incoming.path}]`);
+  }
+
+  public complete() {
+    logger.info(
+      `Incoming request [${this.incoming.method} ${this.incoming.path}] has finished`,
+      `with status [${this.outgoing?.status ?? 200}] in [${Date.now() - this.timestamp}ms]`
+    );
+
+    return super.complete();
+  }
+
+  public compileHistory(): History {
+    return History.build({
+      group: this.provider.group,
+      snapshot: this.compileSnapshot().assign({ messages: [] }),
+    });
+  }
+
+  static async build(server: MockServer, request: IncomingMessage, response: ServerResponse) {
+    const incoming = await extractHttpIncommingContext(request);
+    return new InternalHttpRequestContext(server, incoming, request, response);
+  }
+}

package/src/server/transports/internal/http.transport/executor.ts

@@ -0,0 +1,56 @@
+import _ from 'lodash';
+
+import { Endpoint, Executor, IRequestContextOutgoing } from '../../../models';
+import { InternalHttpRequestContext } from './context';
+import { SetRequiredKeys } from '../../../../../types';
+
+import * as endpoints from '../../../endpoints';
+import config from '../../../../config';
+
+export class InternalHttpExecutor extends Executor<InternalHttpRequestContext> {
+  public router = Object.values(endpoints).reduce<Record<string, SetRequiredKeys<Endpoint['TCompiled'], 'http'>>>(
+    (acc, endpoint) => endpoint.http ? _.set(acc, `${endpoint.http.method}:${endpoint.http.path}`, endpoint) : acc,
+    {}
+  );
+
+  public async exec(context: InternalHttpRequestContext) {
+    const routes = config.get('routes');
+
+    const path = `${context.incoming.method}:${context.incoming.path.replace(routes.internal.root, '')}`;
+    const endpoint = this.router[path] ?? (path.includes(routes.internal.gui) ? endpoints.gui : null);
+
+    await endpoint?.handler?.(context);
+
+    if (context.hasStatuses(['completed'])) {
+      return context;
+    }
+
+    const outgoing = await this.reply(context, context.outgoing);
+    return context.assign({ outgoing }).complete();
+  }
+
+  public async match(context: InternalHttpRequestContext<unknown>) {
+    await this.exec(context);
+    return null;
+  }
+
+  public async forward() {
+    return null;
+  }
+
+  public async reply(context: InternalHttpRequestContext, outgoing?: IRequestContextOutgoing) {
+     const result = outgoing ?? {
+      type: 'plain',
+      status: 404,
+
+      headers: {},
+      data: 'Internal route was not found',
+    };
+
+    context.response.writeHead(result.status, result.headers);
+    context.response.write(result.dataRaw ?? '');
+    context.response.end();
+
+    return result;
+  }
+}

package/src/server/transports/internal/http.transport/index.ts

@@ -0,0 +1,23 @@
+import { IncomingMessage, ServerResponse } from 'http';
+
+import type { MockServer } from '../../../index';
+
+import { InternalHttpRequestContext } from './context';
+import { InternalHttpExecutor } from './executor';
+import { Provider, Transport } from '../../../models';
+
+export * from './executor';
+export * from './context';
+export * from './reply';
+
+export class InternalHttpTransport extends Transport<InternalHttpExecutor> {
+  public executor = new InternalHttpExecutor();
+
+  constructor(private server: MockServer) {
+    super();
+  }
+
+  public compileContext(provider: Provider, request: IncomingMessage, response: ServerResponse) {
+    return InternalHttpRequestContext.build(this.server, request, response);
+  }
+}

package/src/server/transports/internal/http.transport/reply.ts

@@ -0,0 +1,82 @@
+import type { InternalHttpRequestContext } from './context';
+
+import { IRequestContextOutgoing, Reply } from '../../../models';
+import { buildEndpointResponse } from '../utils';
+
+const headers = {
+  'Content-type': 'application/json',
+};
+
+export class InternalHttpReply<TOutgoing = unknown> extends Reply<InternalHttpRequestContext, TOutgoing> {
+  public ok(payload: TOutgoing) {
+    const outgoing: IRequestContextOutgoing = {
+      headers,
+
+      type: 'plain',
+      status: 200,
+
+      dataRaw: Buffer.from(JSON.stringify(buildEndpointResponse('OK', payload))),
+    };
+
+    this.context.response.writeHead(outgoing.status, outgoing.headers);
+    this.context.response.write(outgoing.dataRaw);
+    this.context.response.end();
+
+    this.context.assign({ outgoing }).complete();
+  }
+
+  public internalError(message: string = 'Something went wrong') {
+    const outgoing: IRequestContextOutgoing = {
+      headers,
+
+      type: 'plain',
+      status: 500,
+
+      dataRaw: Buffer.from(JSON.stringify(buildEndpointResponse('INTERNAL_ERROR', { message }))),
+    };
+
+    this.context.response.writeHead(outgoing.status, outgoing.headers)
+    this.context.response.write(outgoing.dataRaw);
+    this.context.response.end();
+
+    this.context.assign({ outgoing }).complete();
+  }
+
+  public validationError(reasons: unknown[] = ['Payload is not valid']) {
+    const outgoing: IRequestContextOutgoing = {
+      headers,
+
+      type: 'plain',
+      status: 400,
+
+      dataRaw: Buffer.from(JSON.stringify(buildEndpointResponse('VALIDATION_ERROR', { reasons }))),
+    };
+
+    this.context.response.writeHead(outgoing.status, outgoing.headers)
+    this.context.response.write(outgoing.dataRaw);
+    this.context.response.end();
+
+    this.context.assign({ outgoing }).complete();
+  }
+
+  public notFound() {
+    const outgoing: IRequestContextOutgoing = {
+      headers,
+
+      type: 'plain',
+      status: 404,
+
+      dataRaw: Buffer.from(JSON.stringify(buildEndpointResponse('NOT_FOUND', null))),
+    };
+
+    this.context.response.writeHead(outgoing.status, outgoing.headers)
+    this.context.response.write(outgoing.dataRaw);
+    this.context.response.end();
+
+    this.context.assign({ outgoing }).complete();
+  }
+
+  static build<TResponse>(context: InternalHttpRequestContext) {
+    return new InternalHttpReply<TResponse>(context);
+  }
+}

package/src/server/transports/internal/index.ts

@@ -0,0 +1,2 @@
+export * from './http.transport';
+export * from './io.transport';

package/src/server/transports/internal/io.transport/context.ts

@@ -0,0 +1,40 @@
+import type { IServerContext } from '../../../types';
+import type { MockServer } from '../../../index';
+import type { TFunction } from '../../../../../types';
+
+import { IRequestContextIncoming, RequestContext } from '../../../models';
+import { InternalSocketIoReply } from './reply';
+
+export class InternalSocketIoRequestContext<TOutgoing = unknown> extends RequestContext<IServerContext<{
+  transport: 'io';
+  event: 'message';
+}>> {
+  public incoming: IRequestContextIncoming = {
+    type: 'json',
+    data: this.request.data,
+
+    path: this.request.path,
+    method: 'NONE',
+
+    headers: {},
+    query: {},
+  };
+
+  public reply = InternalSocketIoReply.build<TOutgoing>(this);
+  public snapshot = this.compileSnapshot();
+
+  constructor(
+    public server: MockServer,
+    public request: {
+      path: string;
+      data: unknown;
+      callback: TFunction<void>;
+    }
+  ) {
+    super(server.providers.default, { transport: 'io', event: 'message' });
+  }
+
+  static build(server: MockServer, request: InternalSocketIoRequestContext['request']) {
+    return new InternalSocketIoRequestContext(server, request);
+  }
+}

package/src/server/transports/internal/io.transport/executor.ts

@@ -0,0 +1,27 @@
+import _ from 'lodash';
+
+import { Endpoint, Executor, IRequestContextOutgoing } from '../../../models';
+import { InternalSocketIoRequestContext } from './context';
+import { SetRequiredKeys } from '../../../../../types';
+
+import * as endpoints from '../../../endpoints';
+
+export class InternalSocketIoExecutor extends Executor<InternalSocketIoRequestContext> {
+  public endpoints = Object.values(endpoints).reduce<Record<string, SetRequiredKeys<Endpoint, 'io'>>>(
+    (acc, endpoint) => endpoint.io ? _.set(acc, endpoint.io.path, endpoint) : acc,
+    {}
+  );
+
+  public async exec(context: InternalSocketIoRequestContext) {
+    await this.endpoints[context.incoming.path]?.handler?.(context);
+    return context.complete();
+  }
+
+  public async forward() {
+    return null;
+  }
+
+  public async reply(): Promise<IRequestContextOutgoing> {
+    return { type: 'plain', status: 200, headers: {} };
+  }
+}

package/src/server/transports/internal/io.transport/index.ts

@@ -0,0 +1,36 @@
+import type { IServerContext, MockServer } from '../../../index';
+
+import { buildSocketIoExchange, Provider, Transport } from '../../../models';
+import { InternalSocketIoRequestContext } from './context';
+import { InternalSocketIoExecutor } from './executor';
+
+export * from './executor';
+export * from './context';
+export * from './reply';
+
+export class InternalSocketIoTransport extends Transport<InternalSocketIoExecutor> {
+  public executor = new InternalSocketIoExecutor();
+
+  constructor(private server: MockServer) {
+    super();
+
+    server.io.on('connection', (socket) =>
+      Object.values(this.executor.endpoints).forEach((endpoint) =>
+        socket.on(endpoint.io.path, async (...args) =>
+          endpoint.handler?.(
+            await this.compileContext(server.providers.default, {
+              path: endpoint.io.path,
+              callback: args.pop(),
+              data: args[0],
+            })
+        ))
+      )
+    );
+
+    server.exchanges.io = buildSocketIoExchange(server.io);
+  }
+
+  public async compileContext(provider: Provider<IServerContext<any>>, request: InternalSocketIoRequestContext['request']) {
+    return InternalSocketIoRequestContext.build(this.server, request);
+  }
+}

package/src/server/transports/internal/io.transport/reply.ts

@@ -0,0 +1,26 @@
+import type { InternalSocketIoRequestContext } from './context';
+
+import { buildEndpointResponse } from '../utils';
+import { Reply } from '../../../models';
+
+export class InternalSocketIoReply<TOutgoing = unknown> extends Reply<InternalSocketIoRequestContext, TOutgoing> {
+  public ok(payload: TOutgoing) {
+    this.context.request.callback(buildEndpointResponse('OK', payload))
+  }
+
+  public internalError(message: string = 'Something went wrong') {
+    this.context.request.callback(buildEndpointResponse('INTERNAL_ERROR', { message }));
+  }
+
+  public validationError(reasons: unknown[] = ['Payload is not valid']) {
+    this.context.request.callback(buildEndpointResponse('VALIDATION_ERROR', { reasons }));
+  }
+
+  public notFound() {
+    this.context.request.callback(buildEndpointResponse('NOT_FOUND', null));
+  }
+
+  static build<TResponse>(context: InternalSocketIoRequestContext) {
+    return new InternalSocketIoReply<TResponse>(context);
+  }
+}

package/src/server/transports/internal/utils.ts

@@ -0,0 +1,6 @@
+import type { IEndpointResponse } from '../../models';
+
+export const buildEndpointResponse = <T>(
+  code: IEndpointResponse<T>['code'],
+  data: IEndpointResponse<T>['data']
+): IEndpointResponse<T> => ({ timestamp: Date.now(), code, data });

package/src/server/transports/ws.transport/context.ts

@@ -0,0 +1,90 @@
+import { RawData, WebSocket } from 'ws';
+import { IncomingMessage } from 'http';
+
+import { extractHttpIncommingContext, IRequestContextIncoming, parsePayload, Provider, RequestContext } from '../../models';
+import { IServerContext } from '../../types';
+import { parseJsonSafe } from '../../../utils';
+import { metaStorage } from '../../../meta';
+import { Logger } from '../../../logger';
+
+const logger = Logger.build('Server.Transports.Ws.Context');
+
+export class WsRequestContext extends RequestContext<IServerContext<{
+  transport: 'ws';
+  event: 'connection' | 'message';
+  flag: 'wsCloseConnection';
+}>> {
+  public snapshot = this.compileSnapshot();
+  public history = this.compileHistory();
+
+  constructor(
+    public provider: Provider,
+    public socket: WebSocket,
+    public event: WsRequestContext['TContext']['event'],
+    public incoming: IRequestContextIncoming
+  ) {
+    super(provider, { event, transport: 'ws' });
+  }
+
+  public compileSnapshot() {
+    const snapshot = super.compileSnapshot();
+
+    snapshot.outgoing.status = this.event === 'message' ? 0 : 1000;
+    snapshot.incoming.method = this.event === 'message' ? 'MSG' : 'CON';
+
+    return snapshot;
+  }
+
+  public handle(): this {
+    this.event === 'message'
+      ? logger.info(`Incoming WS ${event} [${this.incoming.path}] got message`, this.incoming.data)
+      : logger.info(`Incoming WS ${event} [${this.incoming.path}]`);
+
+    if (this.event === 'connection') {
+      this.streams.incoming.subscribe({
+        error: () => null,
+        next: (data) => logger.info(`Incoming WS ${this.event} [${this.incoming.path}] got message`, data),
+      });
+    }
+
+    this.streams.outgoing.subscribe({
+      error: () => null,
+      next: (data) => logger.info(`Incoming WS ${this.event} [${this.incoming.path}] has sent`, data),
+    });
+
+    return super.handle();
+  }
+
+  public skip(): this {
+    this.streams.incoming.complete();
+    this.streams.outgoing.complete();
+
+    return super.skip();
+  }
+
+  public complete() {
+    logger.info(`Incoming WS ${this.event} [${this.incoming.path}] has finished in [${Date.now() - this.timestamp}ms]`);
+    return super.complete();
+  }
+
+  static async build(
+    provider: Provider,
+    socket: WebSocket,
+    request: IncomingMessage,
+    event: WsRequestContext['TContext']['event'],
+    message?: RawData
+  ) {
+    const incoming = await extractHttpIncommingContext(request);
+
+    incoming.dataRaw = message ? Buffer.from(message.toString()) : undefined;
+    incoming.data = incoming.dataRaw
+      ? incoming.type === 'plain'
+        ? parseJsonSafe(incoming.dataRaw.toString()).result
+        : parsePayload(incoming.type, incoming.dataRaw)
+      : undefined;
+
+    incoming.type = incoming.type === 'plain' && incoming.data !== undefined ? 'json' : incoming.type;
+
+    return new WsRequestContext(provider, socket, event, incoming);
+  }
+}

package/src/server/transports/ws.transport/executor.ts

@@ -0,0 +1,64 @@
+import { Executor, ExecutorManualError, IExecutorExecOptions, IRequestContextOutgoing } from '../../models';
+import { WsRequestContext } from './context';
+import { parseJsonSafe } from '../../../utils';
+import { Logger } from '../../../logger';
+
+const logger = Logger.build('Server.Transports.Ws.Executor');
+
+export class WsExecutor extends Executor<WsRequestContext> {
+  public async exec(context: WsRequestContext, options?: IExecutorExecOptions) {
+    context.socket.once('close', () => context.complete());
+
+    if (context.event === 'connection') {
+      context.socket.on('message', (data) => {
+        const serialized = data.toString();
+        context.streams.incoming.next(parseJsonSafe(serialized).result ?? serialized);
+      });
+    }
+
+    await super.exec(context, options).catch((error) => {
+      if (error instanceof ExecutorManualError && error.is('ECONNABORTED')) {
+        return context.socket.close();
+      }
+
+      logger.error('Got unexpected error while execution', error?.stack ?? error);
+    });
+
+    return context.event === 'connection' ? context : context.complete();
+  }
+
+  public async match(context: WsRequestContext) {
+    const expectation = context.provider.storages.expectations.match(context.snapshot);
+
+    if (!expectation) {
+      context.event === 'connection' ? context.skip() : logger.warn('Expectation was not found');
+      return null;
+    }
+
+    return expectation;
+  }
+
+  public async prepare(context: WsRequestContext) {
+    if (context.snapshot.flags.wsCloseConnection) {
+      context.socket.close(context.snapshot.outgoing.status || 1000);
+      return context.complete();
+    }
+  }
+
+  public async forward() {
+    return null;
+  }
+
+  public async reply(context: WsRequestContext, outgoing: IRequestContextOutgoing) {
+    await outgoing.stream?.forEach((message) => {
+      context.streams.outgoing.next(message);
+      context.socket.send(typeof message === 'object' ? JSON.stringify(message) : String(message));
+    });
+
+    if (context.event === 'connection' || context.snapshot.flags.wsCloseConnection) {
+      context.socket.close(outgoing.status || 1000);
+    }
+
+    return outgoing;
+  }
+}

package/src/server/transports/ws.transport/index.ts

@@ -0,0 +1,105 @@
+
+import { WebSocket, RawData } from 'ws';
+import { IncomingMessage } from 'http';
+
+import { IRouteMatchResult, Provider, Router, Transport } from '../../models';
+import { WsRequestContext } from './context';
+import { metaStorage } from '../../../meta';
+import { WsExecutor } from './executor';
+import { Logger } from '../../../logger';
+
+const logger = Logger.build('Server.Transports.Ws');
+
+const signals = {
+  close: Symbol('close'),
+  break: Symbol('break'),
+};
+
+const handle = async (
+  event: WsTransport['TContext']['event'],
+  socket: WebSocket,
+  request: IncomingMessage,
+  match: IRouteMatchResult<'ws', WsTransport>,
+  data?: RawData
+): Promise<void | null | symbol> => {
+  const context = await match.transport
+    .compileContext(match.provider, socket, request, event, data)
+    .catch((error) => logger.error(`Got error while [ws:${event}] context compilation`, error?.stack ?? error));
+
+  if (!context) {
+    return signals.close;
+  }
+  if (!context.hasStatuses(['registered', 'handling'])) {
+    return signals.break;
+  }
+
+  const expectation = await metaStorage
+    .wrap(context.meta, () => match.transport.executor.match(context))
+    .catch((error) => logger.error(`Got error while [ws:${event}] expectation matching`, error?.stack ?? error));
+
+  if (!context.hasStatuses(['registered', 'handling'])) {
+    return signals.break;
+  }
+  if (!expectation) {
+    return null;
+  }
+
+  await metaStorage
+    .wrap(context.meta, () => match.transport.executor.exec(context.handle(), { expectation }))
+    .catch((error) => logger.error(`Got error while [ws:${event}] execution`, error?.stack ?? error));
+
+  return signals.close;
+}
+
+export const buildWsListener = (router: Router<WsRequestContext['TContext']>) =>
+  async (socket: WebSocket, request: IncomingMessage) => {
+    if (request.url?.startsWith('/socket.io')) {
+      return socket.terminate();
+    }
+
+    const matches: IRouteMatchResult<'ws', WsTransport>[] = [];
+
+    for (const match of router.match<WsTransport>('ws', request.url ?? '')) {
+      matches.push(match);
+
+      const signal = await handle('connection', socket, request, match);
+
+      if (signal === signals.close) {
+        return socket.close();
+      }
+      if (signal === signals.break) {
+        break;
+      }
+    }
+
+    if (!matches.length || socket.readyState !== socket.OPEN) {
+      return socket.close();
+    }
+
+    socket.on('message', async (data) => {
+      for (const match of matches) {
+        const signal = await handle('message', socket, request, match, data);
+
+        if (signal === signals.close) {
+          return socket.close();
+        }
+        if (signal === signals.break) {
+          break;
+        }
+      }
+    });
+  }
+
+export class WsTransport extends Transport<WsExecutor> {
+  public executor = new WsExecutor();
+
+  public compileContext(
+    provider: Provider,
+    socket: WebSocket,
+    request: IncomingMessage,
+    event: WsExecutor['TContext']['event'],
+    message?: RawData
+  ) {
+    return WsRequestContext.build(provider, socket, request, event, message);
+  }
+}

package/src/server/types/index.ts

@@ -0,0 +1,32 @@
+import type { HttpTransport, WsTransport } from '../transports';
+import type { TMetricPoint } from '../services';
+import type { Expectation } from '../../expectations';
+import type { History } from '../models';
+
+export type TRequestPayloadType = 'json' | 'plain' | 'xml';
+export type TDefaultServerContext = HttpTransport['TContext'] | WsTransport['TContext'];
+
+export interface IServerContextInput {
+  transport?: string;
+  event?: string;
+  flag?: string;
+}
+
+export interface IServerContext<TInput extends IServerContextInput = {}> {
+  transport: Extract<TInput['transport'], string>;
+  event: Extract<TInput['event'], string>;
+  flag: Extract<TInput['flag'], string>;
+}
+
+export interface IIoExchangeSchema {
+  'expectation:added': Expectation<any>['TPlain'];
+  'expectation:updated': Expectation<any>['TPlain'];
+
+  'history:added': History['TPlain'];
+  'history:updated': History['TPlain'];
+
+  'metric:registered': {
+    name: string;
+    point: TMetricPoint;
+  };
+}

package/src/server/utils/index.ts

@@ -0,0 +1,35 @@
+import { TObject, TSchema, Type } from '@n1k1t/typebox';
+import { Value, ValueError } from '@n1k1t/typebox/value';
+
+import type { Constructable } from '../../../types';
+
+interface IValidationMetaContext {
+  schema: TObject;
+  properties: Set<string | Symbol>;
+}
+
+const validationContextMetaKey = Symbol('validation:context');
+
+const buildValidationMetaContext = (): IValidationMetaContext => ({
+  schema: Type.Object({}),
+  properties: new Set(),
+});
+
+export const extractValidationMetaContext =
+  (Definition: Constructable<object> | Function): IValidationMetaContext | null =>
+    Reflect.get(Definition, validationContextMetaKey) ?? null;
+
+export const validate = (instance: object, references: TSchema[] = []): ValueError[] => {
+  const context = extractValidationMetaContext(instance.constructor);
+  return context ? [...Value.Errors(context.schema, references, instance)] : [];
+}
+
+export const UseValidation = (schema: TSchema): PropertyDecorator => (target, key) => {
+  const context = extractValidationMetaContext(target.constructor)
+    ?? buildValidationMetaContext();
+
+  context.properties.add(key);
+  context.schema = Type.Composite([context.schema, Type.Object({ [key]: schema })]);
+
+  Reflect.set(target.constructor, validationContextMetaKey, context);
+}