@n1k1t/mock-server 0.1.59 → 0.1.61

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

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

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

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

package/src/client/models/method.ts

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

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

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

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

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

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

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