@n1k1t/mock-server 0.1.61 → 0.1.62

package/src/client/utils.ts

@@ -1,41 +0,0 @@
-import { AxiosError } from 'axios';
-import _ from 'lodash';
-
-import type { IRequestConfiguration } from './errors';
-import type { IEndpointResponse } from '../server';
-
-import { ConnectionError, InternalServerError, ValidationError } from './errors';
-import { Expectation, serializeExpectationSchema } from '../expectations';
-
-export const handleRequestError = (error: AxiosError<IEndpointResponse<any>>) => {
-  const configuration: IRequestConfiguration = {
-    baseURL: error.config.baseURL,
-    method: error.config.method,
-    url: error.config.url,
-  };
-
-  if (!error.response) {
-    throw new ConnectionError(configuration);
-  }
-
-  switch(error.response?.data.code) {
-    case 'INTERNAL_ERROR': {
-      throw new InternalServerError(configuration, error.response?.data.data?.message);
-    }
-    case 'VALIDATION_ERROR': {
-      throw new ValidationError(configuration, error.response?.data.data?.reasons);
-    }
-  }
-
-  throw new InternalServerError(configuration, error.message);
-}
-
-export const prepareExpectationBodyToRequest = <T extends Partial<Expectation<any>['TPlain']>>(body: T): T => ({
-  ...body,
-
-  schema: {
-    ...body.schema,
-    ...(body.schema?.request && { request: serializeExpectationSchema(body.schema.request) }),
-    ...(body.schema?.response && { response: serializeExpectationSchema(body.schema.response) }),
-  }
-});

package/src/config/index.ts

@@ -1,34 +0,0 @@
-import path from 'path';
-
-import type { TLoggerLevel } from '../logger';
-
-import { Config } from './model';
-import { cast } from '../utils';
-
-export * from './model';
-
-const checkIsTypeScriptRuntime = (): boolean => path.parse(__filename).ext === '.ts';
-const getPathToRoot = (): string => path.resolve(__dirname, checkIsTypeScriptRuntime() ? '' : '../', '../../');
-
-export default Config.build(<const>{
-    statics: {
-      public: {
-        dir: path.resolve(getPathToRoot(), 'public'),
-      },
-    },
-
-    routes: {
-      internal: {
-        root: '/_system',
-        gui: '/gui',
-      },
-    },
-
-    history: {
-      limit: 100,
-    },
-
-    logger: {
-      level: cast<TLoggerLevel>('D'),
-    },
-  });

package/src/config/model.ts

@@ -1,24 +0,0 @@
-import merge from 'deepmerge';
-import { PartialDeep, SetRequiredKeys } from '../../types';
-
-export class Config<T extends object = object> {
-  public storage: T = merge(this.defaults, JSON.parse(process.env['MOCK_CONFIG'] ?? '{}'));
-
-  constructor(public defaults: T) {}
-
-  public get<K extends keyof T>(key: K): T[K] {
-    return this.storage[key];
-  }
-
-  public has<K extends keyof T>(key: K): this is SetRequiredKeys<T, K> {
-    return key in this.storage;
-  }
-
-  public merge(payload: PartialDeep<T>): this {
-    return Object.assign(this, { storage: merge(this.storage, <T>payload, { arrayMerge: (target, source) => source }) });
-  }
-
-  static build<T extends object>(defaults: T) {
-    return new Config(defaults);
-  }
-}

package/src/expectations/__utils__/index.ts

@@ -1,61 +0,0 @@
-import { IExpectationSchemaContext } from '../types';
-import { ContainersStorage } from '../../server/models';
-
-export const buildExpectationContext = (): IExpectationSchemaContext => ({
-  storage: new ContainersStorage(),
-
-  transport: 'http',
-  event: 'connection',
-
-  state: {},
-  flags: {},
-
-  cache: {
-    isEnabled: false,
-  },
-
-  incoming: {
-    type: 'json',
-
-    path: '/foo/bar/baz',
-    method: 'POST',
-
-    query: {
-      foo: 1,
-      bar: {
-        baz: null,
-      },
-    },
-
-    dataRaw: Buffer.from('{"foo": [{"bar": 1}, {"baz": ["2"]}]}'),
-    data: {
-      foo: [
-        { bar: 1 },
-        { baz: ['2'] },
-      ],
-    },
-
-    headers: {
-      'content-type': 'application/json',
-      'accept-language': 'en/gb',
-    },
-  },
-
-  outgoing: {
-    type: 'json',
-    status: 200,
-
-    dataRaw: Buffer.from('{"foo": {"bar": {"baz": true}}}'),
-    data: {
-      foo: {
-        bar: {
-          baz: true,
-        },
-      },
-    },
-
-    headers: {
-      'content-type': 'application/json',
-    },
-  },
-});

package/src/expectations/errors/index.ts

@@ -1,7 +0,0 @@
-import { ValueError } from '@n1k1t/typebox/errors';
-
-export class ExpectationValidationError extends Error {
-  constructor(public reasons: ValueError[]) {
-    super('Got error on expectation validation');
-  }
-}

package/src/expectations/index.ts

@@ -1,3 +0,0 @@
-export * from './models';
-export * from './types';
-export * from './utils';

package/src/expectations/models/expectation.ts

@@ -1,96 +0,0 @@
-import generateAnimalName from 'random-animal-name';
-import { v4 as genUid } from 'uuid';
-import { ValueError } from '@n1k1t/typebox/errors';
-import _ from 'lodash';
-
-import { serializeExpectationSchema } from '../utils';
-import {
-  IExpectationMeta,
-  IExpectationSchemaContext,
-  IExpectationSchemaInput,
-  IExpectationSchema,
-} from '../types';
-
-import * as operators from '../operators';
-
-export class Expectation<
-  TInput extends IExpectationSchemaInput = {},
-  TContext extends IExpectationSchemaContext<TInput> = IExpectationSchemaContext<TInput>
-> {
-  public TPlain!: Pick<
-    Expectation<TInput, TContext>,
-    'schema' | 'id' | 'group' | 'isEnabled' | 'meta' | 'name' | 'transports'
-  >;
-
-  public id: string = this.configuration.id ?? genUid();
-  public name: string = this.configuration.name ?? generateAnimalName().split(' ').map(_.capitalize).join('');
-  public group: string = this.configuration.group ?? 'unknown';
-
-  public transports?: TContext['transport'][] = this.configuration.transports;
-
-  public schema = <IExpectationSchema<TContext>>this.configuration.schema;
-  public isEnabled: boolean = this.configuration.isEnabled ?? true;
-
-  public request = this.schema.request
-    ? new operators.root<TContext>(operators, this.schema.request)
-    : new operators.root<TContext>(operators, { $exec: () => true });
-
-  public response = this.schema.response
-    ? new operators.root<TContext>(operators, this.schema.response)
-    : null;
-
-  public meta: IExpectationMeta = {
-    executionsCount: this.configuration.meta?.executionsCount ?? 0,
-    tags: (this.request?.tags ?? []).concat(this.response?.tags ?? []),
-  };
-
-  public get forward() {
-    return this.schema.forward;
-  }
-
-  private serialized = {
-    schema: {
-      request: this.schema.request ? serializeExpectationSchema(this.schema.request) : undefined,
-      response: this.schema.response ? serializeExpectationSchema(this.schema.response) : undefined,
-    },
-  };
-
-  constructor(
-    public configuration: Pick<Expectation<TContext>, 'schema'> & Partial<
-      Pick<Expectation<TContext>, 'id' | 'name' | 'isEnabled' | 'group' | 'transports' | 'meta'>
-    >
-  ) {}
-
-  public increaseExecutionsCounter(): this {
-    this.meta.executionsCount += 1;
-    return this;
-  }
-
-  public validate(): ValueError[] {
-    return [];
-  }
-
-  public toPlain(): Expectation<TInput, TContext>['TPlain'] {
-    return {
-      id: this.id,
-      group: this.group,
-
-      name: this.name,
-      transports: this.transports,
-
-      meta: this.meta,
-      isEnabled: this.isEnabled,
-
-      schema: {
-        ...this.schema,
-
-        request: this.serialized.schema.request,
-        response: this.serialized.schema.response,
-      },
-    };
-  }
-
-  static build<TContext extends IExpectationSchemaContext>(configuration: Expectation<TContext>['configuration']) {
-    return new Expectation(configuration);
-  }
-}

package/src/expectations/models/index.ts

@@ -1,3 +0,0 @@
-export * from './expectation';
-export * from './operator';
-export * from './storage';

package/src/expectations/models/operator.ts

@@ -1,89 +0,0 @@
-import { Faker, ru, en, en_GB } from '@faker-js/faker';
-import dayjs from 'dayjs';
-import _ from 'lodash';
-import * as rxjs from 'rxjs';
-
-import { Constructable, TFunction } from '../../../types';
-import { metaStorage } from '../../meta';
-import { Logger } from '../../logger';
-import {
-  IExpectationSchemaContext,
-  IExpectationExecMode,
-  IExpectationExecUtils,
-  IExpectationOperatorsSchema,
-  TExpectationMetaTag,
-  TExpectationOperators,
-} from '../types';
-
-const logger = Logger.build('Expectations.Models.Operator');
-
-export type TExpectationOperatorConstructor<TContext extends IExpectationSchemaContext> =
-  Constructable<ExpectationOperator<TContext, any>, ConstructorParameters<typeof ExpectationOperator>>
-
-export abstract class ExpectationOperator<TContext extends IExpectationSchemaContext, TSchema> {
-  public TContext!: TContext;
-  public TSchema!: TSchema;
-
-  public abstract match(context: TContext): boolean;
-  public abstract manipulate<T extends TContext>(context: T): T;
-
-  public abstract get tags(): TExpectationMetaTag[];
-
-  constructor(public operators: TExpectationOperators, public command: TSchema) {}
-
-  protected compileExecHandler(raw: TFunction<any, any[]> | string, provide: ('payload' | 'utils')[]) {
-    const parameters: string[] = [];
-
-    if (provide.includes('payload')) {
-      parameters.push('payload');
-    }
-    if (provide.includes('utils')) {
-      parameters.push('{ context, mode, meta, T, _, d, faker }');
-    }
-
-    const handler = typeof raw === 'function' ? raw : Function(parameters.join(', '), `return (() => ${raw})()`);
-
-    return (mode: IExpectationExecMode, context: TContext, ...args: unknown[]) => {
-      const utils = this.compileExecUtils(mode, context);
-      const handled = handler(...args, utils);
-
-      return typeof handled === 'function' ? handled(...args, utils) : handled;
-    }
-  }
-
-  protected extractNestedSchema(schema: IExpectationOperatorsSchema<any, any>): {
-    [K in keyof IExpectationOperatorsSchema]: null | {
-      key: K;
-      nested: IExpectationOperatorsSchema[K];
-    }
-  }[keyof IExpectationOperatorsSchema] {
-    const key = <keyof IExpectationOperatorsSchema | undefined>Object.keys(schema)[0];
-    return key ? { key, nested: <any>schema[key] } : null;
-  }
-
-  private compileExecUtils<T extends TContext>(
-    mode: IExpectationExecMode,
-    context: T
-  ): IExpectationExecUtils<T> {
-    const faker = new Faker({ locale: [ru, en, en_GB] });
-
-    if (context.seed) {
-      faker.seed(context.seed);
-    }
-
-    return {
-      _,
-
-      faker,
-      mode,
-      logger,
-
-      context: <IExpectationExecUtils<T>['context']>context,
-      meta: metaStorage.provide(),
-
-      T: (payload) => <any>payload,
-      rx: rxjs,
-      d: dayjs,
-    }
-  }
-}

package/src/expectations/models/storage.spec.ts

@@ -1,70 +0,0 @@
-import { buildExpectationContext } from '../__utils__';
-import { ExpectationsStorage } from './storage'
-import { Expectation } from './expectation';
-
-describe('Expectations.Models.Storage', () => {
-  it('should not match with empty storage', () => {
-    const storage = new ExpectationsStorage();
-    expect(storage.match(buildExpectationContext())).toBeNull();
-  });
-
-  it('should match with 1 expectation', () => {
-    const storage = new ExpectationsStorage();
-
-    const { expectation } = <{ expectation: Expectation }>storage.register({
-      schema: {
-        request: { $has: { $location: 'path', $value: '/foo/bar/baz' } },
-      },
-    });
-
-    expect(storage.match(buildExpectationContext())?.id).toEqual(expectation.id);
-  });
-
-  it('should not match with 1 expectation', () => {
-    const storage = new ExpectationsStorage();
-
-    storage.register({
-      schema: {
-        request: { $has: { $location: 'path', $value: '/foo' } },
-      },
-    });
-
-    expect(storage.match(buildExpectationContext())).toBeNull();
-  });
-
-  it('should match with 2 expectations', () => {
-    const storage = new ExpectationsStorage();
-
-    storage.register({
-      schema: {
-        request: { $has: { $location: 'path', $value: '/foo/bar' } },
-      },
-    });
-
-    const { expectation } = <{ expectation: Expectation }>storage.register({
-      schema: {
-        request: { $has: { $location: 'method', $valueAnyOf: ['GET', 'POST'] } },
-      },
-    });
-
-    expect(storage.match(buildExpectationContext())?.id).toEqual(expectation.id);
-  });
-
-  it('should not match with 2 expectations', () => {
-    const storage = new ExpectationsStorage();
-
-    storage.register({
-      schema: {
-        request: { $has: { $location: 'path', $value: '/foo/bar' } },
-      },
-    });
-
-    storage.register({
-      schema: {
-        request: { $has: { $location: 'method', $valueAnyOf: ['GET'] } },
-      },
-    });
-
-    expect(storage.match(buildExpectationContext())).toBeNull();
-  });
-});

package/src/expectations/models/storage.ts

@@ -1,42 +0,0 @@
-import { ValueError } from '@n1k1t/typebox/errors';
-
-import { IExpectationSchemaContext } from '../types';
-import { Expectation } from './expectation';
-import { Logger } from '../../logger';
-
-export type TExpectationsStorageRegisterationResult =
-  | { status: 'REGISTERED', expectation: Expectation<any> }
-  | { status: 'ERROR', reasons: ValueError[] };
-
-const logger = Logger.build('Expectations.Storage');
-
-export class ExpectationsStorage extends Map<string, Expectation> {
-  public register(configuration: Expectation['configuration']): TExpectationsStorageRegisterationResult {
-    const expectation = Expectation.build<any>(configuration);
-    const errors = expectation.validate();
-
-    if (errors.length) {
-      return { status: 'ERROR', reasons: errors }
-    }
-
-    logger.info(`Expectation [${expectation.name}] has registered in group [${expectation.group}]`);
-    this.set(expectation.id, expectation);
-
-    return { status: 'REGISTERED', expectation };
-  }
-
-  public match(context: IExpectationSchemaContext): Expectation<any> | null {
-    for (const expectation of this.values()) {
-      if (!expectation.isEnabled) {
-        continue;
-      }
-
-      const hasSameTransport = expectation.transports?.includes(context.transport) ?? true;
-      if (hasSameTransport && expectation.request.match(context)) {
-        return expectation;
-      }
-    }
-
-    return null;
-  }
-}

package/src/expectations/operators/and.operator.spec.ts

@@ -1,59 +0,0 @@
-import { buildExpectationContext } from '../__utils__';
-import * as operators from './index';
-
-describe('Expectations.Operators.And', () => {
-  describe('matching', () => {
-    it('should match by schema with one valid condition', () => {
-      const operator = new operators.$and(operators, [
-        { $has: { $location: 'incoming.query', $path: 'foo', $value: 1 } },
-      ]);
-
-      expect(operator.match(buildExpectationContext())).toBeTruthy();
-    });
-
-    it('should match by schema with two valid conditions', () => {
-      const operator = new operators.$and(operators, [
-        { $has: { $location: 'incoming.query', $path: 'foo', $value: 1 } },
-        { $has: { $location: 'incoming.query', $path: 'bar.baz', $value: null } },
-      ]);
-
-      expect(operator.match(buildExpectationContext())).toBeTruthy();
-    });
-
-    it('should match by schema with zero conditions', () => {
-      expect(new operators.$and(operators, []).match(buildExpectationContext())).toBeTruthy();
-    });
-
-    it('should match by schema with one valid and one invalid condition', () => {
-      const operator = new operators.$and(operators, [
-        { $has: { $location: 'incoming.query', $path: 'foo', $value: 1 } },
-        { $has: { $location: 'incoming.query', $path: 'bar.baz', $value: 1 } },
-      ]);
-
-      expect(operator.match(buildExpectationContext())).toBeFalsy();
-    });
-
-    it('should match by schema with two invalid conditions', () => {
-      const operator = new operators.$and(operators, [
-        { $has: { $location: 'incoming.query', $path: 'foo', $value: null } },
-        { $has: { $location: 'incoming.query', $path: 'bar.baz', $value: 1 } },
-      ]);
-
-      expect(operator.match(buildExpectationContext())).toBeFalsy();
-    });
-  });
-
-  describe('manipulation', () => {
-    it('should manipulate by schema with two conditions', () => {
-      const operator = new operators.$and<any>(operators, [
-        { $set: { $location: 'incoming.headers', $path: 'content-length', $value: 100 } },
-        { $set: { $location: 'incoming.query', $path: 'bar.baz', $value: { test: true } } },
-      ]);
-
-      const context = operator.manipulate<any>(buildExpectationContext());
-
-      expect(context.incoming.headers?.['content-length']).toEqual(100);
-      expect(context.incoming.query?.bar?.baz?.test).toBeTruthy();
-    });
-  });
-});

package/src/expectations/operators/and.operator.ts

@@ -1,37 +0,0 @@
-import { ExpectationOperator, TExpectationOperatorConstructor } from '../models/operator';
-import {
-  IExpectationSchemaContext,
-  IExpectationOperatorsSchema,
-  TExpectationMetaTag,
-  TExpectationOperatorLocation,
-} from '../types';
-
-export default class AndExpectationOperator<
-  TContext extends IExpectationSchemaContext,
-  TLocation extends TExpectationOperatorLocation = TExpectationOperatorLocation,
-  TValue = void
-> extends ExpectationOperator<
-  TContext,
-  IExpectationOperatorsSchema<TContext, TLocation, TValue>[]
-> {
-  public compiled = this.command
-    .map((schema) => this.extractNestedSchema(schema)!)
-    .filter(Boolean)
-    .map((extracted) => {
-      const Operator = <TExpectationOperatorConstructor<TContext>>this.operators[extracted.key];
-      return new Operator(this.operators, extracted.nested);
-    });
-
-  public get tags(): TExpectationMetaTag[] {
-    return this.compiled.reduce<TExpectationMetaTag[]>((acc, operator) => acc.concat(operator.tags), []);
-  }
-
-  public match(context: TContext): boolean {
-    return this.compiled.every((operator) => operator.match(context));
-  }
-
-  public manipulate<T extends TContext>(context: T): T {
-    this.compiled.forEach((operator) => operator.manipulate(context));
-    return context;
-  }
-}

package/src/expectations/operators/exec.operator.spec.ts

@@ -1,47 +0,0 @@
-import { buildExpectationContext } from '../__utils__';
-import { IExpectationSchemaContext } from '../types';
-
-import * as operators from './index';
-
-describe('Expectations.Operators.Exec', () => {
-  it('should exec by inline serialized command with utils', () => {
-    const operator = new operators.$exec(operators, '_.set(context, "incoming.query.test", "foo")');
-    const context = operator.manipulate<any>(buildExpectationContext());
-
-    expect(context.incoming.query.test).toEqual('foo');
-  });
-
-  it('should exec by multiline serialized command', () => {
-    const operator = new operators.$exec(operators, `{
-      context.incoming.data.foo.push({ test: 1 });
-      context.incoming.data.foo.push({ test: 2 });
-    }`);
-
-    const context = operator.manipulate<any>(buildExpectationContext());
-
-    expect(context.incoming.data.foo[2].test).toEqual(1);
-    expect(context.incoming.data.foo[3].test).toEqual(2);
-  });
-
-  it('should exec by function', () => {
-    const operator = new operators.$exec<IExpectationSchemaContext<{
-      incoming: { query: { test: number } }
-    }>>(operators, ({ context }) => {
-      context.incoming.query.test = 100;
-    });
-
-    const context = operator.manipulate<any>(buildExpectationContext());
-    expect(context.incoming.query.test).toEqual(100);
-  });
-
-  it('should exec by function with utils', () => {
-    const operator = new operators.$exec<IExpectationSchemaContext<{
-      incoming: { query: { test: number } }
-    }>>(operators, ({ context, _ }) => {
-      _.set(context, 'incoming.query.test', 100);
-    });
-
-    const context = operator.manipulate<any>(buildExpectationContext());
-    expect(context.incoming.query.test).toEqual(100);
-  });
-});

package/src/expectations/operators/exec.operator.ts

@@ -1,25 +0,0 @@
-import _ from 'lodash';
-
-import { IExpectationExecUtils, IExpectationSchemaContext, TExpectationMetaTag } from '../types';
-import { ExpectationOperator } from '../models/operator';
-import { TFunction } from '../../../types';
-
-export default class ExecExpectationOperator<
-  TContext extends IExpectationSchemaContext,
-> extends ExpectationOperator<TContext, string | TFunction<unknown, [IExpectationExecUtils<TContext>]>> {
-  public compiled = this.compileExecHandler(this.command, ['utils']);
-
-  public get tags(): TExpectationMetaTag[] {
-    return [];
-  }
-
-  public match(context: TContext): boolean {
-    const result = this.compiled('match', context);
-    return typeof result === 'boolean' ? result : true;
-  }
-
-  public manipulate<T extends TContext>(context: T): T {
-    this.compiled('manipulate', context);
-    return context;
-  }
-}