vovk 3.0.0-draft.5 → 3.0.0-draft.51

package/{utils → dist/utils}/reqQuery.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = reqQuery;
-const clientizeController_1 = require("../client/clientizeController");
+const createRPC_1 = require("../client/createRPC");
 function reqQuery(req) {
-    const queryArr = req.nextUrl.searchParams.get(clientizeController_1.ARRAY_QUERY_KEY)?.split(',') ?? null;
+    const queryArr = req.nextUrl.searchParams.get(createRPC_1.ARRAY_QUERY_KEY)?.split(',') ?? null;
     const entries = [...req.nextUrl.searchParams.entries()];
     const query = entries.reduce((acc, [key, value]) => {
-        if (key === clientizeController_1.ARRAY_QUERY_KEY)
+        if (key === createRPC_1.ARRAY_QUERY_KEY)
             return acc;
         if (queryArr?.includes(key)) {
             if (!(key in acc)) {

package/dist/utils/setClientValidatorsForHandler.d.ts

@@ -0,0 +1,5 @@
+import type { KnownAny } from '../types';
+export declare function setClientValidatorsForHandler(h: (...args: KnownAny[]) => KnownAny, validation: {
+    body: unknown;
+    query: unknown;
+}): Promise<void>;

package/{utils → dist/utils}/setClientValidatorsForHandler.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = setClientValidatorsForHandler;
-function setClientValidatorsForHandler(h, validators) {
+exports.setClientValidatorsForHandler = setClientValidatorsForHandler;
+function setClientValidatorsForHandler(h, validation) {
     return new Promise((resolve) => {
+        // the setTimeout is necessary to ensure that the _controller is already defined
         setTimeout(() => {
             const controller = h._controller;
             if (!controller) {
@@ -16,10 +17,7 @@ function setClientValidatorsForHandler(h, validators) {
                 ...controller._handlers,
                 [handlerName]: {
                     ...controller._handlers[handlerName],
-                    clientValidators: {
-                        body: validators.body,
-                        query: validators.query,
-                    },
+                    validation,
                 },
             };
             resolve();

package/dist/worker/createWPC.d.ts

@@ -0,0 +1,2 @@
+import type { WorkerPromiseInstance } from './types';
+export declare function createWPC<T extends object>(currentWorker: Worker | null, workerSchema: object): WorkerPromiseInstance<T>;

package/{worker/promisifyWorker.js → dist/worker/createWPC.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._promisifyWorker = _promisifyWorker;
-function _promisifyWorker(currentWorker, givenWorkerService) {
-    if (!givenWorkerService)
+exports.createWPC = createWPC;
+function createWPC(currentWorker, workerSchema) {
+    if (!workerSchema)
         throw new Error('Worker schema is not provided');
-    const workerService = givenWorkerService;
+    const schema = workerSchema;
     const instance = {
         worker: currentWorker,
     };
@@ -23,11 +23,9 @@ function _promisifyWorker(currentWorker, givenWorkerService) {
         instance.worker = worker;
         return instance;
     };
-    instance.fork = (worker) => {
-        return _promisifyWorker(worker, givenWorkerService);
-    };
-    for (const methodName of Object.keys(workerService._handlers)) {
-        const { isGenerator } = workerService._handlers[methodName];
+    instance.fork = (worker) => createWPC(worker, schema);
+    for (const methodName of Object.keys(schema.handlers)) {
+        const { isGenerator } = schema.handlers[methodName];
         if (isGenerator) {
             const method = (...args) => {
                 const key = callsKey;

package/dist/worker/index.d.ts

@@ -0,0 +1,3 @@
+import { worker } from './worker';
+import { createWPC } from './createWPC';
+export { worker, createWPC };

package/dist/worker/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWPC = exports.worker = void 0;
+const worker_1 = require("./worker");
+Object.defineProperty(exports, "worker", { enumerable: true, get: function () { return worker_1.worker; } });
+const createWPC_1 = require("./createWPC");
+Object.defineProperty(exports, "createWPC", { enumerable: true, get: function () { return createWPC_1.createWPC; } });

package/{worker → dist/worker}/types.d.ts

@@ -1,27 +1,27 @@
-import type { _KnownAny as KnownAny } from '../types';
+import type { KnownAny } from '../types';
 type ToPromise<T> = T extends PromiseLike<unknown> ? T : Promise<T>;
 type ToAsyncGenerator<T> = T extends AsyncGenerator<unknown, unknown, unknown> ? T : T extends Generator<infer U, unknown, unknown> ? AsyncGenerator<U, unknown, unknown> : AsyncGenerator<T, unknown, unknown>;
 type ToProperReturnType<T> = T extends Generator<unknown, unknown, unknown> | AsyncGenerator<unknown, unknown, unknown> ? ToAsyncGenerator<T> : ToPromise<T>;
 type OmitNever<T> = {
     [K in keyof T as T[K] extends never ? never : K]: T[K];
 };
-export type _WorkerPromiseInstanceWithNever<T> = {
+export type WorkerPromiseInstanceWithNever<T> = {
     [K in keyof T]: T[K] extends (...args: KnownAny[]) => KnownAny ? (...args: Parameters<T[K]>) => ToProperReturnType<ReturnType<T[K]>> : never;
 };
-export type _WorkerPromiseInstance<T> = OmitNever<_WorkerPromiseInstanceWithNever<T>> & {
+export type WorkerPromiseInstance<T> = OmitNever<WorkerPromiseInstanceWithNever<T>> & {
     terminate: () => void;
-    employ: (w: Worker) => _WorkerPromiseInstance<T>;
-    fork: (w: Worker) => _WorkerPromiseInstance<T>;
+    employ: (w: Worker) => WorkerPromiseInstance<T>;
+    fork: (w: Worker) => WorkerPromiseInstance<T>;
     worker: Worker | null;
     _isTerminated?: true;
     [Symbol.dispose]: () => void;
 };
-export interface _WorkerInput {
+export interface WorkerInput {
     methodName: string;
     args: unknown[];
     key: number;
 }
-export interface _WorkerOutput {
+export interface WorkerOutput {
     methodName: string;
     result?: unknown;
     error?: unknown;

package/dist/worker/worker.d.ts

@@ -0,0 +1 @@
+export declare function worker(): (t: object) => void;

package/{worker → dist/worker}/worker.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._worker = _worker;
-function _worker() {
+exports.worker = worker;
+function worker() {
     return (t) => {
         const target = t;
         target._handlers = {};
-        // TODO: Experimental: You can pass Worker Service instead of schema to prommisify worker
         for (const key of Object.getOwnPropertyNames(target)) {
             const member = target[key];
             if (typeof member === 'function') {

package/package.json

@@ -1,14 +1,17 @@
 {
   "name": "vovk",
-  "version": "3.0.0-draft.5",
+  "version": "3.0.0-draft.51",
+  "main": "dist/index.js",
   "description": "RESTful RPC for Next.js - Transforms Next.js into a powerful REST API platform with RPC capabilities.",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/finom/vovk.git"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc && cp {package.json,LICENSE,.npmignore} dist && cp ../../README.md dist",
+    "build": "tsc",
+    "rm-dist": "shx rm -rf dist",
     "lint": "eslint . --fix",
+    "tsc": "tsc --noEmit",
     "npm-publish": "if [ -z \"$NPM_TAG\" ]; then echo 'Error: NPM_TAG is not set'; exit 1; fi; cd ./dist && npm publish --tag=$NPM_TAG && cd ..",
     "ncu": "npm-check-updates -u"
   },

package/src/HttpException.ts

@@ -0,0 +1,16 @@
+import type { HttpStatus } from './types';
+
+export class HttpException extends Error {
+  statusCode: HttpStatus;
+
+  message: string;
+
+  cause?: unknown;
+
+  constructor(statusCode: HttpStatus, message: string, cause?: unknown) {
+    super(message);
+    this.statusCode = statusCode;
+    this.message = message;
+    this.cause = cause;
+  }
+}

package/src/StreamJSONResponse.ts

@@ -0,0 +1,62 @@
+import type { KnownAny, StreamAbortMessage } from './types';
+import './utils/shim';
+
+export class StreamJSONResponse<T> extends Response {
+  public static defaultHeaders = {
+    'content-type': 'text/plain; charset=utf-8',
+    'x-vovk-stream': 'true',
+  };
+
+  public isClosed = false;
+
+  public controller?: ReadableStreamDefaultController;
+
+  public readonly encoder: TextEncoder;
+
+  public readonly readableStream: ReadableStream;
+
+  constructor(init?: ResponseInit) {
+    const encoder = new TextEncoder();
+    let readableController: ReadableStreamDefaultController;
+
+    const readableStream = new ReadableStream({
+      cancel: () => {
+        this.isClosed = true;
+      },
+      start: (controller) => {
+        readableController = controller;
+      },
+    });
+
+    super(readableStream, {
+      ...init,
+      headers: init?.headers ?? StreamJSONResponse.defaultHeaders,
+    });
+
+    this.readableStream = readableStream;
+    this.encoder = encoder;
+    this.controller = readableController!;
+  }
+
+  public send(data: T | StreamAbortMessage) {
+    const { controller, encoder } = this;
+    if (this.isClosed) return;
+    return controller?.enqueue(encoder.encode(JSON.stringify(data) + '\n'));
+  }
+
+  public close() {
+    const { controller } = this;
+    if (this.isClosed) return;
+    this.isClosed = true;
+    controller?.close();
+  }
+
+  public throw(e: KnownAny) {
+    this.send({ isError: true, reason: e instanceof Error ? e.message : (e as unknown) });
+    return this.close();
+  }
+
+  public [Symbol.dispose]() {
+    this.close();
+  }
+}

package/src/VovkApp.ts

@@ -0,0 +1,242 @@
+import {
+  HttpMethod,
+  HttpStatus,
+  type RouteHandler,
+  type VovkErrorResponse,
+  type VovkController,
+  type DecoratorOptions,
+  type VovkRequest,
+  type KnownAny,
+} from './types';
+import { HttpException as HttpException } from './HttpException';
+import { StreamJSONResponse } from './StreamJSONResponse';
+import reqQuery from './utils/reqQuery';
+import reqMeta from './utils/reqMeta';
+import reqForm from './utils/reqForm';
+
+export class VovkApp {
+  private static getHeadersFromOptions(options?: DecoratorOptions) {
+    if (!options) return {};
+
+    const corsHeaders = {
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS, HEAD',
+      'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+    };
+
+    const headers = {
+      ...(options.cors ? corsHeaders : {}),
+      ...(options.headers ?? {}),
+    };
+
+    return headers;
+  }
+
+  routes: Record<HttpMethod, Map<VovkController, Record<string, RouteHandler>>> = {
+    GET: new Map(),
+    POST: new Map(),
+    PUT: new Map(),
+    PATCH: new Map(),
+    DELETE: new Map(),
+    HEAD: new Map(),
+    OPTIONS: new Map(),
+  };
+
+  GET = async (req: VovkRequest, data: { params: Promise<Record<string, string[]>> }) =>
+    this.#callMethod(HttpMethod.GET, req, await data.params);
+
+  POST = async (req: VovkRequest, data: { params: Promise<Record<string, string[]>> }) =>
+    this.#callMethod(HttpMethod.POST, req, await data.params);
+
+  PUT = async (req: VovkRequest, data: { params: Promise<Record<string, string[]>> }) =>
+    this.#callMethod(HttpMethod.PUT, req, await data.params);
+
+  PATCH = async (req: VovkRequest, data: { params: Promise<Record<string, string[]>> }) =>
+    this.#callMethod(HttpMethod.PATCH, req, await data.params);
+
+  DELETE = async (req: VovkRequest, data: { params: Promise<Record<string, string[]>> }) =>
+    this.#callMethod(HttpMethod.DELETE, req, await data.params);
+
+  HEAD = async (req: VovkRequest, data: { params: Promise<Record<string, string[]>> }) =>
+    this.#callMethod(HttpMethod.HEAD, req, await data.params);
+
+  OPTIONS = async (req: VovkRequest, data: { params: Promise<Record<string, string[]>> }) =>
+    this.#callMethod(HttpMethod.OPTIONS, req, await data.params);
+
+  respond = (status: HttpStatus, body: unknown, options?: DecoratorOptions) => {
+    return new Response(JSON.stringify(body), {
+      status,
+      headers: {
+        'Content-Type': 'application/json',
+        ...VovkApp.getHeadersFromOptions(options),
+      },
+    });
+  };
+
+  #respondWithError = (statusCode: HttpStatus, message: string, options?: DecoratorOptions, cause?: unknown) => {
+    return this.respond(
+      statusCode,
+      {
+        cause,
+        statusCode,
+        message,
+        isError: true,
+      } satisfies VovkErrorResponse,
+      options
+    );
+  };
+
+  #callMethod = async (
+    httpMethod: HttpMethod,
+    req: VovkRequest<KnownAny, KnownAny>,
+    params: Record<string, string[]>
+  ) => {
+    const controllers = this.routes[httpMethod];
+    const methodParams: Record<string, string> = {};
+    const path = params[Object.keys(params)[0]];
+
+    const handlers: Record<string, { staticMethod: RouteHandler; controller: VovkController }> = {};
+    controllers.forEach((staticMethods, controller) => {
+      const prefix = controller._prefix ?? '';
+
+      if (!controller._activated) {
+        throw new HttpException(
+          HttpStatus.INTERNAL_SERVER_ERROR,
+          `Controller "${controller.name}" found but not activated`
+        );
+      }
+
+      Object.entries(staticMethods).forEach(([path, staticMethod]) => {
+        const fullPath = [prefix, path].filter(Boolean).join('/');
+        handlers[fullPath] = { staticMethod, controller };
+      });
+    });
+
+    const getHandler = () => {
+      if (Object.keys(params).length === 0) {
+        return handlers[''];
+      }
+
+      const allMethodKeys = Object.keys(handlers);
+
+      let methodKeys: string[] = [];
+
+      methodKeys = allMethodKeys
+        // First, try to match literal routes exactly.
+        .filter((p) => {
+          if (p.includes(':')) return false; // Skip parameterized paths
+          return p === path.join('/');
+        });
+
+      if (!methodKeys.length) {
+        methodKeys = allMethodKeys.filter((p) => {
+          const routeSegments = p.split('/');
+          if (routeSegments.length !== path.length) return false;
+
+          for (let i = 0; i < routeSegments.length; i++) {
+            const routeSegment = routeSegments[i];
+            const pathSegment = path[i];
+
+            if (routeSegment.startsWith(':')) {
+              const parameter = routeSegment.slice(1);
+
+              if (parameter in methodParams) {
+                throw new HttpException(HttpStatus.INTERNAL_SERVER_ERROR, `Duplicate parameter "${parameter}"`);
+              }
+
+              // If it's a parameterized segment, capture the parameter value.
+              methodParams[parameter] = pathSegment;
+            } else if (routeSegment !== pathSegment) {
+              // If it's a literal segment and it does not match the corresponding path segment, return false.
+              return false;
+            }
+          }
+          return true;
+        });
+      }
+
+      if (methodKeys.length > 1) {
+        throw new HttpException(HttpStatus.INTERNAL_SERVER_ERROR, `Conflicting routes found: ${methodKeys.join(', ')}`);
+      }
+
+      const [methodKey] = methodKeys;
+
+      if (methodKey) {
+        return handlers[methodKey];
+      }
+
+      return null;
+    };
+
+    const handler = getHandler();
+
+    if (!handler) {
+      return this.#respondWithError(HttpStatus.NOT_FOUND, `Route ${path.join('/')} is not found`);
+    }
+
+    const { staticMethod, controller } = handler;
+
+    req.vovk = {
+      body: () => req.json(),
+      query: () => reqQuery(req),
+      meta: <T = KnownAny>(meta?: T | null) => reqMeta<T>(req, meta),
+      form: <T = KnownAny>() => reqForm<T>(req),
+    };
+
+    try {
+      const result = await staticMethod.call(controller, req, methodParams);
+
+      const isIterator =
+        typeof result === 'object' &&
+        !!result &&
+        ((Reflect.has(result, Symbol.iterator) &&
+          typeof (result as Iterable<unknown>)[Symbol.iterator] === 'function') ||
+          (Reflect.has(result, Symbol.asyncIterator) &&
+            typeof (result as AsyncIterable<unknown>)[Symbol.asyncIterator] === 'function'));
+
+      if (isIterator && !(result instanceof Array)) {
+        const streamResponse = new StreamJSONResponse({
+          headers: {
+            ...StreamJSONResponse.defaultHeaders,
+            ...VovkApp.getHeadersFromOptions(staticMethod._options),
+          },
+        });
+
+        void (async () => {
+          try {
+            for await (const chunk of result as AsyncGenerator<unknown>) {
+              streamResponse.send(chunk);
+            }
+          } catch (e) {
+            return streamResponse.throw(e);
+          }
+
+          return streamResponse.close();
+        })();
+
+        return streamResponse;
+      }
+
+      if (result instanceof Response) {
+        return result;
+      }
+
+      return this.respond(200, result ?? null, staticMethod._options);
+    } catch (e) {
+      const err = e as HttpException;
+      try {
+        await controller._onError?.(err, req);
+      } catch (onErrorError) {
+        // eslint-disable-next-line no-console
+        console.error(onErrorError);
+      }
+
+      if (err.message !== 'NEXT_REDIRECT' && err.message !== 'NEXT_NOT_FOUND') {
+        const statusCode = err.statusCode ?? HttpStatus.INTERNAL_SERVER_ERROR;
+        return this.#respondWithError(statusCode, err.message, staticMethod._options, err.cause);
+      }
+
+      throw e; // if NEXT_REDIRECT or NEXT_NOT_FOUND, rethrow it
+    }
+  };
+}

package/src/client/createRPC.ts

@@ -0,0 +1,133 @@
+import {
+  type VovkControllerSchema,
+  type ControllerStaticMethod,
+  type VovkControllerParams,
+  type VovkControllerQuery,
+  type KnownAny,
+} from '../types';
+import { type VovkClientOptions, type VovkClient, type VovkDefaultFetcherOptions, VovkValidateOnClient } from './types';
+
+import defaultFetcher from './defaultFetcher';
+import { defaultHandler } from './defaultHandler';
+import { defaultStreamHandler } from './defaultStreamHandler';
+
+// TODO Ugly workaround. Need your ideas how to distinguish between array and non-array query params
+export const ARRAY_QUERY_KEY = '_vovkarr';
+
+const trimPath = (path: string) => path.trim().replace(/^\/|\/$/g, '');
+
+const getHandlerPath = <T extends ControllerStaticMethod>(
+  endpoint: string,
+  params?: VovkControllerParams<T>,
+  query?: VovkControllerQuery<T>
+) => {
+  let result = endpoint;
+  for (const [key, value] of Object.entries(params ?? {})) {
+    result = result.replace(`:${key}`, value as string);
+  }
+
+  const searchParams = new URLSearchParams();
+  let hasQuery = false;
+  const arrayKeys: string[] = [];
+  for (const [key, value] of Object.entries(query ?? {})) {
+    if (typeof value === 'undefined') continue;
+    if (value instanceof Array) {
+      arrayKeys.push(key);
+      for (const val of value) {
+        searchParams.append(key, val);
+      }
+    } else {
+      searchParams.set(key, value);
+    }
+    hasQuery = true;
+  }
+
+  if (arrayKeys.length) {
+    searchParams.set(ARRAY_QUERY_KEY, arrayKeys.join(','));
+  }
+
+  return `${result}${hasQuery ? '?' : ''}${searchParams.toString()}`;
+};
+
+export const createRPC = <T, OPTS extends Record<string, KnownAny> = VovkDefaultFetcherOptions>(
+  controllerSchema: VovkControllerSchema,
+  segmentName?: string,
+  options?: VovkClientOptions<OPTS>
+): VovkClient<T, OPTS> => {
+  const schema = controllerSchema as T & VovkControllerSchema;
+  const client = {} as VovkClient<T, OPTS>;
+  if (!schema) throw new Error(`Unable to clientize. Controller schema is not provided`);
+  if (!schema.handlers)
+    throw new Error(`Unable to clientize. No schema for controller ${String(schema?.controllerName)} provided`);
+  const controllerPrefix = trimPath(schema.prefix ?? '');
+  const { fetcher: settingsFetcher = defaultFetcher } = options ?? {};
+
+  for (const [staticMethodName, { path, httpMethod, validation }] of Object.entries(schema.handlers)) {
+    const getEndpoint = ({
+      apiRoot,
+      params,
+      query,
+    }: {
+      apiRoot: string;
+      params: { [key: string]: string };
+      query: { [key: string]: string };
+    }) => {
+      const mainPrefix =
+        (apiRoot.startsWith('http://') || apiRoot.startsWith('https://') || apiRoot.startsWith('/') ? '' : '/') +
+        (apiRoot.endsWith('/') ? apiRoot : `${apiRoot}/`) +
+        (segmentName ? `${segmentName}/` : '');
+      return mainPrefix + getHandlerPath([controllerPrefix, path].filter(Boolean).join('/'), params, query);
+    };
+
+    const handler = (
+      input: {
+        body?: unknown;
+        query?: { [key: string]: string };
+        params?: { [key: string]: string };
+        validateOnClient?: VovkValidateOnClient;
+        fetcher?: VovkClientOptions<OPTS>['fetcher'];
+        transform?: (response: unknown) => unknown;
+      } & OPTS = {} as OPTS
+    ) => {
+      const fetcher = input.fetcher ?? settingsFetcher;
+      const validate = async ({ body, query, endpoint }: { body?: unknown; query?: unknown; endpoint: string }) => {
+        await (input.validateOnClient ?? options?.validateOnClient)?.({ body, query, endpoint }, validation ?? {});
+      };
+
+      const internalOptions: Parameters<typeof fetcher>[0] = {
+        name: staticMethodName as keyof T,
+        httpMethod,
+        getEndpoint,
+        validate,
+        defaultHandler,
+        defaultStreamHandler,
+      };
+      const internalInput = {
+        ...options?.defaultOptions,
+        ...input,
+        body: input.body ?? null,
+        query: input.query ?? {},
+        params: input.params ?? {},
+        // TS workaround
+        fetcher: undefined,
+        validateOnClient: undefined,
+      };
+
+      delete internalInput.fetcher;
+      delete internalInput.validateOnClient;
+
+      if (!fetcher) throw new Error('Fetcher is not provided');
+
+      const fetcherPromise = fetcher(internalOptions, internalInput) as Promise<unknown>;
+
+      if (!(fetcherPromise instanceof Promise)) return Promise.resolve(fetcherPromise);
+
+      return input.transform ? fetcherPromise.then(input.transform) : fetcherPromise;
+    };
+
+    // @ts-expect-error TODO
+    client[staticMethodName] = handler;
+  }
+
+  return client;
+};

package/src/client/defaultFetcher.ts

@@ -0,0 +1,57 @@
+import type { VovkDefaultFetcherOptions, VovkClientFetcher } from './types';
+import { HttpStatus } from '../types';
+import { HttpException } from '../HttpException';
+
+export const DEFAULT_ERROR_MESSAGE = 'Unknown error at the defaultFetcher';
+
+// defaultFetcher uses HttpException class to throw errors of fake HTTP status 0 if client-side error occurs
+// For normal HTTP errors, it uses message and status code from the response of VovkErrorResponse type
+const defaultFetcher: VovkClientFetcher<VovkDefaultFetcherOptions> = async (
+  { httpMethod, getEndpoint, validate, defaultHandler, defaultStreamHandler },
+  { params, query, body, apiRoot = '/api', ...options }
+) => {
+  const endpoint = getEndpoint({ apiRoot, params, query });
+
+  if (!options.disableClientValidation) {
+    try {
+      await validate({ body, query, endpoint });
+    } catch (e) {
+      // if HttpException is thrown, rethrow it
+      if (e instanceof HttpException) throw e;
+      // otherwise, throw HttpException with status 0
+      throw new HttpException(HttpStatus.NULL, (e as Error).message ?? DEFAULT_ERROR_MESSAGE);
+    }
+  }
+
+  const init: RequestInit = {
+    method: httpMethod,
+    ...options,
+  };
+
+  if (body instanceof FormData) {
+    init.body = body as BodyInit;
+  } else if (body) {
+    init.body = JSON.stringify(body);
+  }
+
+  let response: Response;
+
+  try {
+    response = await fetch(endpoint, init);
+  } catch (e) {
+    // handle network errors
+    throw new HttpException(HttpStatus.NULL, (e as Error)?.message ?? DEFAULT_ERROR_MESSAGE);
+  }
+
+  if (response.headers.get('content-type')?.includes('application/json')) {
+    return defaultHandler(response);
+  }
+
+  if (response.headers.get('x-vovk-stream') === 'true') {
+    return defaultStreamHandler(response);
+  }
+
+  return response;
+};
+
+export default defaultFetcher;