@n1k1t/mock-server 0.1.60 → 0.1.61

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

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

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

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

package/src/expectations/utils/json.ts

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

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

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

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

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