@n1k1t/mock-server 0.1.59 → 0.1.61

package/src/server/endpoints/gui.endpoint.ts

@@ -0,0 +1,76 @@
+import { createReadStream } from 'fs';
+
+import mime from 'mime-types';
+import path from 'path';
+import fs from 'fs/promises';
+import _ from 'lodash';
+
+import { Endpoint, IRequestContextOutgoing } from '../models';
+import config from '../../config';
+
+export default Endpoint
+  .build<{ outgoing: string }>()
+  .bindToHttp(<const>{ method: 'GET', path: '/gui' })
+  .assignHandler(async (context) => {
+    if (context.transport !== 'http') {
+      return context.reply.notFound();
+    }
+
+    const routes = config.get('routes');
+    const statics = config.get('statics');
+
+    if (!context.incoming.path.includes(routes.internal.gui)) {
+      return context.assign({ outgoing: { type: 'plain', status: 404, headers: {} } });
+    }
+
+    const root = routes.internal.root + routes.internal.gui;
+    const parsed = path.parse(context.incoming.path.replace(root, ''));
+
+    if (!parsed.dir) {
+      return context.assign({
+        outgoing: {
+          type: 'plain',
+          status: 301,
+
+          headers: {
+            Location: `..${root}/`,
+          },
+        },
+      });
+    }
+
+    if (parsed.dir === '/' && !parsed.ext) {
+      const outgoing: IRequestContextOutgoing = {
+        type: 'plain',
+        status: 200,
+
+        headers: {
+          'Content-Type': 'text/html;charset=utf-8',
+        },
+      };
+
+      context.response.writeHead(outgoing.status, outgoing.headers);
+      createReadStream(path.join(statics.public.dir, '/index.html')).pipe(context.response);
+
+      return context.assign({ outgoing }).complete();
+    }
+
+    const stats = await fs.stat(path.join(statics.public.dir, parsed.dir, parsed.base)).catch(() => null);
+    if (!stats) {
+      return context.assign({ outgoing: { type: 'plain', status: 404, headers: {} } });
+    }
+
+    const outgoing: IRequestContextOutgoing = {
+      type: 'plain',
+      status: 200,
+
+      headers: {
+        'Content-Type': mime.contentType(parsed.ext) || '',
+      },
+    };
+
+    context.response.writeHead(outgoing.status, outgoing.headers);
+    createReadStream(path.join(statics.public.dir, parsed.dir, parsed.base)).pipe(context.response);
+
+    return context.assign({ outgoing }).complete();
+  });

package/src/server/endpoints/history.delete.endpoint.ts

@@ -0,0 +1,10 @@
+import { Endpoint } from '../models';
+
+export default Endpoint
+  .build<{ outgoing: null }>()
+  .bindToHttp(<const>{ method: 'DELETE', path: '/history' })
+  .bindToIo(<const>{ path: 'history:delete' })
+  .assignHandler(({ reply, server }) => {
+    server.providers.extract().forEach((provider) => provider.storages.history.clear());
+    reply.ok(null);
+  });

package/src/server/endpoints/history.get-list.endpoint.ts

@@ -0,0 +1,15 @@
+import { History, Endpoint } from '../models';
+
+export default Endpoint
+  .build<{ outgoing: History['TPlain'][] }>()
+  .bindToHttp(<const>{ method: 'GET', path: '/history' })
+  .bindToIo(<const>{ path: 'history:get-list' })
+  .assignHandler(({ reply, server }) =>
+    reply.ok(
+      server.providers
+        .extract()
+        .reduce<History[]>((acc, provider) => acc.concat([...provider.storages.history.values()]), [])
+        .sort((a, b) => b.timestamp - a.timestamp)
+        .map((history) => history.toPlain())
+    )
+  );

package/src/server/endpoints/index.ts

@@ -0,0 +1,18 @@
+export { default as expectationsGroupUpdate } from './expectations-group.update.endpoint';
+export { default as expectationsGetList } from './expectations.get-list.endpoint';
+export { default as expectationsCreate } from './expectations.create.endpoint';
+export { default as expectationsDelete } from './expectations.delete.endpoint';
+export { default as expectationsUpdate } from './expectations.update.endpoint';
+
+export { default as historyGetList } from './history.get-list.endpoint';
+export { default as historyDelete } from './history.delete.endpoint';
+
+export { default as cacheUsageGet } from './cache.usage.get.endpoint';
+export { default as cacheDelete } from './cache.delete.endpoint';
+
+export { default as configGet } from './config.get.endpoint';
+
+export { default as metrics } from './metrics.endpoint';
+export { default as stats } from './stats.endpoint';
+export { default as ping } from './ping.endpoint';
+export { default as gui } from './gui.endpoint';

package/src/server/endpoints/metrics.endpoint.ts

@@ -0,0 +1,12 @@
+import { MetricsService } from '../services';
+import { Endpoint } from '../models';
+
+export default Endpoint
+  .build<{
+    outgoing: MetricsService['points'];
+  }>()
+  .bindToHttp(<const>{ method: 'GET', path: '/metrics' })
+  .bindToIo(<const>{ path: 'metrics:get' })
+  .assignHandler(({ reply, server }) =>
+    reply.ok(server.services.metrics.points)
+  );

package/src/server/endpoints/ping.endpoint.ts

@@ -0,0 +1,7 @@
+import { Endpoint } from '../models';
+
+export default Endpoint
+  .build<{ outgoing: 'pong' }>()
+  .bindToHttp(<const>{ method: 'GET', path: '/ping' })
+  .bindToIo(<const>{ path: 'ping' })
+  .assignHandler(({ reply }) => reply.ok('pong'));

package/src/server/endpoints/stats.endpoint.ts

@@ -0,0 +1,20 @@
+import dayjs from 'dayjs';
+
+import { version } from '../../../package.json';
+import { Endpoint } from '../models';
+
+export default Endpoint
+  .build<{
+    outgoing: {
+      version: string;
+      uptime: string;
+    };
+  }>()
+  .bindToHttp(<const>{ method: 'GET', path: '/stats' })
+  .bindToIo(<const>{ path: 'stats' })
+  .assignHandler((context) =>
+    context.reply.ok({
+      version,
+      uptime: dayjs(context.server.timestamp).fromNow(true),
+    })
+  );

package/src/server/index.ts

@@ -0,0 +1,182 @@
+import relativeTimePlugin from 'dayjs/plugin/relativeTime';
+import dayjs from 'dayjs';
+import _ from 'lodash';
+
+import { Redis, RedisOptions } from 'ioredis';
+import { WebSocketServer } from 'ws';
+import { createServer } from 'http';
+import { Server } from 'socket.io';
+
+import { buildSocketIoExchange, ProvidersStorage, Router, Transport, TransportsStorage } from './models';
+import { IIoExchangeSchema, IServerContext, TDefaultServerContext } from './types';
+import { AnalyticsService, MetricsService } from './services';
+import { Logger } from '../logger';
+import {
+  buildHttpListener,
+  buildWsListener,
+  HttpTransport,
+  InternalHttpTransport,
+  InternalSocketIoTransport,
+  WsTransport,
+} from './transports';
+
+import config from '../config';
+
+export * from './transports';
+export * from './models';
+export * from './types';
+
+dayjs.extend(relativeTimePlugin);
+
+const logger = Logger.build('Server');
+
+export interface IMockServerConfiguration {
+  port: number;
+  host: string;
+
+  containers?: {
+    /** Seconds `default: 1h` */
+    expiredCleaningInterval?: number;
+  };
+
+  transports?: Partial<Record<TDefaultServerContext['transport'], Transport>> & Record<string, Transport>;
+  databases?: {
+    redis?: RedisOptions;
+  };
+}
+
+export class MockServer<
+  TConfiguration extends IMockServerConfiguration = IMockServerConfiguration,
+  TContext extends IServerContext<any> = IServerContext<{
+    transport: TDefaultServerContext['transport'] | Extract<keyof TConfiguration['transports'], string>;
+
+    event: TDefaultServerContext['event'] | {
+      [K in keyof TConfiguration['transports']]: NonNullable<TConfiguration['transports']>[K]['TContext']['event'];
+    }[keyof TConfiguration['transports']];
+
+    flag: TDefaultServerContext['flag'] | {
+      [K in keyof TConfiguration['transports']]: NonNullable<TConfiguration['transports']>[K]['TContext']['flag'];
+    }[keyof TConfiguration['transports']];
+  }>
+> {
+  public TContext!: TContext;
+
+  public timestamp = Date.now();
+  public authority = `http://${this.configuration.host}:${this.configuration.port}`;
+
+  public databases = {
+    redis: this.configuration.databases?.redis
+      ? new Redis({ keyPrefix: 'mock:', ...this.configuration.databases?.redis })
+      : null,
+  };
+
+  public exchanges = {
+    io: buildSocketIoExchange<IIoExchangeSchema>({ emit: () => false }),
+  };
+
+  public providers = new ProvidersStorage<TContext>(this);
+  public transports = new TransportsStorage<TContext>()
+    .register('http', new HttpTransport())
+    .register('ws', new WsTransport());
+
+  public router = Router.build<TContext>(this);
+
+  public http = createServer(buildHttpListener(this.router));
+  public ws = new WebSocketServer({ server: this.http }).on('connection', buildWsListener(this.router));
+
+  public io = new Server(this.http, {
+    ...(process.env['NODE_ENV'] === 'development' && {
+      cors: { origin: '*' },
+    }),
+  });
+
+  public services = {
+    analytics: AnalyticsService.build(this),
+    metrics: MetricsService.build(this),
+  };
+
+  private internal = {
+    transports: {
+      http: new InternalHttpTransport(this),
+      io: new InternalSocketIoTransport(this),
+    },
+  };
+
+  constructor(public configuration: TConfiguration) {
+    this.databases.redis?.on('reconnecting', () => logger.info('Redis is reconnecting'));
+    this.databases.redis?.on('connect', () => logger.info('Redis has connected'));
+    this.databases.redis?.on('close', () => logger.info('Redis has closed'));
+    this.databases.redis?.on('error', (error) => logger.info('Got redis error', error?.stack ?? error));
+  }
+
+  public get client() {
+    return this.providers.default.client;
+  }
+
+  public unbindExpiredContainers() {
+    this.providers.extract().forEach((provider) =>
+      provider.storages.containers.getExpired().forEach((container) => {
+        container.unbind();
+        logger.info(`Container [${container.key}] has unbinded by expiration of [${container.ttl}] seconds`);
+      })
+    )
+  }
+
+  static async start<
+    TConfiguration extends IMockServerConfiguration,
+    TContext extends MockServer<TConfiguration>['TContext'] = MockServer<TConfiguration>['TContext']
+  >(configuration: TConfiguration) {
+    const routes = config.get('routes');
+    const server = new MockServer<TConfiguration>(configuration);
+
+    await new Promise<void>((resolve) =>
+      server.http.listen(configuration.port, configuration.host, () => {
+        logger.info(`Server has started on [${server.authority}]`);
+        logger.info(`GUI is available on [${server.authority}${routes.internal.root}${routes.internal.gui}/]`);
+
+        resolve();
+      })
+    );
+
+    Object
+      .entries(configuration.transports ?? {})
+      .forEach(([type, transport]) => server.transports.register(<TContext['transport']>type, transport));
+
+    server.router.register(`${routes.internal.root}/**`, {
+      provider: server.providers.default,
+      transports: <Record<TContext['transport'], Transport>>{
+        http: server.internal.transports.http,
+      },
+    });
+
+    setInterval(
+      () => server.unbindExpiredContainers(),
+      (configuration.containers?.expiredCleaningInterval ?? 60 * 60) * 1000
+    );
+
+    setInterval(
+      () => server.services.metrics.register('memory', { mbs: process.memoryUsage().heapUsed / 1024 / 1024 }),
+      5 * 1000
+    );
+
+    setInterval(
+      () => server.services.metrics.register('containers', {
+        count: server.providers.extract().reduce((acc, provider) => acc + provider.storages.containers.size, 0),
+      }),
+      5 * 1000
+    );
+
+    if (server.databases.redis) {
+      setInterval(async () => {
+        const redis = await server.services.analytics.calculateRedisUsage();
+
+        server.services.metrics.register('cache', {
+          redis_mbs: redis.bytes / 1024 / 1024,
+          redis_count: redis.count,
+        });
+      }, 10 * 60 * 1000);
+    }
+
+    return server;
+  }
+}

package/src/server/models/containers/index.ts

@@ -0,0 +1,2 @@
+export * from './storage';
+export * from './model';

package/src/server/models/containers/model.spec.ts

@@ -0,0 +1,81 @@
+import { Container } from './model';
+
+// Test generated using Keploy
+test('should initialize Container with correct properties', () => {
+  const provided = {
+    key: 'testKey',
+    payload: { data: 'testData' },
+    ttl: 100,
+    timestamp: Date.now(),
+    prefix: 'testPrefix',
+    hooks: {
+      onBind: jest.fn(),
+      onUnbind: jest.fn(),
+    },
+  };
+  const container = new Container(provided);
+  expect(container.key).toBe('testPrefixtestKey');
+  expect(container.payload).toEqual(provided.payload);
+  expect(container.ttl).toBe(provided.ttl);
+  expect(container.expiresAt).toBe(provided.timestamp + provided.ttl * 1000);
+});
+
+// Test generated using Keploy
+test('should merge payload correctly', () => {
+  const provided = {
+    key: 'testKey',
+    payload: { data: 'initialData' },
+    ttl: 100,
+    timestamp: Date.now(),
+  };
+  const container = new Container(provided);
+  const merged = container.merge({ data: 'newData' });
+  expect(merged.payload.data).toBe('newData');
+});
+
+// Test generated using Keploy
+test('should assign new payload to Container', () => {
+  const provided = {
+    key: 'testKey',
+    payload: { data: 'initialData' },
+    ttl: 100,
+    timestamp: Date.now(),
+  };
+  const container = new Container(provided);
+  container.assign({ data: 'updatedData' });
+  expect(container.payload.data).toBe('updatedData');
+});
+
+// Test generated using Keploy
+test('should call onBind hook when binding', () => {
+  const onBindMock = jest.fn();
+  const provided = {
+    key: 'testKey',
+    payload: {},
+    ttl: 100,
+    timestamp: Date.now(),
+    hooks: {
+      onBind: onBindMock,
+    },
+  };
+  const container = new Container(provided);
+  container.bind('testLink');
+  expect(onBindMock).toHaveBeenCalled();
+});
+
+// Test generated using Keploy
+test('should call onUnbind hook when unbinding', () => {
+  const onUnbindMock = jest.fn();
+  const provided = {
+    key: 'testKey',
+    payload: {},
+    ttl: 100,
+    timestamp: Date.now(),
+    hooks: {
+      onUnbind: onUnbindMock,
+    },
+  };
+  const container = new Container(provided);
+  container.unbind();
+  expect(onUnbindMock).toHaveBeenCalled();
+});

package/src/server/models/containers/model.ts

@@ -0,0 +1,79 @@
+import merge from 'deepmerge';
+import rfdc from 'rfdc';
+import _ from 'lodash';
+
+import { PartialDeep, TFunction } from '../../../../types';
+import { compileContainerLink } from './utils';
+
+const clone = rfdc();
+
+export class Container<TPayload extends object = object> {
+  public TPlain!: Pick<Container<TPayload>, 'key' | 'prefix' | 'payload' | 'ttl'>;
+
+  public ttl = this.provided.ttl;
+  public expiresAt = this.provided.timestamp + this.ttl * 1000;
+
+  public payload = this.provided.payload;
+
+  public prefix = this.provided.prefix;
+  public key = (this.prefix ?? '') + this.provided.key;
+
+  constructor(
+    public provided: {
+      key: string;
+      payload: TPayload;
+
+      /** Seconds */
+      ttl: number;
+      timestamp: number;
+
+      prefix?: string;
+
+      hooks?: {
+        onBind?: TFunction<unknown, [string, Container<any>]>;
+        onUnbind?: TFunction<unknown, [Container<any>]>;
+      };
+    }
+  ) {}
+
+  public assign(predicate: Partial<TPayload> | TFunction<Partial<TPayload>, [TPayload]>) {
+    const payload = Object.assign(
+      this.payload,
+      typeof predicate === 'function' ? predicate(this.payload) : predicate
+    );
+
+    return Object.assign(this, { payload });
+  }
+
+  public merge(predicate: PartialDeep<TPayload> | TFunction<PartialDeep<TPayload>, [TPayload]>) {
+    const payload = merge(
+      this.payload,
+      <TPayload>(typeof predicate === 'function' ? predicate(this.payload) : predicate),
+      { arrayMerge: (target, source) => source }
+    );
+
+    return Object.assign(this, { payload });
+  }
+
+  public bind(key: string | object): this {
+    this.provided.hooks?.onBind?.(compileContainerLink(key), this);
+    return this;
+  }
+
+  public unbind(): this {
+    this.provided.hooks?.onUnbind?.(this);
+    return this;
+  }
+
+  public clone(): Container<TPayload> {
+    return new Container<TPayload>({ ...this.provided, payload: clone(this.payload) });
+  }
+
+  public toPlain(): Container<TPayload>['TPlain'] {
+    return _.pick(this, ['key', 'prefix', 'payload', 'ttl']);
+  }
+
+  static build<T extends object>(provided: Container<T>['provided']) {
+    return new Container<T>(provided);
+  }
+}

package/src/server/models/containers/storage.spec.ts

@@ -0,0 +1,41 @@
+import { ContainersStorage } from './storage';
+
+// Test generated using Keploy
+test('register method increases storage size correctly', () => {
+  const storage = new ContainersStorage();
+  const config = {
+    key: 'test-key',
+    payload: { data: 'test data' },
+    ttl: 3600,
+  };
+  storage.register(config);
+  expect(storage.size).toBe(1);
+});
+
+// Test generated using Keploy
+test('provide method reuses existing container', () => {
+  const storage = new ContainersStorage();
+  const config = { key: 'test-key', payload: { data: 'test data' } };
+  const container1 = storage.provide(config);
+  const container2 = storage.provide(config);
+  expect(container1).toBe(container2);
+  expect(storage.size).toBe(1);
+});
+
+// Test generated using Keploy
+test('delete method removes container and decreases size', () => {
+  const storage = new ContainersStorage();
+  const config = { key: 'test-key', payload: { data: 'test data' } };
+  storage.register(config);
+  expect(storage.size).toBe(1);
+  storage.delete('test-key');
+  expect(storage.size).toBe(0);
+});
+
+// Test generated using Keploy
+test('getExpired method returns empty array when no containers are expired', () => {
+  const storage = new ContainersStorage();
+  const result = storage.getExpired();
+  expect(result).toEqual([]);
+});
+

package/src/server/models/containers/storage.ts

@@ -0,0 +1,59 @@
+import { compileContainerLink } from './utils';
+import { Container } from './model';
+
+export interface IContainerConfiguration<T extends object> {
+  key: string | object;
+  payload: T;
+
+  /** Seconds */
+  ttl?: number;
+  prefix?: string;
+}
+
+export class ContainersStorage<T extends object = object> {
+  private storage = new Map<string, Container<T>>();
+
+  public get size(): number {
+    return this.storage.size;
+  }
+
+  public register(configuration: IContainerConfiguration<T>): Container<T> {
+    const key = compileContainerLink(configuration.key);
+    const container = Container.build({
+      key,
+      payload: configuration.payload,
+
+      timestamp: Date.now(),
+      ttl: configuration?.ttl ?? 3600,
+
+      hooks: {
+        onUnbind: (target) => this.storage.delete(target.key),
+        onBind: (key, target) => {
+          const alias = Container.build({ ...target.provided, key });
+          this.storage.set(alias.key, alias);
+        },
+      },
+    });
+
+    this.storage.set(container.key, container);
+    return container;
+  }
+
+  public provide(configuration: IContainerConfiguration<T>): Container<T> {
+    return this.find(configuration.key) ?? this.register(configuration);
+  }
+
+  public find(key: string | object): Container<T> | undefined {
+    return <Container<T>>this.storage.get(compileContainerLink(key));
+  }
+
+  public delete(key: string | object): this {
+    this.storage.delete(compileContainerLink(key));
+    return this;
+  }
+
+  public getExpired(): Container[] {
+    const timestamp = Date.now();
+    return [...this.storage.values()].filter((container) => container.expiresAt < timestamp);
+  }
+}

package/src/server/models/containers/utils.ts

@@ -0,0 +1,4 @@
+import { Value } from '@n1k1t/typebox/value';
+
+export const compileContainerLink =
+  (key: string | object) => typeof key === 'object' ? Value.Hash(key).toString() : String(key);