@n1k1t/mock-server 0.1.61 → 0.1.62

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

@@ -1,126 +0,0 @@
-import _ from 'lodash';
-
-import { ExpectationOperator, TExpectationOperatorConstructor } from '../models/operator';
-import { extractContextByLocation } from '../utils';
-import { TFunction } from '../../../types';
-import {
-  CompileExpectationOperatorValue,
-  IExpectationSchemaContext,
-  IExpectationExecUtils,
-  IExpectationOperatorsSchema,
-  LExpectationMetaTagLocation,
-  TExpectationMetaTag,
-  TExpectationMetaTagLocation,
-  TExpectationOperatorLocation,
-} from '../types';
-
-export default class SwitchExpectationOperator<
-  TContext extends IExpectationSchemaContext,
-  TPickLocation extends TExpectationOperatorLocation = TExpectationOperatorLocation,
-  TPickValue = void,
-  TForwardLocation extends TExpectationOperatorLocation = TExpectationOperatorLocation,
-  TForwardValue = void
-> extends ExpectationOperator<
-  TContext,
-  {
-    [K in TPickLocation]: {
-      $location: K;
-
-      $cases: Partial<
-        Record<
-          Extract<CompileExpectationOperatorValue<TContext, K, TPickValue>, number | string> extends never
-            ? (number | string)
-            : Extract<CompileExpectationOperatorValue<TContext, K, TPickValue>, number | string>,
-          IExpectationOperatorsSchema<TContext, TForwardLocation, TForwardValue>
-        >
-      >;
-
-      $default?: IExpectationOperatorsSchema<TContext, TForwardLocation, TForwardValue>;
-      $path?: string;
-
-      $exec?: string | TFunction<unknown, [
-        CompileExpectationOperatorValue<TContext, K, TPickValue>,
-        IExpectationExecUtils<TContext>
-      ]>;
-    }
-  }[TPickLocation]
-> {
-  public compiled = {
-    cases: Object
-      .entries(this.command.$cases)
-      .reduce<Record<string | number, ExpectationOperator<any, any>>>((acc, [key, schema]) => {
-        const extracted = this.extractNestedSchema(<IExpectationOperatorsSchema<any, any>>schema);
-        if (!extracted) {
-          return acc;
-        }
-
-        const Operator = <TExpectationOperatorConstructor<TContext>>this.operators[extracted.key];
-        return _.set(acc, key, new Operator(this.operators, extracted.nested));
-      }, {}),
-
-    ...(this.command.$default && {
-      default: (() => {
-        const extracted = this.extractNestedSchema(this.command.$default);
-        if (!extracted) {
-          return null;
-        }
-
-        const Operator = <TExpectationOperatorConstructor<TContext>>this.operators[extracted.key];
-        return new Operator(this.operators, extracted.nested);
-      })(),
-    }),
-
-    ...(this.command.$exec && {
-      exec: this.compileExecHandler(this.command.$exec, ['payload', 'utils']),
-    }),
-  };
-
-  public get tags(): TExpectationMetaTag[] {
-    return [
-      ...(
-        LExpectationMetaTagLocation.includes(<TExpectationMetaTagLocation>this.command.$location)
-          ? Object.keys(this.compiled.cases).map((value) => (<TExpectationMetaTag>{ location: this.command.$location, value }))
-          : []
-      ),
-
-      ...Object.values(this.compiled.cases).reduce<TExpectationMetaTag[]>((acc, operator) => acc.concat(operator.tags), []),
-      ...(this.compiled.default?.tags ?? []),
-    ];
-  }
-
-  public match(context: TContext): boolean {
-    const operator = this.handle(context);
-    return operator?.match(context) ?? false;
-  }
-
-  public manipulate<T extends TContext>(context: T): T {
-    const operator = this.handle(context);
-
-    operator?.manipulate(context);
-    return context;
-  }
-
-  private handle<T extends TContext>(context: T): ExpectationOperator<any, any> | null {
-    const value = this.extractValue(context);
-    if (value === null) {
-      return this.compiled.default ?? null;
-    }
-
-    return _.get(this.compiled.cases, String(value)) ?? this.compiled.default ?? null;
-  }
-
-  private extractValue<T extends TContext>(context: T): unknown {
-    const payload = extractContextByLocation(this.command.$location, context);
-    if (!payload) {
-      return null;
-    }
-
-    if (this.compiled.exec) {
-      return this.compiled.exec('match', context, payload.value);
-    }
-
-    return this.command.$path
-      ? payload.type === 'object' ? _.get(payload.value, this.command.$path) : payload.value
-      : payload.value;
-  }
-}

package/src/expectations/types.ts

@@ -1,225 +0,0 @@
-import type { Observable } from 'rxjs';
-import type { faker } from '@faker-js/faker';
-import type dayjs from 'dayjs';
-import type * as rxjs from 'rxjs';
-import type _ from 'lodash';
-
-import type { Container, ContainersStorage, IRequestContextIncoming, IRequestContextOutgoing, RequestContextSnapshot } from '../server/models';
-import type { ConvertTupleToUnion, ExtractObjectValueByPath } from '../../types';
-import type { MetaContext } from '../meta';
-import type { Logger } from '../logger';
-
-import type * as operators from './operators';
-
-import type AndExpectationOperator from './operators/and.operator';
-import type SetExpectationOperator from './operators/set.operator';
-import type HasExpectationOperator from './operators/has.operator';
-import type OrExpectationOperator from './operators/or.operator';
-import type NotExpectationOperator from './operators/not.operator';
-import type IfExpectationOperator from './operators/if.operator';
-import type MergeExpectationOperator from './operators/merge.operator';
-import type RemoveExpectationOperator from './operators/remove.operator';
-import type ExecExpectationOperator from './operators/exec.operator';
-import type SwitchExpectationOperator from './operators/switch.operator';
-
-export type TExpectationFlatOperator = ConvertTupleToUnion<typeof LExpectationFlatOperator>;
-export const LExpectationFlatOperator = <const>['$set', '$remove', '$merge', '$exec', '$has'];
-
-export type TExpectationMetaTagLocation = ConvertTupleToUnion<typeof LExpectationMetaTagLocation>;
-export const LExpectationMetaTagLocation = <const>['path', 'method', 'outgoing.status'];
-
-export type TExpectationMetaTag =
-  | { location: 'path' | 'method' | 'error', value: string }
-  | { location: 'outgoing.status', value: number };
-
-export interface IExpectationMeta {
-  executionsCount: number;
-  tags: TExpectationMetaTag[];
-};
-
-export type TExpectationContextLocation = 'request' | 'response';
-
-export type TExpectationOperatorLocation = ConvertTupleToUnion<typeof LExpectationOperatorLocation>;
-export const LExpectationOperatorLocation = <const>[
-  'transport',
-  'event',
-  'flags',
-
-  'container',
-  'cache',
-  'state',
-  'seed',
-  'error',
-  'delay',
-
-  'path',
-  'method',
-
-  'incoming.data',
-  'incoming.dataRaw',
-  'incoming.query',
-  'incoming.headers',
-  'incoming.stream',
-
-  'outgoing.data',
-  'outgoing.dataRaw',
-  'outgoing.status',
-  'outgoing.headers',
-  'outgoing.stream',
-];
-
-export type TExpectationOperatorObjectLocation =
-  | 'cache'
-  | 'state'
-  | 'flags'
-  | 'incoming.data'
-  | 'incoming.headers'
-  | 'incoming.query'
-  | 'outgoing.data'
-  | 'outgoing.headers';
-
-export type TExpectationOperators = Omit<typeof operators, 'root'>;
-
-export interface IExpectationSchemaInput {
-  state?: Record<string, any>;
-
-  incoming?: Pick<IRequestContextIncoming, 'query' | 'data'>;
-  outgoing?: Pick<IRequestContextOutgoing, 'data'>;
-
-  container?: any;
-  transport?: any;
-  event?: any;
-  flag?: any;
-}
-
-type ExtractData<T extends IExpectationSchemaInput['incoming'] | IExpectationSchemaInput['outgoing']> =
-  'data' extends keyof T ? T['data'] : any;
-
-export interface IExpectationSchemaContext<TInput extends IExpectationSchemaInput = {}> {
-  transport: TInput['transport'];
-  event: TInput['event'];
-  flags: Partial<Record<TInput['flag'], boolean>>;
-
-  state: TInput['state'] extends object ? TInput['state'] : Record<string, any>;
-  storage: ContainersStorage<TInput['container']>;
-  cache: TInput extends object ? RequestContextSnapshot['cache'] : any;
-
-  container?: Container<NonNullable<TInput['container']>>;
-  seed?: RequestContextSnapshot['seed'];
-
-  incoming: TInput['incoming'] extends object
-    ? Omit<IRequestContextIncoming, 'stream'> & TInput['incoming'] & {
-      data?: ExtractData<TInput['incoming']>;
-      stream?: Observable<ExtractData<TInput['incoming']>>;
-    }
-    : IRequestContextIncoming;
-
-  outgoing: TInput['outgoing'] extends object
-    ? IRequestContextOutgoing & TInput['outgoing'] & {
-      data?: ExtractData<TInput['outgoing']>;
-      stream?: Observable<ExtractData<TInput['outgoing']>>;
-    }
-    : IRequestContextOutgoing;
-};
-
-type ConvertExpectationLocationToContextPath<TLocation extends TExpectationOperatorLocation> =
-  TLocation extends 'path' | 'method' | 'error' | 'delay'
-    ? {
-      path: 'incoming.path';
-      delay: 'incoming.delay';
-      error: 'incoming.error';
-      method: 'incoming.method';
-    }[TLocation]
-    : TLocation;
-
-export type ExtractExpectationContextValueByLocation<
-  TContext extends object,
-  TLocation extends TExpectationOperatorLocation,
-  T = ExtractObjectValueByPath<TContext, ConvertExpectationLocationToContextPath<TLocation>>,
-  U = ExtractObjectValueByPath<IExpectationSchemaContext, ConvertExpectationLocationToContextPath<TLocation>>,
-> = Exclude<T, never> extends never ? Exclude<U, never> extends never ? any : U : T;
-
-export type ExtractExpectationContextValue<
-  TContext extends IExpectationSchemaContext,
-  TLocation extends TExpectationOperatorLocation,
-  TPath extends string | void = void,
-  T = ExtractExpectationContextValueByLocation<TContext, TLocation>,
-  U = TPath extends string ? T extends object ? ExtractObjectValueByPath<T, TPath> : any : T
-> = Exclude<U, never> extends never ? any : U;
-
-export type CompileExpectationOperatorValue<
-  TContext extends IExpectationSchemaContext,
-  TLocation extends TExpectationOperatorLocation,
-  TProvided = void,
-  T = ExtractExpectationContextValue<TContext, TLocation>
-> = Exclude<TProvided, void> extends never ? T : TProvided;
-
-export type CompileExpectationOperatorValueWithPredicate<
-  TContext extends IExpectationSchemaContext,
-  TLocation extends TExpectationOperatorLocation,
-  TProvided = void,
-  T = CompileExpectationOperatorValue<TContext, TLocation, TProvided>
-> = T extends object ? (T | object) : T;
-
-export interface IExpectationOperatorsSchema<
-  TContext extends IExpectationSchemaContext = IExpectationSchemaContext,
-  TLocation extends TExpectationOperatorLocation = TExpectationOperatorLocation,
-  TValue = void
-> {
-  $and?: AndExpectationOperator<TContext, TLocation, TValue>['TSchema'];
-  $or?: OrExpectationOperator<TContext, TLocation, TValue>['TSchema'];
-
-  $not?: NotExpectationOperator<TContext, TLocation, TValue>['TSchema'];
-  $if?: IfExpectationOperator<TContext, TLocation, TValue>['TSchema'];
-  $switch?: SwitchExpectationOperator<TContext, TLocation, TValue, TLocation, TValue>['TSchema'];
-
-  $set?: SetExpectationOperator<TContext, TLocation, TValue>['TSchema'];
-  $has?: HasExpectationOperator<TContext, TLocation, TValue>['TSchema'];
-  $merge?: MergeExpectationOperator<TContext, Extract<TLocation, TExpectationOperatorObjectLocation>, TValue>['TSchema'];
-  $remove?: RemoveExpectationOperator<TContext, TLocation>['TSchema'];
-
-  $exec?: ExecExpectationOperator<TContext>['TSchema'];
-};
-
-export interface IExpectationSchemaForward {
-  url?: string;
-  baseUrl?: string;
-  timeout?: number;
-
-  cache?: Pick<RequestContextSnapshot['cache'], 'key' | 'prefix' | 'ttl'> & {
-    storage?: 'redis';
-  };
-
-  options?: {
-    /** Rewrites the `Host` header by forwarding url. Default is `true` */
-    overrideHost?: boolean;
-  };
-
-  proxy?: {
-    host: string;
-    port: number;
-  };
-}
-
-export interface IExpectationSchema<TContext extends IExpectationSchemaContext = IExpectationSchemaContext> {
-  request?: IExpectationOperatorsSchema<TContext>;
-  response?: IExpectationOperatorsSchema<TContext>;
-  forward?: IExpectationSchemaForward;
-};
-
-export type IExpectationExecMode = 'match' | 'manipulate';
-
-export interface IExpectationExecUtils<T extends IExpectationSchemaContext> {
-  context: T;
-  logger: Logger;
-
-  mode: IExpectationExecMode;
-  meta: MetaContext;
-
-  T: <T = any>(payload: unknown) => T;
-
-  _: typeof _;
-  d: typeof dayjs;
-  rx: typeof rxjs;
-  faker: typeof faker;
-}

package/src/expectations/utils/index.ts

@@ -1,3 +0,0 @@
-export * from './location';
-export * from './schema';
-export * from './json';

package/src/expectations/utils/json.ts

@@ -1,22 +0,0 @@
-import { JSONPath, JSONPathOptions } from 'jsonpath-plus';
-
-export interface IJsonPathExtractionResult {
-  value: object;
-  parent: object;
-  pointer: string;
-  parentProperty: string;
-};
-
-export const extractWithJsonPathSafe = (params: Omit<JSONPathOptions, 'resultType'>) => {
-  try {
-    return <const>{
-      status: 'OK',
-      results: JSONPath<IJsonPathExtractionResult[]>(Object.assign(params, <const>{ resultType: 'all' })),
-    };
-  } catch(error) {
-    return <const>{
-      status: 'ERROR',
-      error: error instanceof Error ? error : new Error('Unknown'),
-    };
-  }
-};

package/src/expectations/utils/location.spec.ts

@@ -1,64 +0,0 @@
-import { extractContextByLocation, checkIsLocationInContext } from './location';
-
-// Test generated using Keploy
-it('should return false for undefined location in context', () => {
-  const context = { incoming: {} };
-  const result = checkIsLocationInContext(<any>'nonexistent', <any>context);
-  expect(result).toBe(false);
-});
-
-// Test generated using Keploy
-it('should return expected context for valid path', () => {
-  const context = {
-    incoming: {
-      path: '/api/test',
-      method: 'GET',
-    },
-  };
-  const result = extractContextByLocation('path', <any>context);
-  expect(result).toEqual({
-    key: 'incoming.path',
-    type: 'string',
-    parent: context,
-    value: '/api/test',
-  });
-});
-
-// Test generated using Keploy
-it('should return null for invalid location', () => {
-  const context = {};
-  const result = extractContextByLocation(<any>'invalid.location', <any>context);
-  expect(result).toBeNull();
-});
-
-// Test generated using Keploy
-it('should return correct context for method location', () => {
-  const context = {
-    incoming: {
-      method: 'GET',
-    },
-  };
-  const result = extractContextByLocation('method', <any>context);
-  expect(result).toEqual({
-    key: 'incoming.method',
-    type: 'string',
-    parent: context,
-    value: 'GET',
-  });
-});
-
-// Test generated using Keploy
-it('should return correct context for outgoing.data location', () => {
-  const context = {
-    outgoing: {
-      data: { key: 'value' },
-    },
-  };
-  const result = extractContextByLocation('outgoing.data', <any>context);
-  expect(result).toEqual({
-    key: 'outgoing.data',
-    type: 'object',
-    parent: context,
-    value: { key: 'value' },
-  });
-});

package/src/expectations/utils/location.ts

@@ -1,180 +0,0 @@
-import _ from 'lodash';
-
-import { IExpectationSchemaContext, TExpectationOperatorLocation } from '../types';
-
-type TBaseExtractedContext = { parent: object, key: string };
-type TExtractedContext =
-  | (TBaseExtractedContext & { value?: unknown, type: 'object' })
-  | (TBaseExtractedContext & { value?: string, type: 'string' })
-  | (TBaseExtractedContext & { value?: Buffer, type: 'buffer' })
-  | (TBaseExtractedContext & { value?: number, type: 'number' });
-
-export const checkIsLocationInContext = (
-  location: TExpectationOperatorLocation,
-  context: IExpectationSchemaContext
-): boolean => {
-  switch(location) {
-    case 'delay':
-    case 'error':
-    case 'method':
-    case 'path': return context.incoming[location] !== undefined;
-
-    default: return _.get(context, location) !== undefined;
-  }
-}
-
-export const extractContextByLocation = (
-  location: TExpectationOperatorLocation,
-  context: IExpectationSchemaContext
-): TExtractedContext | null => {
-  switch(location) {
-    case 'path': return {
-      key: 'incoming.path',
-      type: 'string',
-      parent: context,
-      value: context.incoming?.path,
-    };
-
-    case 'method': return {
-      key: 'incoming.method',
-      type: 'string',
-      parent: context,
-      value: context.incoming?.method,
-    };
-
-    case 'incoming.data': return {
-      key: 'incoming.data',
-      type: 'object',
-      parent: context,
-      value: context.incoming?.data,
-    };
-
-    case 'incoming.dataRaw': return {
-      key: 'incoming.dataRaw',
-      type: 'buffer',
-      parent: context,
-      value: context.incoming?.dataRaw,
-    };
-
-    case 'incoming.query': return {
-      key: 'incoming.query',
-      type: 'object',
-      parent: context,
-      value: context.incoming?.query,
-    };
-
-    case 'incoming.headers': return {
-      key: 'incoming.headers',
-      type: 'object',
-      parent: context,
-      value: context.incoming?.headers,
-    };
-
-    case 'incoming.stream': return {
-      key: 'incoming.stream',
-      type: 'object',
-      parent: context,
-      value: context.incoming.stream,
-    };
-
-    case 'outgoing.data': return {
-      key: 'outgoing.data',
-      type: 'object',
-      parent: context,
-      value: context.outgoing?.data,
-    };
-
-    case 'outgoing.dataRaw': return {
-      key: 'outgoing.dataRaw',
-      type: 'buffer',
-      parent: context,
-      value: context.outgoing?.dataRaw,
-    };
-
-    case 'outgoing.headers': return {
-      key: 'outgoing.headers',
-      type: 'object',
-      parent: context,
-      value: context.outgoing?.headers,
-    };
-
-    case 'outgoing.status': return {
-      key: 'outgoing.status',
-      type: 'number',
-      parent: context,
-      value: context.outgoing?.status,
-    };
-
-    case 'outgoing.stream': return {
-      key: 'outgoing.stream',
-      type: 'object',
-      parent: context,
-      value: context.outgoing.stream,
-    };
-
-    case 'delay': return {
-      key: 'incoming.delay',
-      type: 'number',
-      parent: context,
-      value: context.incoming?.delay,
-    };
-
-    case 'error': return {
-      key: 'incoming.error',
-      type: 'string',
-      parent: context,
-      value: context.incoming?.error,
-    };
-
-    case 'seed': return {
-      key: 'seed',
-      type: 'number',
-      parent: context,
-      value: context.seed,
-    };
-
-    case 'state': return {
-      key: 'state',
-      type: 'object',
-      parent: context,
-      value: context.state,
-    };
-
-    case 'cache': return {
-      key: 'cache',
-      type: 'object',
-      parent: context,
-      value: context.cache,
-    };
-
-    case 'container': return {
-      key: 'container',
-      type: 'object',
-      parent: context,
-      value: context.container,
-    };
-
-    case 'transport': return {
-      key: 'transport',
-      type: 'string',
-      parent: context,
-      value: <string>context.transport,
-    };
-
-    case 'event': return {
-      key: 'event',
-      type: 'string',
-      parent: context,
-      value: <string>context.event,
-    };
-
-    case 'flags': return {
-      key: 'flags',
-      type: 'object',
-      parent: context,
-      value: context.flags,
-    };
-
-    default: return null;
-  }
-}

package/src/expectations/utils/schema.spec.ts

@@ -1,17 +0,0 @@
-import { serializeExpectationSchema } from './schema';
-
-// Test generated using Keploy
-it('should serialize $exec functions in the schema', () => {
-  const schema = {
-    $exec: () => {},
-    nested: {
-      $exec: () => {},
-      $has: {
-        $exec: () => {},
-      },
-    },
-  };
-  const result = serializeExpectationSchema(schema);
-  expect(result.nested.$exec).toBeDefined();
-  expect(result.nested.$has.$exec).toBeDefined();
-});

package/src/expectations/utils/schema.ts

@@ -1,60 +0,0 @@
-import rfdc from 'rfdc';
-import _ from 'lodash';
-
-import { serializeRegExp } from '../../utils';
-import {
-  IExpectationSchema,
-  LExpectationFlatOperator,
-  TExpectationFlatOperator,
-  IExpectationOperatorsSchema,
-} from '../types';
-
-const clone = rfdc();
-
-export const introspectExpectationOperatorsSchema = <T extends object = IExpectationSchema, K extends keyof T = keyof T>(
-  schema: T,
-  handler: (key: K, schema: T, path: string) => unknown,
-  location: string = ''
-): void => {
-  (<K[]>Object.keys(schema)).forEach((key) => {
-    const path = location ? `${location}.${String(key)}` : String(key);
-
-    handler(key, schema, path);
-
-    if (_.isObject(schema[key]) && !LExpectationFlatOperator.includes(<TExpectationFlatOperator>key)) {
-      introspectExpectationOperatorsSchema(<T>schema[key], handler, path);
-    }
-  });
-}
-
-export const serializeExpectationSchema = <T extends IExpectationOperatorsSchema<any>>(schema: T): T => {
-  const cloned = clone(schema ?? {});
-
-  introspectExpectationOperatorsSchema(schema, (key, schema, path) => {
-    if (key === '$exec') {
-      _.set(cloned, path, schema.$exec?.toString());
-    }
-
-    if (key === '$has' && schema.$has?.$regExp) {
-      _.set(cloned, `${path}.$regExp`, serializeRegExp(schema.$has.$regExp));
-    }
-    if (key === '$has' && schema.$has?.$regExpAnyOf) {
-      _.set(cloned, `${path}.$regExpAnyOf`, schema.$has.$regExpAnyOf.map((expr) => serializeRegExp(expr)));
-    }
-
-    if (key === '$has' && schema.$has?.$exec) {
-      _.set(cloned, `${path}.$exec`, schema.$has.$exec.toString());
-    }
-    if (key === '$set' && schema.$set?.$exec) {
-      _.set(cloned, `${path}.$exec`, schema.$set.$exec.toString());
-    }
-    if (key === '$merge' && schema.$merge?.$exec) {
-      _.set(cloned, `${path}.$exec`, schema.$merge.$exec.toString());
-    }
-    if (key === '$switch' && schema.$switch?.$exec) {
-      _.set(cloned, `${path}.$exec`, schema.$switch.$exec.toString());
-    }
-  });
-
-  return cloned;
-}