@n1k1t/mock-server 0.1.61 → 0.1.62

package/src/server/utils/index.ts

@@ -1,35 +0,0 @@
-import { TObject, TSchema, Type } from '@n1k1t/typebox';
-import { Value, ValueError } from '@n1k1t/typebox/value';
-
-import type { Constructable } from '../../../types';
-
-interface IValidationMetaContext {
-  schema: TObject;
-  properties: Set<string | Symbol>;
-}
-
-const validationContextMetaKey = Symbol('validation:context');
-
-const buildValidationMetaContext = (): IValidationMetaContext => ({
-  schema: Type.Object({}),
-  properties: new Set(),
-});
-
-export const extractValidationMetaContext =
-  (Definition: Constructable<object> | Function): IValidationMetaContext | null =>
-    Reflect.get(Definition, validationContextMetaKey) ?? null;
-
-export const validate = (instance: object, references: TSchema[] = []): ValueError[] => {
-  const context = extractValidationMetaContext(instance.constructor);
-  return context ? [...Value.Errors(context.schema, references, instance)] : [];
-}
-
-export const UseValidation = (schema: TSchema): PropertyDecorator => (target, key) => {
-  const context = extractValidationMetaContext(target.constructor)
-    ?? buildValidationMetaContext();
-
-  context.properties.add(key);
-  context.schema = Type.Composite([context.schema, Type.Object({ [key]: schema })]);
-
-  Reflect.set(target.constructor, validationContextMetaKey, context);
-}

package/src/utils/index.spec.ts

@@ -1,31 +0,0 @@
-import { wait, buildCounter, flattenArrayed } from './index';
-
-// Test generated using Keploy
-test('wait resolves after specified duration', async () => {
-  const duration = 100;
-  const start = Date.now();
-  await wait(duration);
-  const end = Date.now();
-  expect(end - start).toBeGreaterThanOrEqual(duration);
-});
-
-// Test generated using Keploy
-test('buildCounter increments correctly with initial value', () => {
-  const counter = buildCounter(5);
-  expect(counter()).toBe(6);
-  expect(counter()).toBe(7);
-});
-
-// Test generated using Keploy
-test('flattenArrayed wraps a single array in an array', () => {
-  const singleArray = [1, 2, 3];
-  const expectedResult = [[1, 2, 3]];
-  expect(flattenArrayed<any>(singleArray)).toEqual(expectedResult);
-});
-
-// Test generated using Keploy
-test('flattenArrayed wraps a non-array in an array', () => {
-  const nonArrayInput = 42;
-  const expectedResult = [[42]];
-  expect(flattenArrayed<any>(nonArrayInput)).toEqual(expectedResult);
-});

package/src/utils/index.ts

@@ -1,51 +0,0 @@
-import type { FlattenArrays } from '../../types';
-
-export const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
-export const cast = <T>(payload: T) => payload;
-
-export const flattenArrayed = <
-  T extends unknown[][],
-  Q extends FlattenArrays<T>[] = FlattenArrays<T>[]
->(payload: T): Q => {
-  if (payload?.every?.(Array.isArray)) {
-    return <Q>payload.reduce((acc, nestedPayload) => acc.concat(flattenArrayed(<T>nestedPayload)), []);
-  }
-
-  return Array.isArray(payload)
-    ? <Q>[payload]
-    : <Q>[[payload]];
-};
-
-/**
- * @example
- * ```ts
- * const counter = buildCounter(5);
- *
- * counter() // 6
- * counter() // 7
- * counter(2) // 9
- * ```
- */
-export const buildCounter =
-  (initial = 0, step = 1) =>
-  (value = step) =>
-    (initial += value);
-
-export const serializeRegExp = (exp: RegExp): Pick<RegExp, 'source' | 'flags'> => ({
-  source: exp.source,
-  flags: exp.flags,
-});
-
-export const parseJsonSafe = <T extends Record<string, unknown>>(serializedJson: string) => {
-  try {
-    return <const>{
-      status: 'OK',
-      result: <T>JSON.parse(serializedJson),
-    };
-  } catch(error) {
-    return <const>{
-      status: 'ERROR',
-      error: error instanceof Error ? error : new Error('Unknown'),
-    };
-  }
-};

package/test/index.ts

@@ -1,299 +0,0 @@
-import { MockServer, RemoteClient, Logger, Provider } from '../src';
-import * as providers from './providers';
-
-Logger.useSerializers({
-  cvv: () => '***',
-  card: (text: string) => `xxxx${text.slice(4, 8)}xxxx`,
-});
-
-const host = 'localhost';
-const port = 13000;
-
-(async () => {
-  const server = await MockServer.start({
-    host,
-    port,
-
-    databases: {
-      redis: {
-        host: 'localhost',
-        port: 6379,
-      },
-    },
-  });
-
-  const client = await RemoteClient.connect({ baseUrl: `http://${host}:${port}` });
-  const papi = Provider.build({ group: 'papi' });
-
-  server.router
-    .register('/statics/**', {
-      provider: providers.statics,
-      transports: ['http'],
-    })
-    .register('/{generation,items}/**', {
-      provider: providers.root,
-      transports: ['http'],
-    })
-    .register('**/papi/**', {
-      provider: papi,
-    });
-
-  await client.createExpectation(({ $ }) => ({
-    transports: ['http'],
-    schema: {
-      request: $.has('path', { $value: '/foo/9349beb2-2fba-4ecd-9280-b44edbeb6b58/bar/f4261e21-cad7-412d-9726-5a8e48734855' }),
-      response: $.set('outgoing.data', { $value: { has_mocked: true } }),
-
-      forward: {
-        baseUrl: 'https://www.google.com/9349beb2-2fba-4ecd-9280-b44edbeb6b58',
-      },
-    },
-  }));
-
-  await client.createExpectation(({ $ }) => ({
-    transports: ['http'],
-    schema: {
-      request: $.has('path', { $match: '/statics/qwe' }),
-      response: $.set('outgoing.data', { $value: { has_mocked: true } }),
-    },
-  }));
-
-  await client.createExpectation<{
-    container: {
-      counter: number;
-    };
-
-    outgoing: {
-      data: object;
-    };
-  }>(({ $ }) => ({
-    transports: ['http'],
-    isEnabled: true,
-
-    schema: {
-      request: $.and([
-        $.has('incoming.headers', '$path', 'x-use-mock', { $value: 'true' }),
-        $.has('path', { $regExp: /^\/forward\/*./ }),
-
-        $.set('container', { $exec: (container, { context }) => context.storage.find('test') }),
-
-        $.exec(({ context }) => {
-          context.incoming.path = context.incoming.path.replace('/forward', '');
-          return true;
-        }),
-      ]),
-
-      response: $.and([
-        $.set('outgoing.data', {
-          $exec: (payload, { context }) => Object.assign(payload, {
-            counter: context.container?.payload.counter,
-            transport: context.transport,
-          }),
-        }),
-      ]),
-
-      forward: {
-        baseUrl: 'http://127.0.0.1:8053/v1/maintenance',
-        timeout: 2000,
-
-        cache: {
-          prefix: 'papi:location:',
-          ttl: 20,
-        },
-      },
-    },
-  }));
-
-  await server.client.createExpectation(({ $ }) => ({
-    transports: ['http'],
-    schema: {
-      request: $.and([
-        $.has('path', { $match: '**/papi/**' }),
-      ]),
-      response: $.and([
-        $.set('outgoing.dataRaw', { $exec: () => Buffer.from('Mocked') }),
-      ]),
-    },
-  }));
-
-  await papi.client.createExpectation<{
-    incoming: {
-      query: {
-        foo: 'a' | 'b' | 'c';
-        bar?: string;
-      };
-    };
-
-    outgoing: {
-      data: {
-        timestamp: number;
-        data: {
-          version: string;
-          options: {
-            use_test_mode_by_default: boolean;
-            has_mocked_by?: string;
-          };
-        };
-      };
-    };
-  }>(({ $ }) => ({
-    schema: {
-      request: $.and([
-        $.has('path', { $match: '**/papi/forward/**' }),
-        $.exec(({ context }) => context.incoming.headers['content-type'] === 'application/json'),
-        // $.set('delay', { $value: 5000 }),
-      ]),
-
-      response: $.and([
-        // $.set('cache', '$path', 'isEnabled', { $value: true }),
-
-        $.merge('outgoing.data', '$path', 'data', {
-          $exec: (payload, {}) => ({ foo: 123, host, version: payload.version + '1' }),
-        }),
-
-        $.if({
-          $condition: $.has('incoming.query', '$path', 'foo', { $value: 'a' }),
-          $then: $.merge('outgoing.data', '$path', 'data', { $value: { options: { has_mocked_by: 'John Cena' } } }),
-        }),
-
-        $.if({
-          $condition: $.has('incoming.query', '$path', 'foo', { $value: 'b' }),
-          $then: $.and([
-            $.remove('outgoing.data', {}),
-            $.set('outgoing.dataRaw', { $exec: () => Buffer.from('["What the f*ck"]') }),
-          ]),
-        }),
-      ]),
-
-      forward: {
-        url: 'http://localhost:17188/_papi/v1/maintenance/stats',
-
-        cache: {
-          prefix: 'papi:',
-          ttl: 300,
-        },
-      },
-    },
-  }));
-
-  await server.client.createExpectation<{
-    incoming: {
-      data: number;
-    };
-
-    outgoing: {
-      data: { counter: number };
-    };
-  }>(({ $ }) => ({
-    transports: ['ws'],
-    schema: {
-      request: $.and([
-        $.has('event', { $value: 'message' }),
-        $.has('path', { $value: '/messages' }),
-        $.if({
-          $condition: $.has('incoming.data', { $value: 5 }),
-          $then: $.and([
-            $.merge('flags', { $value: { wsCloseConnection: true } }),
-            $.set('outgoing.status', { $value: 1001 }),
-          ]),
-          $else: $.exec(() => true),
-        }),
-      ]),
-
-      response: $.and([
-        $.if({
-          $condition: $.has('incoming.data', { $value: 6 }),
-          $then: $.and([
-            $.merge('flags', { $value: { wsCloseConnection: true } }),
-            $.set('outgoing.status', { $value: 1002 }),
-          ]),
-          $else: $.exec(() => true),
-        }),
-        $.set('outgoing.stream', {
-          $exec: (payload, { rx, context }) =>
-            rx.merge(
-              rx.from([{ counter: context.incoming.data }, { counter: context.incoming.data + 1 }]),
-              rx.from([{ counter: context.incoming.data + 2 }]).pipe(rx.delay(1000)),
-              rx.from([{ counter: context.incoming.data + 3 }]).pipe(rx.delay(2000)),
-              rx.from([{ counter: context.incoming.data + 4 }]).pipe(rx.delay(3000)),
-            ),
-        }),
-      ]),
-    },
-  }));
-
-  await server.client.createExpectation<{
-    incoming: {
-      data: number;
-    };
-
-    outgoing: {
-      data: { counter: number };
-    };
-  }>(({ $ }) => ({
-    transports: ['ws'],
-    schema: {
-      request: $.and([
-        $.has('event', { $value: 'connection' }),
-        $.has('path', { $value: '/connection' }),
-      ]),
-
-      response: $.and([
-        $.set('outgoing.stream', {
-          $exec: (payload, { context, rx }) =>
-            rx.merge<typeof context['outgoing']['data'][]>(
-              rx.from([{ counter: 1 }, { counter: 2 }]),
-              rx.from([{ counter: 3 }]).pipe(rx.delay(1000)),
-              rx.from([{ counter: 4 }]).pipe(rx.delay(2000)),
-              rx.from([{ counter: 5 }]).pipe(rx.delay(3000)),
-            )
-        }),
-      ]),
-    },
-  }));
-
-  await server.client.createExpectation<{
-    incoming: {
-      data: number;
-    };
-
-    outgoing: {
-      data: number | string;
-    };
-  }>(({ $ }) => ({
-    transports: ['ws'],
-    schema: {
-      request: $.and([
-        $.has('event', { $value: 'connection' }),
-        $.has('path', { $value: '/mixed' }),
-      ]),
-
-      response: $.and([
-        $.set('outgoing.stream', {
-          $exec: (payload, { context, rx }) => {
-            const subject = new rx.ReplaySubject<typeof context['outgoing']['data']>();
-
-            subject.next('It multuplies value by 2');
-            subject.next('Type any number here...');
-
-            context.incoming.stream!
-              .pipe(
-                rx.tap((data) => {
-                  if (data === 5) {
-                    context.outgoing.status = 1011;
-
-                    subject.next('Ooops');
-                    subject.complete();
-                  }
-                }),
-                rx.map((data) => data ** 2),
-              )
-              .subscribe(subject);
-
-            return subject.asObservable();
-          },
-        }),
-      ]),
-    },
-  }));
-})();

package/test/providers/index.ts

@@ -1,2 +0,0 @@
-export { default as statics } from './statics';
-export { default as root } from './root';

package/test/providers/root.ts

@@ -1,241 +0,0 @@
-import { Provider } from '../../src';
-
-const provider = Provider.build({ group: 'root' });
-
-(async () => {
-  await provider.client.createExpectation(({ $ }) => ({
-    isEnabled: true,
-    transports: ['http'],
-    schema: {
-      request: $.and([
-        $.has('method', { $value: 'GET' }),
-        $.has('path', { $value: '/items/1' }),
-      ]),
-      response: $.and([
-        $.set('outgoing.headers', { $value: { 'content-type': 'application/json' } }),
-
-        $.set('container', {
-          $exec: (payload, { context }) => context.storage.register({
-            key: `im:order:123123`,
-            payload: {
-              orderId: 123123,
-              ticketIds: {
-                567567: 123123,
-              },
-              orderItemIds: {
-                123123: 45645456,
-              },
-            },
-          }),
-        }),
-
-        $.set('container', {
-          $exec: (payload, { context }) => context.storage.find(`im:order:123123`)?.bind('im:ticket:123123123'),
-        }),
-
-        $.exec(({ context }) => {
-          if (context.incoming.path === '/items/1') {
-            if (context.outgoing) {
-              context.outgoing.status = 204;
-            }
-          }
-        }),
-      ]),
-    },
-  }));
-
-  await provider.client.createExpectation<{
-    incoming: {
-      query: {
-        foo: 'a' | 'b' | 'c';
-        bar?: string;
-      };
-    };
-
-    outgoing: {
-      data: {
-        foo: number;
-        bar: {
-          baz: 'a' | 'b' | 'c';
-        };
-      };
-    };
-  }>(({ $ }) => ({
-    transports: ['http'],
-    schema: {
-      request: $.and([
-        $.has('method', { $value: 'GET' }),
-        $.has('path', { $match: '/generat*on/foo' }),
-        $.has('incoming.query', '$path', 'foo', { $valueAnyOf: ['a', 'b', 'c'] }),
-        $.exec(({ context }) => context.incoming.headers['content-type'] === 'application/json'),
-      ]),
-
-      response: $.and([
-        $.set('outgoing.data', { $value: {} }),
-        $.switch('incoming.query', '$path', 'foo', {
-          $cases: {
-            'a': $.and([
-              $.set('outgoing.status', { $value: 201 }),
-              $.set('outgoing.data', '$path', 'bar.baz', { $value: 'a' }),
-            ]),
-
-            'b': $.merge('outgoing.data', '$path', 'bar', { $value: { baz: 'b' } }),
-          },
-
-          $default: $.and([
-            $.set('outgoing.status', { $value: 400 }),
-            $.set('outgoing.data', '$path', 'bar.baz', { $value: 'c' }),
-          ]),
-        }),
-
-        $.exec(({ context, logger }) => {
-          context.outgoing!.headers['x-mock-entity'] = String(Date.now());
-
-          logger.info('Payment data', { cvv: '123', card: '123412341234' });
-
-          switch(context.incoming.query.foo) {
-            case 'a': return context.outgoing.data.foo = 100;
-            case 'b': return context.outgoing.data.foo = 200;
-            case 'c': return context.outgoing.data.foo = 300;
-          }
-        }),
-      ]),
-    },
-  }));
-
-  await provider.client.createExpectation<{
-    incoming: {
-      query: {
-        foo: 'a' | 'b' | 'c';
-        bar?: string;
-      };
-    };
-
-    outgoing: {
-      data: object;
-    };
-  }>(({ $ }) => ({
-    schema: {
-      request: $.and([
-        $.has('path', { $matchAnyOf: ['/gen*ration/bar'] }),
-        $.exec(({ context }) => context.incoming.headers['content-type'] === 'application/xml'),
-      ]),
-
-      response: $.and([
-        $.set('outgoing.headers', '$path', 'content-type', { $value: 'application/xml' }),
-        $.set('outgoing.data', {
-          $value: {
-            tag: {
-              nested: {
-                '#text': 100,
-                '@_type': 'mocked'
-              }
-            },
-          },
-        }),
-
-        $.exec(({ context, logger, meta }) => {
-          logger.info(meta.requestId, context.incoming.data);
-          return true;
-        }),
-
-        $.if({
-          $condition: $.not($.has('incoming.query', '$path', 'foo', { $value: 'a' })),
-
-          $then: $.and([
-            $.set('outgoing.status', { $value: 201 }),
-            $.set('outgoing.data', {
-              $value: {
-                tag: {
-                  nested: {
-                    '#text': 200,
-                    '@_type': 'mocked'
-                  }
-                },
-              },
-            }),
-          ]),
-        }),
-      ]),
-    },
-  }));
-
-  await provider.client.createExpectation<{
-    incoming: {
-      data: {
-        foo: {
-          baz?: 1 | 2 | 3;
-          bar: {
-            baz: 'a' | 'b' | 'c';
-          };
-        };
-      };
-    };
-  }>(({ $ }) => ({
-    schema: {
-      request: $.and([
-        $.has('method', { $value: 'POST' }),
-        $.has('path', { $valueAnyOf: ['/generation/deep-matching'] }),
-
-        $.or([
-          $.has('incoming.data', { $match: { foo: { bar: {} } } }),
-          $.has('incoming.data', { $match: { foo: { baz: 1 } } }),
-        ]),
-      ]),
-
-      response: $.and([
-        $.set('outgoing.status', { $value: 201 }),
-        $.set('outgoing.data', { $value: ['How match is the fish?'] }),
-
-        $.if({
-          $condition: $.has('incoming.data', '$path', 'foo.bar.baz', { $value: 'a' }),
-          $then: $.set('outgoing.data', { $value: ['Matched'] }),
-        }),
-      ]),
-    },
-  }));
-
-  await provider.client.createExpectation<{
-    container: {
-      counter: number;
-      items: string[];
-    };
-
-    state: {
-      foo?: number;
-      bar?: 2;
-    };
-  }>(({ $ }) => ({
-    schema: {
-      request: $.and([
-        $.has('path', { $value: '/generation/faker' }),
-        $.set('seed', { $exec: (seed, { context, T }) => T(seed ?? context.incoming.query?.foo ?? context.state.foo) }),
-
-        $.set('container', {
-          $exec: (container, { context }) => context.storage.provide({ ttl: 20, key: 'test', payload: { counter: 0, items: [] } })
-        }),
-      ]),
-
-      response: $.and([
-        $.exec(({ context }) => {
-          context.container!.payload.items.push(new Date().toISOString());
-        }),
-        $.set('outgoing.data', {
-          $exec: (payload, { context, faker }) => ({
-            counter: context.container!.payload.counter,
-            items: context.container!.payload.items,
-
-            id: faker.number.int({ max: 1000, min: 500 }),
-            first_name: faker.person.firstName('male'),
-            last_name: faker.person.lastName('male'),
-
-            uids: [faker.string.uuid(), faker.string.uuid()],
-            ids: [faker.number.int({ max: 1000, min: 500 }), faker.number.int({ max: 1000, min: 500 })],
-          }),
-        }),
-      ]),
-    },
-  }));
-})();
-
-export default provider;

package/test/providers/statics.ts

@@ -1,37 +0,0 @@
-import { Provider } from '../../src';
-
-const provider = Provider.build({ group: 'statics' });
-
-(async () => {
-  await provider.client.createExpectation(({ $ }) => ({
-    schema: {
-      request: $.has('path', { $value: '/statics/foo' }),
-      response: $.and([
-        $.set('outgoing.status', { $value: 200 }),
-        $.set('outgoing.data', {
-          $exec: () => ({
-            foo: true,
-          }),
-        }),
-      ]),
-    },
-  }));
-
-  await provider.client.createExpectation(({ $ }) => ({
-    transports: ['http'],
-    schema: {
-      request: $.has('path', { $value: '/statics/bar' }),
-      response: $.and([
-        $.set('outgoing.status', { $value: 200 }),
-        $.set('outgoing.data', {
-          $exec: (payload, { context }) => ({
-            bar: true,
-            transport: context.transport,
-          }),
-        }),
-      ]),
-    },
-  }));
-})();
-
-export default provider;