vovk 3.0.0-draft.8 → 3.0.0-draft.80

package/README.md

@@ -4,108 +4,21 @@
     <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>RESTful RPC for Next.js</strong>
-  
+  <strong>REST + RPC = ♥️</strong>
 </p>
 
 <p align="center">
-  Transforms <a href="https://nextjs.org/docs/app">Next.js</a> into a powerful REST API platform with RPC capabilities. 
-  <br><br>
-  ℹ️ Improved syntax for Zod and DTO validation is coming soon. Stay tuned!
-</p>
-
-<p align="center">
-  <a href="https://vovk.dev/">Documentation</a>&nbsp;&nbsp;&nbsp;&nbsp;
-  <a href="https://discord.gg/qdT8WEHUuP">Discord</a>&nbsp;&nbsp;&nbsp;&nbsp;
-  <a href="https://github.com/finom/vovk-examples">Code Examples</a>&nbsp;&nbsp;&nbsp;&nbsp;
-  <a href="https://github.com/finom/vovk-zod">vovk-zod</a>&nbsp;&nbsp;&nbsp;&nbsp;
-  <a href="https://github.com/finom/vovk-hello-world">vovk-hello-world</a>&nbsp;&nbsp;&nbsp;&nbsp;
-  <a href="https://github.com/finom/vovk-react-native-example">vovk-react-native-example</a>
-</p>
-<p align="center">
-  <a href="https://www.npmjs.com/package/vovk"><img src="https://badge.fury.io/js/vovk.svg" alt="npm version" /></a>&nbsp;
-  <a href="https://www.typescriptlang.org/"><img src="https://img.shields.io/badge/%3C%2F%3E-TypeScript-%230074c1.svg" alt="TypeScript" /></a>&nbsp;
-  <a href="https://github.com/finom/vovk/actions/workflows/main.yml"><img src="https://github.com/finom/vovk/actions/workflows/main.yml/badge.svg" alt="Build status" /></a>
+  Back-end meta-framework for <a href="https://nextjs.org/docs/app">Next.js</a>
 </p>
 
+---
 
- <br />
+## vovk [![npm version](https://badge.fury.io/js/vovk.svg)](https://www.npmjs.com/package/vovk)
 
-Example back-end Controller Class:
+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.
 
-```ts
-// /src/modules/post/PostController.ts
-import { get, prefix, type VovkRequest } from 'vovk';
-import PostService from './PostService';
- 
-@prefix('posts')
-export default class PostController {
-  /**
-   * Create a comment on a post
-   * POST /api/posts/:postId/comments
-   */
-  @post(':postId/comments')
-  static async createComment(
-    // decorate NextRequest type with body and query types
-    req: VovkRequest<
-      { content: string; userId: string }, 
-      { notificationType: 'push' | 'email' }
-    >,
-    { postId }: { postId: string } // params
-  ) {
-    // use standard Next.js API to get body and query
-    const { content, userId } = await req.json();
-    const notificationType = req.nextUrl.searchParams.get('notificationType');
- 
-    // perform the request to the database in a custom service
-    return PostService.createComment({ 
-      postId, content, userId, notificationType,
-    });
-  }
-}
+```sh
+npm install vovk
 ```
 
-Example component that uses the auto-generated client library:
-
-```tsx
-'use client';
-import { useState } from 'react';
-import { PostController } from 'vovk-client';
-import type { VovkReturnType } from 'vovk';
- 
-export default function Example() {
-  const [response, setResponse] = useState<VovkReturnType<typeof PostController.createComment>>();
- 
-  return (
-    <>
-      <button
-        onClick={async () => setResponse(
-          await PostController.createComment({
-            body: { 
-              content: 'Hello, World!', 
-              userId: '1', 
-            },
-            params: { postId: '69' },
-            query: { notificationType: 'push' }
-          })
-        )}
-      >
-        Post a comment
-      </button>
-      <div>{JSON.stringify(response)}</div>
-    </>
-  );
-}
-```
-
-Alternatively, the resource can be fetched wit the regular `fetch` function:
-
-```ts
-fetch('/api/posts/69?notificationType=push', {
-  method: 'POST',
-  body: JSON.stringify({ 
-    content: 'Hello, World!', 
-    userId: '1', 
-  }),
-})
-```
+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/{HttpException.d.ts → 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/{HttpException.js → 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/{StreamResponse.d.ts → dist/StreamJSONResponse.d.ts}

@@ -1,8 +1,8 @@
-import { _KnownAny as KnownAny, _StreamAbortMessage as StreamAbortMessage } from './types';
+import type { KnownAny, StreamAbortMessage } from './types';
 import './utils/shim';
-export declare class _StreamResponse<T> extends Response {
+export declare class StreamJSONResponse<T> extends Response {
     static defaultHeaders: {
-        'Content-Type': string;
+        'content-type': string;
     };
     isClosed: boolean;
     controller?: ReadableStreamDefaultController;

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

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._StreamResponse = void 0;
+exports.StreamJSONResponse = void 0;
 require("./utils/shim");
-class _StreamResponse extends Response {
+class StreamJSONResponse extends Response {
     static defaultHeaders = {
-        'Content-Type': 'text/plain; charset=utf-8',
+        'content-type': 'text/plain; format=jsonlines',
     };
     isClosed = false;
     controller;
@@ -23,7 +23,7 @@ class _StreamResponse extends Response {
         });
         super(readableStream, {
             ...init,
-            headers: init?.headers ?? _StreamResponse.defaultHeaders,
+            headers: init?.headers ?? StreamJSONResponse.defaultHeaders,
         });
         this.readableStream = readableStream;
         this.encoder = encoder;
@@ -50,4 +50,4 @@ class _StreamResponse extends Response {
         this.close();
     }
 }
-exports._StreamResponse = _StreamResponse;
+exports.StreamJSONResponse = StreamJSONResponse;

package/{Segment.d.ts → dist/VovkApp.d.ts}

@@ -1,27 +1,28 @@
-import { _HttpMethod as HttpMethod, _HttpStatus as HttpStatus, type _RouteHandler as RouteHandler, type _VovkController as VovkController, type _DecoratorOptions as DecoratorOptions, type _VovkRequest as VovkRequest } from './types';
-export declare class _Segment {
+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: VovkRequest, data: {
+    routes: Record<HttpMethod, Map<VovkController, Record<string, RouteHandler>>>;
+    GET: (req: NextRequest, data: {
         params: Promise<Record<string, string[]>>;
     }) => Promise<Response>;
-    POST: (req: VovkRequest, data: {
+    POST: (req: NextRequest, data: {
         params: Promise<Record<string, string[]>>;
     }) => Promise<Response>;
-    PUT: (req: VovkRequest, data: {
+    PUT: (req: NextRequest, data: {
         params: Promise<Record<string, string[]>>;
     }) => Promise<Response>;
-    PATCH: (req: VovkRequest, data: {
+    PATCH: (req: NextRequest, data: {
         params: Promise<Record<string, string[]>>;
     }) => Promise<Response>;
-    DELETE: (req: VovkRequest, data: {
+    DELETE: (req: NextRequest, data: {
         params: Promise<Record<string, string[]>>;
     }) => Promise<Response>;
-    HEAD: (req: VovkRequest, data: {
+    HEAD: (req: NextRequest, data: {
         params: Promise<Record<string, string[]>>;
     }) => Promise<Response>;
-    OPTIONS: (req: VovkRequest, data: {
+    OPTIONS: (req: NextRequest, data: {
         params: Promise<Record<string, string[]>>;
     }) => Promise<Response>;
     respond: (status: HttpStatus, body: unknown, options?: DecoratorOptions) => Response;

package/{Segment.js → dist/VovkApp.js}

@@ -4,13 +4,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._Segment = void 0;
+exports.VovkApp = void 0;
 const types_1 = require("./types");
 const HttpException_1 = require("./HttpException");
-const StreamResponse_1 = require("./StreamResponse");
+const StreamJSONResponse_1 = require("./StreamJSONResponse");
 const reqQuery_1 = __importDefault(require("./utils/reqQuery"));
 const reqMeta_1 = __importDefault(require("./utils/reqMeta"));
-class _Segment {
+const reqForm_1 = __importDefault(require("./utils/reqForm"));
+class VovkApp {
     static getHeadersFromOptions(options) {
         if (!options)
             return {};
@@ -25,7 +26,7 @@ class _Segment {
         };
         return headers;
     }
-    _routes = {
+    routes = {
         GET: new Map(),
         POST: new Map(),
         PUT: new Map(),
@@ -34,13 +35,13 @@ class _Segment {
         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);
+    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,
@@ -50,22 +51,24 @@ class _Segment {
             },
         });
     };
-    #respondWithError = (statusCode, message, options) => {
+    #respondWithError = (statusCode, message, options, cause) => {
         return this.respond(statusCode, {
+            cause,
             statusCode,
             message,
             isError: true,
         }, options);
     };
-    #callMethod = async (httpMethod, req, params) => {
-        const controllers = this._routes[httpMethod];
+    #callMethod = async (httpMethod, nextReq, params) => {
+        const req = nextReq;
+        const controllers = this.routes[httpMethod];
         const methodParams = {};
         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`);
+                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('/');
@@ -96,7 +99,7 @@ class _Segment {
                         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}"`);
+                                throw new HttpException_1.HttpException(types_1.HttpStatus.INTERNAL_SERVER_ERROR, `Duplicate parameter "${parameter}"`);
                             }
                             // If it's a parameterized segment, capture the parameter value.
                             methodParams[parameter] = pathSegment;
@@ -110,7 +113,7 @@ class _Segment {
                 });
             }
             if (methodKeys.length > 1) {
-                throw new HttpException_1._HttpException(types_1._HttpStatus.INTERNAL_SERVER_ERROR, `Conflicting routes found: ${methodKeys.join(', ')}`);
+                throw new HttpException_1.HttpException(types_1.HttpStatus.INTERNAL_SERVER_ERROR, `Conflicting routes found: ${methodKeys.join(', ')}`);
             }
             const [methodKey] = methodKeys;
             if (methodKey) {
@@ -120,13 +123,14 @@ class _Segment {
         };
         const handler = getHandler();
         if (!handler) {
-            return this.#respondWithError(types_1._HttpStatus.NOT_FOUND, `Route ${path.join('/')} is not found`);
+            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),
         };
         try {
             const result = await staticMethod.call(controller, req, methodParams);
@@ -137,9 +141,9 @@ class _Segment {
                     (Reflect.has(result, Symbol.asyncIterator) &&
                         typeof result[Symbol.asyncIterator] === 'function'));
             if (isIterator && !(result instanceof Array)) {
-                const streamResponse = new StreamResponse_1._StreamResponse({
+                const streamResponse = new StreamJSONResponse_1.StreamJSONResponse({
                     headers: {
-                        ...StreamResponse_1._StreamResponse.defaultHeaders,
+                        ...StreamJSONResponse_1.StreamJSONResponse.defaultHeaders,
                         ..._a.getHeadersFromOptions(staticMethod._options),
                     },
                 });
@@ -171,12 +175,12 @@ class _Segment {
                 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);
+                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._Segment = _Segment;
-_a = _Segment;
+exports.VovkApp = VovkApp;
+_a = VovkApp;

package/dist/client/createRPC.d.ts

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

package/{client/clientizeController.js → dist/client/createRPC.js}

@@ -3,68 +3,48 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._clientizeController = exports.ARRAY_QUERY_KEY = void 0;
 const defaultFetcher_1 = __importDefault(require("./defaultFetcher"));
 const defaultHandler_1 = require("./defaultHandler");
 const defaultStreamHandler_1 = require("./defaultStreamHandler");
-exports.ARRAY_QUERY_KEY = '_vovkarr';
+const serializeQuery_1 = __importDefault(require("../utils/serializeQuery"));
 const trimPath = (path) => path.trim().replace(/^\/|\/$/g, '');
 const getHandlerPath = (endpoint, params, query) => {
     let result = endpoint;
     for (const [key, value] of Object.entries(params ?? {})) {
         result = result.replace(`:${key}`, value);
     }
-    const searchParams = new URLSearchParams();
-    let hasQuery = false;
-    const arrayKeys = [];
-    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(exports.ARRAY_QUERY_KEY, arrayKeys.join(','));
-    }
-    return `${result}${hasQuery ? '?' : ''}${searchParams.toString()}`;
+    const queryStr = query ? (0, serializeQuery_1.default)(query) : null;
+    return `${result}${queryStr ? '?' : ''}${queryStr}`;
 };
-const _clientizeController = (givenController, segmentName, options) => {
-    const controller = givenController;
+const createRPC = (controllerSchema, segmentName, options) => {
+    const schema = controllerSchema;
     const client = {};
-    if (!controller)
-        throw new Error(`Unable to clientize. Controller schema is not provided`);
-    const schema = controller._handlers;
     if (!schema)
-        throw new Error(`Unable to clientize. No schema for controller ${String(controller?._controllerName)}`);
-    const controllerPrefix = trimPath(controller._prefix ?? '');
+        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_1.default } = options ?? {};
-    for (const [staticMethodName, { path, httpMethod, clientValidators }] of Object.entries(schema)) {
-        const getEndpoint = ({ prefix, params, query, }) => {
-            const mainPrefix = (prefix.startsWith('http://') || prefix.startsWith('https://') || prefix.startsWith('/') ? '' : '/') +
-                (prefix.endsWith('/') ? prefix : `${prefix}/`) +
+    for (const [staticMethodName, handlerSchema] of Object.entries(schema.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, endpoint }) => {
-                await (input.validateOnClient ?? options?.validateOnClient)?.({ body, query, endpoint }, clientValidators ?? {});
+                await (input.validateOnClient ?? options?.validateOnClient)?.({ body, query, endpoint }, validation ?? {});
             };
             const internalOptions = {
                 name: staticMethodName,
-                httpMethod,
+                httpMethod: httpMethod,
                 getEndpoint,
                 validate,
-                defaultHandler: defaultHandler_1._defaultHandler,
-                defaultStreamHandler: defaultStreamHandler_1._defaultStreamHandler,
+                defaultHandler: defaultHandler_1.defaultHandler,
+                defaultStreamHandler: defaultStreamHandler_1.defaultStreamHandler,
             };
             const internalInput = {
                 ...options?.defaultOptions,
@@ -85,9 +65,11 @@ const _clientizeController = (givenController, segmentName, options) => {
                 return Promise.resolve(fetcherPromise);
             return input.transform ? fetcherPromise.then(input.transform) : fetcherPromise;
         };
-        // @ts-expect-error TODO: Fix this
+        handler.schema = handlerSchema;
+        handler.controllerSchema = schema;
+        // @ts-expect-error TODO
         client[staticMethodName] = handler;
     }
     return client;
 };
-exports._clientizeController = _clientizeController;
+exports.default = createRPC;

package/dist/client/defaultFetcher.d.ts

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

package/{client → dist/client}/defaultFetcher.js

@@ -3,21 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_ERROR_MESSAGE = void 0;
 const types_1 = require("../types");
 const HttpException_1 = require("../HttpException");
-exports.DEFAULT_ERROR_MESSAGE = 'Unknown error at defaultFetcher';
+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 defaultFetcher = async ({ httpMethod, getEndpoint, validate, defaultHandler, defaultStreamHandler }, { params, query, body, prefix = '/api', ...options }) => {
-    const endpoint = getEndpoint({ prefix, params, query });
+const defaultFetcher = 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_1._HttpException)
+            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);
+            throw new HttpException_1.HttpException(types_1.HttpStatus.NULL, e.message ?? exports.DEFAULT_ERROR_MESSAGE, {
+                body,
+                query,
+                params,
+                endpoint,
+            });
         }
     }
     const init = {
@@ -36,12 +41,18 @@ const defaultFetcher = async ({ httpMethod, getEndpoint, validate, defaultHandle
     }
     catch (e) {
         // handle network errors
-        throw new HttpException_1._HttpException(types_1._HttpStatus.NULL, e?.message ?? exports.DEFAULT_ERROR_MESSAGE);
+        throw new HttpException_1.HttpException(types_1.HttpStatus.NULL, e?.message ?? exports.DEFAULT_ERROR_MESSAGE, {
+            body,
+            query,
+            params,
+            endpoint,
+        });
     }
-    if (response.headers.get('content-type')?.includes('application/json')) {
+    const contentType = response.headers.get('content-type');
+    if (contentType?.startsWith('application/json')) {
         return defaultHandler(response);
     }
-    if (response.headers.get('content-type')?.includes('text/plain; charset=utf-8')) {
+    if (contentType === 'text/plain; format=jsonlines') {
         return defaultStreamHandler(response);
     }
     return response;

package/{client → 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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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) => {
+    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);
+    }
+    if (!response.ok) {
+        // handle server errors
+        const errorResponse = result;
+        throw new HttpException_1.HttpException(response.status, errorResponse?.message ?? exports.DEFAULT_ERROR_MESSAGE, errorResponse?.cause);
+    }
+    return result;
+};
+exports.defaultHandler = defaultHandler;

package/dist/client/defaultStreamHandler.d.ts

@@ -0,0 +1,4 @@
+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<VovkStreamAsyncIterable<unknown>>;

package/{client → 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/index.d.ts

@@ -0,0 +1,2 @@
+export { default as createRPC } from './createRPC';
+export type { VovkClient, VovkClientFetcher, VovkClientOptions, VovkDefaultFetcherOptions, VovkValidateOnClient, VovkStreamAsyncIterable, } from './types';

package/dist/client/index.js

@@ -0,0 +1,8 @@
+"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;
+var createRPC_1 = require("./createRPC");
+Object.defineProperty(exports, "createRPC", { enumerable: true, get: function () { return __importDefault(createRPC_1).default; } });