@n1k1t/mock-server 0.1.61 → 0.1.62

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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