@n1k1t/mock-server 0.1.61 → 0.1.62

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

@@ -1,50 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

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

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

@@ -1,40 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,105 +0,0 @@
-
-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

@@ -1,32 +0,0 @@
-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;
-  };
-}