@n1k1t/mock-server 0.1.61 → 0.1.62

package/src/client/models/client.spec.ts

@@ -1,316 +0,0 @@
-import { prepareExpectationBodyToRequest } from '../utils';
-import { Expectation } from '../../expectations';
-import { Client } from './client';
-
-
-interface IExpectationContext {
-  incoming: {
-    query: {
-      foo?: 'a' | 'b' | 'c';
-      bar: 'a' | 'b' | 'c';
-    }
-
-    body: {
-      foo: 'a' | 'b' | 'c';
-      bar?: ('a' | 'b' | 'c')[];
-
-      baz: {
-        foo: 1 | 2 | 3;
-        bar?: 1 | 2 | 3;
-        baz?: (1 | 2 | 3)[];
-      };
-    };
-  };
-}
-
-const buildClient = () => new Client({
-  ping: () => Promise.resolve('pong'),
-  deleteExpectations: () => Promise.resolve(null),
-
-  createExpectation: (configuration) => Promise.resolve(
-    prepareExpectationBodyToRequest(
-      Object.assign(Expectation.build(configuration).toPlain(), {
-        id: '12426262-85a3-4340-969b-272e003722e9',
-        name: 'MaliciousCobra',
-      })
-    )
-  ),
-
-  updateExpectation: ({ id, set }) => Promise.resolve(
-    prepareExpectationBodyToRequest(
-      Object.assign(Expectation.build({ ...set, schema: set.schema ?? {} }).toPlain(), { id })
-    )
-  ),
-
-  updateExpectationsGroup: () => Promise.resolve([]),
-});
-
-describe('Client.Models.Client', () => {
-  it('should create expectation with complex schema as object', async () => {
-    const client = buildClient();
-
-    await expect(
-      client.createExpectation({
-        schema: {
-          request: {
-            $and: [
-              { $has: { $location: 'path', $value: '/foo' } },
-              { $has: { $location: 'path', $valueAnyOf: ['/foo', '/foo/bar'] } },
-              { $has: { $location: 'path', $match: '/foo/*' } },
-              { $has: { $location: 'path', $matchAnyOf: ['/foo/*', '*/bar'] } },
-              { $has: { $location: 'path', $regExp: /^\/foo/ } },
-              { $has: { $location: 'path', $regExpAnyOf: [/^\/foo$/, /^\/foo\/bar$/] } },
-              { $has: { $location: 'path', $exec: (payload) => payload.includes('/foo') } },
-
-              { $has: { $location: 'path', $path: '/foo', $value: '/foo' } },
-              { $has: { $location: 'path', $path: '/foo', $valueAnyOf: ['/foo', '/foo/bar'] } },
-              { $has: { $location: 'path', $path: '/foo', $match: '/foo/*' } },
-              { $has: { $location: 'path', $path: '/foo', $matchAnyOf: ['/foo/*', '*/bar'] } },
-              { $has: { $location: 'path', $path: '/foo', $regExp: /^\/foo/ } },
-              { $has: { $location: 'path', $path: '/foo', $regExpAnyOf: [/^\/foo$/, /^\/foo\/bar$/] } },
-              { $has: { $location: 'path', $path: '/foo', $exec: (payload) => payload.includes('/foo') } },
-
-              { $has: { $location: 'incoming.query' } },
-
-              { $has: { $location: 'incoming.query', $value: { foo: 'a' } } },
-              { $has: { $location: 'incoming.query', $valueAnyOf: [{ foo: 'a' }, { foo: 'b' }] } },
-              { $has: { $location: 'incoming.query', $match: { foo: 'a' } } },
-              { $has: { $location: 'incoming.query', $matchAnyOf: [{ foo: 'a' }, { foo: 'b' }] } },
-              { $has: { $location: 'incoming.query', $exec: (payload) => payload?.foo === 'a' } },
-
-              { $has: { $location: 'incoming.query', $path: 'foo', $value: 'a' } },
-              { $has: { $location: 'incoming.query', $path: 'foo', $valueAnyOf: ['a', 'b'] } },
-              { $has: { $location: 'incoming.query', $path: 'foo', $match: 'a' } },
-              { $has: { $location: 'incoming.query', $path: 'foo', $matchAnyOf: ['a', 'b'] } },
-              { $has: { $location: 'incoming.query', $path: 'foo', $regExp: /a|b/ } },
-              { $has: { $location: 'incoming.query', $path: 'foo', $regExpAnyOf: [/a/i, /b/i] } },
-              { $has: { $location: 'incoming.query', $path: 'foo', $exec: (payload) => payload === 'a' } },
-
-              { $has: { $location: 'incoming.data' } },
-
-              { $has: { $location: 'incoming.data', $value: { foo: 'a', bar: ['a'] } } },
-              { $has: { $location: 'incoming.data', $valueAnyOf: [{ foo: 'a', bar: ['a'] }, { bar: ['b'] }, { baz: {} }] } },
-              { $has: { $location: 'incoming.data', $match: { foo: 'a', baz: { foo: 1 } } } },
-              { $has: { $location: 'incoming.data', $matchAnyOf: [{ baz: {} }, { bar: [] }] } },
-              { $has: { $location: 'incoming.data', $exec: (payload) => payload?.baz?.foo === 1 } },
-
-              { $has: { $location: 'incoming.data', $path: 'baz', $value: { foo: 1, bar: 1 } } },
-              { $has: { $location: 'incoming.data', $path: 'baz', $valueAnyOf: [{ foo: 1 }, { bar: 1 }] } },
-              { $has: { $location: 'incoming.data', $path: 'baz', $match: { foo: 1 } } },
-              { $has: { $location: 'incoming.data', $path: 'baz', $matchAnyOf: [{}, { foo: '1' }] } },
-              { $has: { $location: 'incoming.data', $path: 'baz', $exec: (payload) => payload?.foo === 1 } },
-
-              { $has: { $location: 'incoming.data', $path: 'baz.baz', $value: [1] } },
-              { $has: { $location: 'incoming.data', $path: 'baz.baz', $valueAnyOf: [[1], [1, 2]] } },
-              { $has: { $location: 'incoming.data', $path: 'baz.baz', $match: '*' } },
-              { $has: { $location: 'incoming.data', $path: 'baz.baz', $matchAnyOf: ['1', '2'] } },
-              { $has: { $location: 'incoming.data', $path: 'baz.baz', $regExp: /1/ } },
-              { $has: { $location: 'incoming.data', $path: 'baz.baz', $regExpAnyOf: [/1/, /2/] } },
-              { $has: { $location: 'incoming.data', $path: 'baz.baz', $exec: (payload) => payload === 1 } },
-            ],
-          },
-
-          response: {
-            $or: [
-              {
-                $switch: {
-                  $location: 'outgoing.status',
-                  $cases: {
-                    200: {
-                      $and: [
-                        { $set: { $location: 'outgoing.data', $value: {} } },
-                        { $set: { $location: 'outgoing.data', $path: 'foo', $value: 'a' } },
-
-                        { $set: { $location: 'outgoing.headers', $exec: () => ({}) } },
-                        { $set: { $location: 'outgoing.headers', $path: 'foo', $value: 'bar' } },
-                      ],
-                    },
-                  },
-
-                  $default: { $set: { $location: 'outgoing.data', $value: {} } },
-                },
-              },
-              {
-                $switch: {
-                  $location: 'outgoing.data',
-                  $path: 'baz.bar',
-
-                  $cases: {
-                    1: {
-                      $and: [
-                        { $merge: { $location: 'outgoing.data', $value: {} } },
-                        { $remove: { $location: 'outgoing.data', $path: 'foo' } },
-                      ],
-                    },
-                  },
-                },
-              },
-              {
-                $switch: {
-                  $location: 'outgoing.headers',
-                  $exec: (payload) => payload.foo,
-
-                  $cases: {
-                    'a': {
-                      $and: [{
-                        $exec: ({ context }) => {
-                          if (context.incoming.data?.foo === 'a') {
-                            context.outgoing!.status = 200;
-                          }
-                        },
-                      }],
-                    },
-                  },
-                },
-              },
-            ],
-          },
-        },
-      })
-    ).resolves.toMatchSnapshot();
-  });
-
-  it('should create expectation with complex schema as function', async () => {
-    const client = buildClient();
-
-    await expect(
-      client.createExpectation<IExpectationContext>(({ $ }) => ({
-        schema: {
-          request: $.and([
-            $.has('path', { $value: '/foo' }),
-            $.has('path', { $valueAnyOf: ['/foo', '/foo/bar'] }),
-            $.has('path', { $match: '/foo/*' }),
-            $.has('path', { $matchAnyOf: ['/foo/*', '*/bar'] }),
-            $.has('path', { $regExp: /^\/foo/ }),
-            $.has('path', { $regExpAnyOf: [/^\/foo$/, /^\/foo\/bar$/] }),
-            $.has('path', { $exec: (payload) => payload.includes('/foo') }),
-
-            $.has('path', '$path', '/foo', { $value: '/foo' }),
-            $.has('path', '$path', '/foo', { $valueAnyOf: ['/foo', '/foo/bar'] }),
-            $.has('path', '$path', '/foo', { $match: '/foo/*' }),
-            $.has('path', '$path', '/foo', { $matchAnyOf: ['/foo/*', '*/bar'] }),
-            $.has('path', '$path', '/foo', { $regExp: /^\/foo/ }),
-            $.has('path', '$path', '/foo', { $regExpAnyOf: [/^\/foo$/, /^\/foo\/bar$/] }),
-            $.has('path', '$path', '/foo', { $exec: (payload) => payload.includes('/foo') }),
-
-            $.has('incoming.query', {}),
-            $.has('incoming.query', '$path', 'foo'),
-
-            $.has('incoming.query', { $value: { foo: 'a', bar: 'a' } }),
-            $.has('incoming.query', { $valueAnyOf: [{ foo: 'a', bar: 'a' }, { foo: 'b', bar: 'b' }] }),
-            $.has('incoming.query', { $match: { foo: 'a' } }),
-            $.has('incoming.query', { $matchAnyOf: [{ foo: 'a' }, { foo: 'b' }] }),
-            $.has('incoming.query', { $exec: (payload) => payload?.foo === 'a' }),
-
-            $.has('incoming.query', '$path', 'foo', { $value: 'a' }),
-            $.has('incoming.query', '$path', 'foo', { $valueAnyOf: ['a', 'b'] }),
-            $.has('incoming.query', '$path', 'foo', { $match: 'a' }),
-            $.has('incoming.query', '$path', 'foo', { $matchAnyOf: ['a', 'b'] }),
-            $.has('incoming.query', '$path', 'foo', { $regExp: /a|b/ }),
-            $.has('incoming.query', '$path', 'foo', { $regExpAnyOf: [/a/i, /b/i] }),
-            $.has('incoming.query', '$path', 'foo', { $exec: (payload) => payload === 'a' }),
-
-            $.has('incoming.data', {}),
-
-            $.has('incoming.data', { $value: { foo: 'a', bar: ['a'] } }),
-            $.has('incoming.data', { $valueAnyOf: [{ foo: 'a', bar: ['a'] }, { bar: ['b'] }, { baz: {} }] }),
-            $.has('incoming.data', { $match: { foo: 'a', baz: { foo: 1 } } }),
-            $.has('incoming.data', { $matchAnyOf: [{ baz: {} }, { bar: [] }] }),
-            $.has('incoming.data', { $exec: (payload) => payload?.baz?.foo === 1 }),
-
-            $.has('incoming.data', '$path', 'baz', { $value: { foo: 1, bar: 1 } }),
-            $.has('incoming.data', '$path', 'baz', { $valueAnyOf: [{ foo: 1 }, { foo: 1, bar: 1 }] }),
-            $.has('incoming.data', '$path', 'baz', { $match: { foo: 1 } }),
-            $.has('incoming.data', '$path', 'baz', { $matchAnyOf: [{}, { foo: 1 }] }),
-            $.has('incoming.data', '$path', 'baz', { $exec: (payload) => payload?.foo === 1 }),
-
-            $.has('incoming.data', '$jsonPath', '123.123.213', {
-              $match: {},
-            }),
-
-            $.has('incoming.data', '$path', 'baz.baz', { $value: [1] }),
-            $.has('incoming.data', '$path', 'baz.baz', { $valueAnyOf: [[1], [1, 2]] }),
-            $.has('incoming.data', '$path', 'baz.baz.0', { $match: '*' }),
-            $.has('incoming.data', '$path', 'baz.baz.0', { $matchAnyOf: ['1', '2'] }),
-            $.has('incoming.data', '$path', 'baz.baz', { $regExp: /1/ }),
-            $.has('incoming.data', '$path', 'baz.baz', { $regExpAnyOf: [/1/, /2/] }),
-            $.has('incoming.data', '$path', 'baz.baz', { $exec: (payload) => payload?.[0] === 1 }),
-
-            $.switch('incoming.query', '$path', 'foo', {
-              $cases: {
-                'a': $.and([])
-              },
-            }),
-          ]),
-
-          response: $.or([
-            $.switch('outgoing.status', {
-              $cases: {
-                200: $.and([
-                  $.set('outgoing.data', { $value: {} }),
-                  $.set('outgoing.data', '$path', 'foo', { $value: 'a' }),
-                  $.set('outgoing.headers', { $exec: () => ({}) }),
-                  $.set('outgoing.headers', '$path', 'foo', { $value: 'bar' }),
-                ]),
-              },
-
-              $default: $.set('outgoing.data', { $value: {} }),
-            }),
-
-            $.switch('incoming.data', '$path', 'baz.bar', {
-              $cases: {
-                1: $.and([
-                  $.merge('outgoing.data', { $value: {} }),
-                  $.remove('outgoing.data', '$path', 'foo'),
-                ]),
-              },
-            }),
-
-            $.switch('incoming.data', '$exec', (payload) => payload.baz.bar, {
-              $cases: {
-                1: $.and([]),
-              },
-            }),
-
-            $.switch('outgoing.headers', '$exec', (payload) => payload.foo, {
-              $cases: {
-                'a': $.and([
-                  $.exec(({ context }) => {
-                    if (context.incoming.data.foo === 'a') {
-                      context.outgoing!.status = 200;
-                    }
-                  }),
-                ]),
-              },
-            }),
-          ]),
-        },
-      }))
-    ).resolves.toMatchSnapshot();
-  });
-});
-
-// Test generated using Keploy
-it('should return pong on ping method', async () => {
-    const client = buildClient();
-    await expect(client.ping()).resolves.toEqual('pong');
-  });
-
-
-// Test generated using Keploy
-it('should return null on deleteExpectations method', async () => {
-    const client = buildClient();
-    await expect(client.deleteExpectations()).resolves.toBeNull();
-  });
-
-
-// Test generated using Keploy
-it('should update expectation with function predicate', async () => {
-    const client = buildClient();
-    const result = await client.updateExpectation((context) => ({
-      id: 'some-id',
-      set: { schema: {} },
-    }));
-    expect(result).toHaveProperty('id');
-  });
-

package/src/client/models/client.ts

@@ -1,85 +0,0 @@
-import type { Expectation, IExpectationSchemaInput } from '../../expectations';
-import type { IServerContext } from '../../server';
-import type { TMethodsSchema } from '../types';
-import type { TFunction } from '../../../types';
-
-import { compileExpectationOperators, ICompiledExpectationOperators } from '../helpers';
-
-interface IExpectationHandlerContext<
-  TContext extends IServerContext<any>,
-  TInput extends IExpectationSchemaInput
-> {
-  $: ICompiledExpectationOperators<TInput & TContext>;
-  T: <T>(payload: T) => T extends TFunction<any, any[]> ? TFunction<any, any[]> : T;
-};
-
-interface IAnyExpectationInput<TContext extends IServerContext<any>> {
-  transport: TContext['transport'];
-  state: any;
-
-  incoming: {
-    headers: any;
-    query: any;
-    data: any;
-  };
-
-  outgoing: {
-    headers: any;
-    data: any;
-  };
-};
-
-type TExpectationAnyConfiguration<TContext extends IServerContext<any>> =
-  & Omit<Expectation<TContext>['configuration'], 'schema'>
-  & Pick<Expectation<any, any>['configuration'], 'schema'>;
-
-export class Client<TContext extends IServerContext<any>> {
-  constructor(protected methods: TMethodsSchema) {}
-
-  public get ping() {
-    return this.methods.ping;
-  }
-
-  public get deleteExpectations() {
-    return this.methods.deleteExpectations;
-  }
-
-  public createExpectation<TInput extends IExpectationSchemaInput>(
-    handler: TFunction<TExpectationAnyConfiguration<TContext>, [IExpectationHandlerContext<TContext, TInput>]>
-  ): ReturnType<TMethodsSchema['createExpectation']>;
-
-  public createExpectation(
-    configuration: Expectation<IAnyExpectationInput<TContext>>['configuration']
-  ): ReturnType<TMethodsSchema['createExpectation']>;
-
-  public createExpectation(predicate: unknown): ReturnType<TMethodsSchema['createExpectation']> {
-    return typeof predicate === 'function'
-      ? this.methods.createExpectation(predicate(this.compileHandlerUtils()))
-      : this.methods.createExpectation(<Expectation<IAnyExpectationInput<TContext>>['configuration']>predicate);
-  }
-
-  public updateExpectation(
-    configuration: { id: string, set: Partial<Expectation<IAnyExpectationInput<TContext>>['configuration']> }
-  ): ReturnType<TMethodsSchema['updateExpectation']>;
-
-  public updateExpectation<TInput extends IExpectationSchemaInput>(
-    handler: TFunction<{ id: string, set: Partial<TExpectationAnyConfiguration<TContext>> }, [
-      IExpectationHandlerContext<TContext, TInput>
-    ]>
-  ): ReturnType<TMethodsSchema['updateExpectation']>
-
-  public updateExpectation(predicate: unknown): ReturnType<TMethodsSchema['updateExpectation']> {
-    return typeof predicate === 'function'
-      ? this.methods.updateExpectation(predicate(this.compileHandlerUtils()))
-      : this.methods.updateExpectation(<{ id: string, set: Partial<TExpectationAnyConfiguration<TContext>> }>predicate);
-  }
-
-  private compileHandlerUtils<
-    TInput extends IExpectationSchemaInput
-  >(): IExpectationHandlerContext<TContext, TInput> {
-    return {
-      $: compileExpectationOperators(),
-      T: (payload: any) => payload,
-    }
-  }
-}

package/src/client/models/index.ts

@@ -1,2 +0,0 @@
-export * from './method';
-export * from './client';

package/src/client/models/method.ts

@@ -1,50 +0,0 @@
-import type { AxiosInstance } from 'axios';
-
-import type { SetPartialKeys, TFunction } from '../../../types';
-import type { Provider } from '../../server/models';
-
-import { cast } from '../../utils';
-
-type THandler<TContext, TSchema extends IClientMethodSchema> = TFunction<
-  TFunction<Promise<TSchema['outgoing']>, [TSchema['incoming']]>,
-  [TContext]
->;
-
-export interface IClientMethodSchema {
-  incoming?: unknown;
-  outgoing?: unknown;
-};
-
-export interface IClientMethodHandlers<TSchema extends IClientMethodSchema> {
-  remote: THandler<AxiosInstance, TSchema>;
-  onsite: THandler<SetPartialKeys<Provider, 'server'>, TSchema>;
-}
-
-export class ClientMethod<TSchema extends IClientMethodSchema> {
-  public TSchema!: TSchema;
-
-  private handlers = cast<IClientMethodHandlers<TSchema>>({
-    remote: () => () => Promise.reject(new Error('Not implemented')),
-    onsite: () => () => Promise.reject(new Error('Not implemented')),
-  });
-
-  public register<K extends keyof IClientMethodHandlers<any>>(
-    type: K,
-    handler: IClientMethodHandlers<TSchema>[K]
-  ) {
-    this.handlers[type] = handler;
-    return this;
-  }
-
-  public compile<K extends keyof IClientMethodHandlers<any>>(
-    type: K,
-    context: Parameters<IClientMethodHandlers<TSchema>[K]>[0]
-  ) {
-    const handler: THandler<any, any> = this.handlers[type];
-    return handler(context);
-  }
-
-  static build<TSchema extends IClientMethodSchema>() {
-    return new ClientMethod<TSchema>();
-  }
-}

package/src/client/onsite.spec.ts

@@ -1,23 +0,0 @@
-import { OnsiteClient } from './onsite';
-
-// Test generated using Keploy
-test('updateExpectationsGroup(validInput) should return array of expectations', async () => {
-  const provider = {}; // Mock provider
-  const client = new OnsiteClient(<any>provider);
-  const mockExpectationsResponse = [{ id: 1, name: 'Expectation 1' }];
-  client['methods'] = <any>{
-    updateExpectationsGroup: jest.fn().mockResolvedValue(mockExpectationsResponse),
-  };
-
-  const body = { set: [{ someKey: 'someValue' }] };
-  const result = await client.updateExpectationsGroup(<any>body);
-  expect(result).toEqual(mockExpectationsResponse);
-  expect(client['methods'].updateExpectationsGroup).toHaveBeenCalledWith({ set: body });
-});
-
-// Test generated using Keploy
-test('build(provider) should return an instance of OnsiteClient', () => {
-  const provider = {}; // Mock provider
-  const clientInstance = OnsiteClient.build(<any>provider);
-  expect(clientInstance).toBeInstanceOf(OnsiteClient);
-});

package/src/client/onsite.ts

@@ -1,29 +0,0 @@
-import _ from 'lodash';
-
-import type { Provider, IServerContext, TDefaultServerContext } from '../server';
-import type { TEndpoints, TMethodsSchema } from './types';
-import type { Expectation } from '../expectations';
-
-import { Client } from './models';
-
-import * as methods from './methods';
-
-export class OnsiteClient<TContext extends IServerContext<any> = TDefaultServerContext> extends Client<TContext> {
-  constructor(provider: Provider<any>) {
-    super(
-      Object
-        .entries(methods)
-        .reduce((acc, [name, method]) => _.set(acc, name, method.compile('onsite', provider)), <TMethodsSchema>{})
-    );
-  }
-
-  public async updateExpectationsGroup(
-    body: NonNullable<TEndpoints['expectationsGroupUpdate']['incoming']['data']>['set']
-  ): Promise<Expectation['TPlain'][]> {
-    return this.methods.updateExpectationsGroup({ set: body });
-  }
-
-  static build<TContext extends IServerContext<any> = TDefaultServerContext>(provider: Provider<any>) {
-    return new OnsiteClient<TContext>(provider);
-  }
-}

package/src/client/remote.spec.ts

@@ -1,15 +0,0 @@
-import { RemoteClient } from './remote';
-
-// Test generated using Keploy
-it('should initialize the axios instance with correct baseURL and timeout', () => {
-  const options = { baseUrl: 'http://localhost', timeout: 5000 };
-  const client = new RemoteClient(options);
-  expect(client['options'].baseUrl).toEqual('http://localhost');
-  expect(client['options'].timeout).toEqual(5000);
-});
-
-// Test generated using Keploy
-it('should throw an error when pinging fails', async () => {
-  const options = { baseUrl: 'http://invalidurl', timeout: 5000 };
-  await expect(RemoteClient.connect(options)).rejects.toThrow();
-});

package/src/client/remote.ts

@@ -1,34 +0,0 @@
-import axios from 'axios';
-import _ from 'lodash';
-
-import { IRemoteClientConnectOptions, TMethodsSchema } from './types';
-import { IServerContext, TDefaultServerContext } from '../server/types';
-import { Client } from './models';
-
-import * as methods from './methods';
-
-export class RemoteClient<TContext extends IServerContext<any> = TDefaultServerContext> extends Client<TContext> {
-  get updateExpectationsGroup() {
-    return this.methods.updateExpectationsGroup;
-  }
-
-  constructor(public options: IRemoteClientConnectOptions) {
-    const instance = axios.create({
-      baseURL: options.baseUrl,
-      timeout: options.timeout ?? 1000 * 10,
-    });
-
-    super(
-      Object
-        .entries(methods)
-        .reduce((acc, [name, method]) => _.set(acc, name, method.compile('remote', instance)), <TMethodsSchema>{})
-    );
-  }
-
-  static async connect<TContext extends IServerContext<any> = TDefaultServerContext>(options: IRemoteClientConnectOptions) {
-    const client = new RemoteClient<TContext>(options);
-
-    await client.ping();
-    return client;
-  }
-}

package/src/client/types.ts

@@ -1,31 +0,0 @@
-import type { TFunction } from '../../types';
-import type config from '../config';
-
-import type * as endpoints from '../server/endpoints';
-import type * as methods from './methods';
-
-export interface IRemoteClientConnectOptions {
-  baseUrl?: string;
-  timeout?: number;
-}
-
-export type TMethodsSchema = {
-  [K in keyof typeof methods]: TFunction<
-    Promise<typeof methods[K]['TSchema']['outgoing']>, [typeof methods[K]['TSchema']['incoming']]
-  >;
-};
-
-export type TEndpoints = {
-  [K in keyof typeof endpoints]: {
-    http: (typeof endpoints)[K]['http'];
-    io: (typeof endpoints)[K]['io'];
-
-    incoming: (typeof endpoints)[K]['TSchema']['incoming'];
-    outgoing: (typeof endpoints)[K]['TSchema']['outgoing'];
-
-    location: {
-      url: `${typeof config['storage']['routes']['internal']['root']}${(typeof endpoints)[K]['http']['path']}`;
-      method: (typeof endpoints)[K]['http']['method'];
-    };
-  };
-}

package/src/client/utils.spec.ts

@@ -1,60 +0,0 @@
-import { handleRequestError } from './utils';
-import { ConnectionError } from './errors';
-import { InternalServerError } from './errors';
-import { ValidationError } from './errors';
-
-// Test generated using Keploy
-test('handleRequestError should throw ConnectionError when error.response is undefined', () => {
-  const mockError = {
-    config: {
-      baseURL: 'http://example.com',
-      method: 'GET',
-      url: '/endpoint'
-    },
-    response: undefined
-  };
-
-  expect(() => handleRequestError(<any>mockError)).toThrow(ConnectionError);
-});
-
-// Test generated using Keploy
-test('handleRequestError should throw InternalServerError for INTERNAL_ERROR code', () => {
-  const mockError = {
-    config: {
-      baseURL: 'http://example.com',
-      method: 'GET',
-      url: '/endpoint'
-    },
-    response: {
-      data: {
-        code: 'INTERNAL_ERROR',
-        data: {
-          message: 'An internal server error occurred'
-        }
-      }
-    }
-  };
-
-  expect(() => handleRequestError(<any>mockError)).toThrow(InternalServerError);
-});
-
-// Test generated using Keploy
-test('handleRequestError should throw ValidationError for VALIDATION_ERROR code', () => {
-  const mockError = {
-    config: {
-      baseURL: 'http://example.com',
-      method: 'POST',
-      url: '/endpoint'
-    },
-    response: {
-      data: {
-        code: 'VALIDATION_ERROR',
-        data: {
-          reasons: ['Invalid input']
-        }
-      }
-    }
-  };
-
-  expect(() => handleRequestError(<any>mockError)).toThrow(ValidationError);
-});