vovk 3.0.0-beta.6 → 3.0.0-draft.100

package/{dist/package.json → LICENSE}

@@ -1,22 +1,22 @@
 {
   "name": "vovk",
-  "version": "3.0.0-beta.6",
+  "version": "3.0.0-beta.9",
   "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 dist && cp package-lock.json dist && cp .npmignore dist && cp ../../README.md dist ",
+    "build": "rm -rf dist && tsc && cp {package.json,LICENSE} && cp ../../README.md dist ",
     "lint": "eslint . --fix",
-    "npm-publish": "npm publish ./dist",
+    "npm-publish": "npm publish ./dist --dry-run",
     "ncu": "npm-check-updates -u"
   },
   "keywords": [
     "nextjs",
     "router"
   ],
-  "author": "Andrii Gubanov",
+  "author": "Andrey Gubanov",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/finom/vovk/issues"

package/README.md

@@ -1 +1,24 @@
-Description is coming soon.
+<p align="center"> 
+  <picture>
+    <source width="300" media="(prefers-color-scheme: dark)" srcset="https://vovk.dev/vovk-logo-white.svg">
+    <source width="300" media="(prefers-color-scheme: light)" srcset="https://vovk.dev/vovk-logo.svg">
+    <img width="300" alt="vovk" src="https://vovk.dev/vovk-logo.svg">
+  </picture><br>
+  <strong>REST + RPC = ♥️</strong>
+</p>
+
+<p align="center">
+  Back-end meta-framework for <a href="https://nextjs.org/docs/app">Next.js</a>
+</p>
+
+---
+
+## vovk [![npm version](https://badge.fury.io/js/vovk.svg)](https://www.npmjs.com/package/vovk)
+
+The main library with [zero dependencies](https://bundlephobia.com/result?p=vovk) that's going to be used in production. It provides a wrapper for Next.js API routes, internal RPC API, utilities and types.
+
+```sh
+npm install vovk
+```
+
+For more information, please visit the [getting started guide](https://vovk.dev/getting-started) or check out the [Vovk.ts examples](https://vovk-examples.vercel.app/).

package/dist/HttpException.d.ts

@@ -1,5 +1,5 @@
-import type { _HttpStatus as HttpStatus } from './types';
-export declare class _HttpException extends Error {
+import type { HttpStatus } from './types';
+export declare class HttpException extends Error {
     statusCode: HttpStatus;
     message: string;
     cause?: unknown;

package/dist/HttpException.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._HttpException = void 0;
-class _HttpException extends Error {
+exports.HttpException = void 0;
+class HttpException extends Error {
     statusCode;
     message;
     cause;
@@ -12,4 +12,4 @@ class _HttpException extends Error {
         this.cause = cause;
     }
 }
-exports._HttpException = _HttpException;
+exports.HttpException = HttpException;

package/dist/{StreamResponse.d.ts → StreamJSONResponse.d.ts}

@@ -1,14 +1,12 @@
-import { _KnownAny as KnownAny, _StreamAbortMessage as StreamAbortMessage } from './types';
+import type { headers } from 'next/headers';
+import type { KnownAny, StreamAbortMessage } from './types';
 import './utils/shim';
-export declare class _StreamResponse<T> extends Response {
-    static defaultHeaders: {
-        'Content-Type': string;
-    };
+export declare class StreamJSONResponse<T> extends Response {
     isClosed: boolean;
     controller?: ReadableStreamDefaultController;
     readonly encoder: TextEncoder;
     readonly readableStream: ReadableStream;
-    constructor(init?: ResponseInit);
+    constructor(requestHeaders: Awaited<ReturnType<typeof headers>>, init?: ResponseInit);
     send(data: T | StreamAbortMessage): void;
     close(): void;
     throw(e: KnownAny): void;

package/dist/{StreamResponse.js → StreamJSONResponse.js}

@@ -1,16 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._StreamResponse = void 0;
+exports.StreamJSONResponse = void 0;
 require("./utils/shim");
-class _StreamResponse extends Response {
-    static defaultHeaders = {
-        'Content-Type': 'text/plain; charset=utf-8',
-    };
+class StreamJSONResponse extends Response {
     isClosed = false;
     controller;
     encoder;
     readableStream;
-    constructor(init) {
+    constructor(requestHeaders, init) {
         const encoder = new TextEncoder();
         let readableController;
         const readableStream = new ReadableStream({
@@ -21,9 +18,16 @@ class _StreamResponse extends Response {
                 readableController = controller;
             },
         });
+        if (!requestHeaders) {
+            throw new Error('Request headers are required');
+        }
+        const accept = requestHeaders.get('accept');
         super(readableStream, {
             ...init,
-            headers: init?.headers ?? _StreamResponse.defaultHeaders,
+            headers: {
+                ...init?.headers,
+                'Content-Type': accept?.includes('application/jsonl') ? 'application/jsonl; charset=utf-8' : 'text/plain; charset=utf-8',
+            },
         });
         this.readableStream = readableStream;
         this.encoder = encoder;
@@ -50,4 +54,4 @@ class _StreamResponse extends Response {
         this.close();
     }
 }
-exports._StreamResponse = _StreamResponse;
+exports.StreamJSONResponse = StreamJSONResponse;

package/dist/VovkApp.d.ts

@@ -0,0 +1,29 @@
+import type { NextRequest } from 'next/server';
+import { HttpMethod, HttpStatus, type RouteHandler, type VovkController, type DecoratorOptions } from './types';
+export declare class VovkApp {
+    #private;
+    private static getHeadersFromOptions;
+    routes: Record<HttpMethod, Map<VovkController, Record<string, RouteHandler>>>;
+    GET: (req: NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    POST: (req: NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    PUT: (req: NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    PATCH: (req: NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    DELETE: (req: NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    HEAD: (req: NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    OPTIONS: (req: NextRequest, data: {
+        params: Promise<Record<string, string[]>>;
+    }) => Promise<Response>;
+    respond: (status: HttpStatus, body: unknown, options?: DecoratorOptions) => Response;
+}

package/dist/VovkApp.js

@@ -0,0 +1,188 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VovkApp = void 0;
+const types_1 = require("./types");
+const HttpException_1 = require("./HttpException");
+const StreamJSONResponse_1 = require("./StreamJSONResponse");
+const reqQuery_1 = __importDefault(require("./utils/reqQuery"));
+const reqMeta_1 = __importDefault(require("./utils/reqMeta"));
+const reqForm_1 = __importDefault(require("./utils/reqForm"));
+const headers_1 = require("next/headers");
+class VovkApp {
+    static getHeadersFromOptions(options) {
+        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 = {
+        GET: new Map(),
+        POST: new Map(),
+        PUT: new Map(),
+        PATCH: new Map(),
+        DELETE: new Map(),
+        HEAD: new Map(),
+        OPTIONS: new Map(),
+    };
+    GET = async (req, data) => this.#callMethod(types_1.HttpMethod.GET, req, await data.params);
+    POST = async (req, data) => this.#callMethod(types_1.HttpMethod.POST, req, await data.params);
+    PUT = async (req, data) => this.#callMethod(types_1.HttpMethod.PUT, req, await data.params);
+    PATCH = async (req, data) => this.#callMethod(types_1.HttpMethod.PATCH, req, await data.params);
+    DELETE = async (req, data) => this.#callMethod(types_1.HttpMethod.DELETE, req, await data.params);
+    HEAD = async (req, data) => this.#callMethod(types_1.HttpMethod.HEAD, req, await data.params);
+    OPTIONS = async (req, data) => this.#callMethod(types_1.HttpMethod.OPTIONS, req, await data.params);
+    respond = (status, body, options) => {
+        return new Response(JSON.stringify(body), {
+            status,
+            headers: {
+                'content-type': 'application/json',
+                ..._a.getHeadersFromOptions(options),
+            },
+        });
+    };
+    #respondWithError = (statusCode, message, options, cause) => {
+        return this.respond(statusCode, {
+            cause,
+            statusCode,
+            message,
+            isError: true,
+        }, options);
+    };
+    #getHandler = ({ handlers, path, params, }) => {
+        const methodParams = {};
+        if (Object.keys(params).length === 0) {
+            return { handler: handlers[''], methodParams };
+        }
+        const allMethodKeys = Object.keys(handlers);
+        let methodKeys = [];
+        const pathStr = path.join('/');
+        methodKeys = allMethodKeys
+            // First, try to match literal routes exactly.
+            .filter((p) => {
+            if (p.includes(':'))
+                return false; // Skip parameterized paths
+            return p === pathStr;
+        });
+        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_1.HttpException(types_1.HttpStatus.INTERNAL_SERVER_ERROR, `Duplicate parameter "${parameter}" at ${p}`);
+                        }
+                        // 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_1.HttpException(types_1.HttpStatus.INTERNAL_SERVER_ERROR, `Conflicting routes found: ${methodKeys.join(', ')}`);
+        }
+        const [methodKey] = methodKeys;
+        if (methodKey) {
+            return { handler: handlers[methodKey], methodParams };
+        }
+        return { handler: null, methodParams };
+    };
+    #callMethod = async (httpMethod, nextReq, params) => {
+        const req = nextReq;
+        const controllers = this.routes[httpMethod];
+        const path = params[Object.keys(params)[0]];
+        const handlers = {};
+        controllers.forEach((staticMethods, controller) => {
+            const prefix = controller._prefix ?? '';
+            if (!controller._activated) {
+                throw new HttpException_1.HttpException(types_1.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 { handler, methodParams } = this.#getHandler({ handlers, path, params });
+        if (!handler) {
+            return this.#respondWithError(types_1.HttpStatus.NOT_FOUND, `Route ${path.join('/')} is not found`);
+        }
+        const { staticMethod, controller } = handler;
+        req.vovk = {
+            body: () => req.json(),
+            query: () => (0, reqQuery_1.default)(req),
+            meta: (meta) => (0, reqMeta_1.default)(req, meta),
+            form: () => (0, reqForm_1.default)(req),
+            params: () => methodParams,
+        };
+        try {
+            const result = await staticMethod.call(controller, req, methodParams);
+            const isIterator = typeof result === 'object' &&
+                !!result &&
+                ((Reflect.has(result, Symbol.iterator) &&
+                    typeof result[Symbol.iterator] === 'function') ||
+                    (Reflect.has(result, Symbol.asyncIterator) &&
+                        typeof result[Symbol.asyncIterator] === 'function'));
+            if (isIterator && !(result instanceof Array)) {
+                const streamResponse = new StreamJSONResponse_1.StreamJSONResponse(await (0, headers_1.headers)(), {
+                    headers: {
+                        ..._a.getHeadersFromOptions(staticMethod._options),
+                    },
+                });
+                void (async () => {
+                    try {
+                        for await (const chunk of result) {
+                            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;
+            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 || types_1.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
+        }
+    };
+}
+exports.VovkApp = VovkApp;
+_a = VovkApp;

package/dist/client/createRPC.d.ts

@@ -0,0 +1,3 @@
+import type { KnownAny, VovkFullSchema } from '../types';
+import type { VovkClientOptions, VovkClient, VovkDefaultFetcherOptions } from './types';
+export declare const createRPC: <T, OPTS extends Record<string, KnownAny> = VovkDefaultFetcherOptions>(fullSchema: VovkFullSchema, segmentName: string, controllerName: string, options?: VovkClientOptions<OPTS>) => VovkClient<T, OPTS>;

package/dist/client/createRPC.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRPC = void 0;
+const fetcher_1 = require("./fetcher");
+const defaultHandler_1 = require("./defaultHandler");
+const defaultStreamHandler_1 = require("./defaultStreamHandler");
+const serializeQuery_1 = __importDefault(require("../utils/serializeQuery"));
+const trimPath = (path) => path.trim().replace(/^\/|\/$/g, '');
+const getHandlerPath = (endpoint, params, query) => {
+    let result = endpoint;
+    const queryStr = query ? (0, serializeQuery_1.default)(query) : null;
+    for (const [key, value] of Object.entries(params ?? {})) {
+        result = result.replace(`:${key}`, value);
+    }
+    return `${result}${queryStr ? '?' : ''}${queryStr}`;
+};
+const createRPC = (fullSchema, segmentName, controllerName, options) => {
+    const segmentSchema = fullSchema.segments[segmentName];
+    if (!segmentSchema)
+        throw new Error(`Unable to create RPC object. Segment schema is missing. Check client template.`);
+    const controllerSchema = fullSchema.segments[segmentName]?.controllers[controllerName];
+    const client = {};
+    if (!controllerSchema)
+        throw new Error(`Unable to create RPC object. Controller schema is missing. Check client template.`);
+    const controllerPrefix = trimPath(controllerSchema.prefix ?? '');
+    const { fetcher: settingsFetcher = fetcher_1.fetcher } = options ?? {};
+    for (const [staticMethodName, handlerSchema] of Object.entries(controllerSchema.handlers)) {
+        const { path, httpMethod, validation } = handlerSchema;
+        const getEndpoint = ({ apiRoot, params, query, }) => {
+            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 = {}) => {
+            const fetcher = input.fetcher ?? settingsFetcher;
+            const validate = async ({ body, query, params, endpoint, }) => {
+                const validateOnClient = input.validateOnClient ?? options?.validateOnClient;
+                if (validateOnClient) {
+                    if (typeof validateOnClient !== 'function') {
+                        throw new Error('validateOnClient must be a function');
+                    }
+                    await validateOnClient({ body, query, params, endpoint }, validation ?? {}, fullSchema);
+                }
+            };
+            const internalOptions = {
+                name: staticMethodName,
+                httpMethod: httpMethod,
+                getEndpoint,
+                validate,
+                defaultHandler: defaultHandler_1.defaultHandler,
+                defaultStreamHandler: defaultStreamHandler_1.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);
+            if (!(fetcherPromise instanceof Promise))
+                return Promise.resolve(fetcherPromise);
+            return input.transform ? fetcherPromise.then(input.transform) : fetcherPromise;
+        };
+        handler.schema = handlerSchema;
+        handler.controllerSchema = controllerSchema;
+        handler.segmentSchema = segmentSchema;
+        handler.fullSchema = fullSchema;
+        // @ts-expect-error TODO
+        client[staticMethodName] = handler;
+    }
+    return client;
+};
+exports.createRPC = createRPC;

package/dist/client/defaultHandler.d.ts

@@ -1,2 +1,2 @@
 export declare const DEFAULT_ERROR_MESSAGE = "Unknown error at defaultHandler";
-export declare const _defaultHandler: (response: Response) => Promise<unknown>;
+export declare const defaultHandler: (response: Response) => Promise<unknown>;

package/dist/client/defaultHandler.js

@@ -1,21 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._defaultHandler = exports.DEFAULT_ERROR_MESSAGE = void 0;
+exports.defaultHandler = exports.DEFAULT_ERROR_MESSAGE = void 0;
 const HttpException_1 = require("../HttpException");
 exports.DEFAULT_ERROR_MESSAGE = 'Unknown error at defaultHandler';
-const _defaultHandler = async (response) => {
+const defaultHandler = async (response) => {
     let result;
     try {
         result = await response.json();
     }
     catch (e) {
         // handle parsing errors
-        throw new HttpException_1._HttpException(response.status, e?.message ?? exports.DEFAULT_ERROR_MESSAGE);
+        throw new HttpException_1.HttpException(response.status, e?.message ?? exports.DEFAULT_ERROR_MESSAGE);
     }
     if (!response.ok) {
         // handle server errors
-        throw new HttpException_1._HttpException(response.status, result?.message ?? exports.DEFAULT_ERROR_MESSAGE);
+        const errorResponse = result;
+        throw new HttpException_1.HttpException(response.status, errorResponse?.message ?? exports.DEFAULT_ERROR_MESSAGE, errorResponse?.cause);
     }
     return result;
 };
-exports._defaultHandler = _defaultHandler;
+exports.defaultHandler = defaultHandler;

package/dist/client/defaultStreamHandler.d.ts

@@ -1,4 +1,4 @@
-import type { _StreamAsyncIterator as StreamAsyncIterator } from './types';
+import type { VovkStreamAsyncIterable } from './types';
 import '../utils/shim';
 export declare const DEFAULT_ERROR_MESSAGE = "Unknown error at defaultStreamHandler";
-export declare const _defaultStreamHandler: (response: Response) => Promise<StreamAsyncIterator<unknown>>;
+export declare const defaultStreamHandler: (response: Response) => Promise<VovkStreamAsyncIterable<unknown>>;

package/dist/client/defaultStreamHandler.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._defaultStreamHandler = exports.DEFAULT_ERROR_MESSAGE = void 0;
+exports.defaultStreamHandler = exports.DEFAULT_ERROR_MESSAGE = void 0;
 const types_1 = require("../types");
 const HttpException_1 = require("../HttpException");
 require("../utils/shim");
 exports.DEFAULT_ERROR_MESSAGE = 'Unknown error at defaultStreamHandler';
-const _defaultStreamHandler = async (response) => {
+const defaultStreamHandler = async (response) => {
     if (!response.ok) {
         let result;
         try {
@@ -15,10 +15,10 @@ const _defaultStreamHandler = async (response) => {
             // ignore parsing errors
         }
         // handle server errors
-        throw new HttpException_1._HttpException(response.status, result.message ?? exports.DEFAULT_ERROR_MESSAGE);
+        throw new HttpException_1.HttpException(response.status, result.message ?? exports.DEFAULT_ERROR_MESSAGE);
     }
     if (!response.body)
-        throw new HttpException_1._HttpException(types_1._HttpStatus.NULL, 'Stream body is falsy. Check your controller code.');
+        throw new HttpException_1.HttpException(types_1.HttpStatus.NULL, 'Stream body is falsy. Check your controller code.');
     const reader = response.body.getReader();
     // if streaming is too rapid, we need to make sure that the loop is stopped
     let canceled = false;
@@ -79,4 +79,4 @@ const _defaultStreamHandler = async (response) => {
         },
     };
 };
-exports._defaultStreamHandler = _defaultStreamHandler;
+exports.defaultStreamHandler = defaultStreamHandler;

package/dist/client/fetcher.d.ts

@@ -0,0 +1,3 @@
+import type { VovkDefaultFetcherOptions, VovkClientFetcher } from './types';
+export declare const DEFAULT_ERROR_MESSAGE = "Unknown error at the defaultFetcher";
+export declare const fetcher: VovkClientFetcher<VovkDefaultFetcherOptions>;

package/dist/client/fetcher.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetcher = exports.DEFAULT_ERROR_MESSAGE = void 0;
+const types_1 = require("../types");
+const HttpException_1 = require("../HttpException");
+exports.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 fetcher = 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, params, endpoint });
+        }
+        catch (e) {
+            // if HttpException is thrown, rethrow it
+            if (e instanceof HttpException_1.HttpException)
+                throw e;
+            // otherwise, throw HttpException with status 0
+            throw new HttpException_1.HttpException(types_1.HttpStatus.NULL, e.message ?? exports.DEFAULT_ERROR_MESSAGE, {
+                body,
+                query,
+                params,
+                endpoint,
+            });
+        }
+    }
+    const init = {
+        method: httpMethod,
+        ...options,
+        headers: {
+            ...options.headers,
+            accept: 'application/jsonl, application/json',
+        },
+    };
+    if (body instanceof FormData) {
+        init.body = body;
+    }
+    else if (body) {
+        init.body = JSON.stringify(body);
+    }
+    let response;
+    try {
+        response = await fetch(endpoint, init);
+    }
+    catch (e) {
+        // handle network errors
+        throw new HttpException_1.HttpException(types_1.HttpStatus.NULL, e?.message ?? exports.DEFAULT_ERROR_MESSAGE, {
+            body,
+            query,
+            params,
+            endpoint,
+        });
+    }
+    const contentType = response.headers.get('content-type');
+    if (contentType?.startsWith('application/json')) {
+        return defaultHandler(response);
+    }
+    if (contentType?.startsWith('text/plain') && contentType.includes('x-format=jsonlines')) {
+        return defaultStreamHandler(response);
+    }
+    return response;
+};
+exports.fetcher = fetcher;

package/dist/client/index.d.ts

@@ -1,4 +1,3 @@
-import { _clientizeController as clientizeController } from './clientizeController';
-import type { _VovkClientFetcher as VovkClientFetcher, _VovkClientOptions as VovkClientOptions, _VovkDefaultFetcherOptions as VovkDefaultFetcherOptions } from './types';
-export { clientizeController };
-export type { VovkClientFetcher, VovkClientOptions, VovkDefaultFetcherOptions };
+export { createRPC } from './createRPC';
+export { fetcher } from './fetcher';
+export type { VovkClient, VovkClientFetcher, VovkClientOptions, VovkDefaultFetcherOptions, VovkValidateOnClient, VovkStreamAsyncIterable, } from './types';

package/dist/client/index.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clientizeController = void 0;
-const clientizeController_1 = require("./clientizeController");
-Object.defineProperty(exports, "clientizeController", { enumerable: true, get: function () { return clientizeController_1._clientizeController; } });
+exports.fetcher = exports.createRPC = void 0;
+var createRPC_1 = require("./createRPC");
+Object.defineProperty(exports, "createRPC", { enumerable: true, get: function () { return createRPC_1.createRPC; } });
+var fetcher_1 = require("./fetcher");
+Object.defineProperty(exports, "fetcher", { enumerable: true, get: function () { return fetcher_1.fetcher; } });