vovk 3.0.0-beta.2 → 3.0.0-beta.20

package/.npmignore

@@ -0,0 +1,2 @@
+!*
+tsconfig.*

package/HttpException.d.ts

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

package/HttpException.js

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

package/LICENSE

@@ -0,0 +1,28 @@
+{
+  "name": "vovk",
+  "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,LICENSE} && cp ../../README.md dist ",
+    "lint": "eslint . --fix",
+    "npm-publish": "npm publish ./dist --dry-run",
+    "ncu": "npm-check-updates -u"
+  },
+  "keywords": [
+    "nextjs",
+    "router"
+  ],
+  "author": "Andrii Gubanov",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/finom/vovk/issues"
+  },
+  "homepage": "https://vovk.dev",
+  "peerDependencies": {
+    "next": "*"
+  }
+}

package/README.md

@@ -1 +1,111 @@
-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>RESTful RPC for Next.js</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>
+</p>
+
+
+ <br />
+
+Example back-end Controller Class:
+
+```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,
+    });
+  }
+}
+```
+
+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', 
+  }),
+})
+```

package/Segment.d.ts

@@ -0,0 +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 {
+    #private;
+    private static getHeadersFromOptions;
+    _routes: Record<HttpMethod, Map<VovkController, Record<string, RouteHandler>>>;
+    GET: (req: VovkRequest, data: {
+        params: Record<string, string[]>;
+    }) => Promise<Response>;
+    POST: (req: VovkRequest, data: {
+        params: Record<string, string[]>;
+    }) => Promise<Response>;
+    PUT: (req: VovkRequest, data: {
+        params: Record<string, string[]>;
+    }) => Promise<Response>;
+    PATCH: (req: VovkRequest, data: {
+        params: Record<string, string[]>;
+    }) => Promise<Response>;
+    DELETE: (req: VovkRequest, data: {
+        params: Record<string, string[]>;
+    }) => Promise<Response>;
+    HEAD: (req: VovkRequest, data: {
+        params: Record<string, string[]>;
+    }) => Promise<Response>;
+    OPTIONS: (req: VovkRequest, data: {
+        params: Record<string, string[]>;
+    }) => Promise<Response>;
+    respond: (status: HttpStatus, body: unknown, options?: DecoratorOptions) => Response;
+}

package/Segment.js

@@ -0,0 +1,184 @@
+"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._Segment = void 0;
+const types_1 = require("./types");
+const HttpException_1 = require("./HttpException");
+const StreamResponse_1 = require("./StreamResponse");
+const reqQuery_1 = __importDefault(require("./utils/reqQuery"));
+const reqMeta_1 = __importDefault(require("./utils/reqMeta"));
+class _Segment {
+    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 = (req, data) => {
+        return this.#callMethod(types_1._HttpMethod.GET, req, data.params);
+    };
+    POST = (req, data) => this.#callMethod(types_1._HttpMethod.POST, req, data.params);
+    PUT = (req, data) => this.#callMethod(types_1._HttpMethod.PUT, req, data.params);
+    PATCH = (req, data) => this.#callMethod(types_1._HttpMethod.PATCH, req, data.params);
+    DELETE = (req, data) => this.#callMethod(types_1._HttpMethod.DELETE, req, data.params);
+    HEAD = (req, data) => this.#callMethod(types_1._HttpMethod.HEAD, req, data.params);
+    OPTIONS = (req, data) => this.#callMethod(types_1._HttpMethod.OPTIONS, req, 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) => {
+        return this.respond(statusCode, {
+            statusCode,
+            message,
+            isError: true,
+        }, options);
+    };
+    #callMethod = async (httpMethod, req, params) => {
+        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`);
+            }
+            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 = [];
+            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_1._HttpException(types_1._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_1._HttpException(types_1._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(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: (metadata) => (0, reqMeta_1.default)(req, metadata),
+        };
+        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 StreamResponse_1._StreamResponse({
+                    headers: {
+                        ...StreamResponse_1._StreamResponse.defaultHeaders,
+                        ..._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);
+            }
+            throw e; // if NEXT_REDIRECT or NEXT_NOT_FOUND, rethrow it
+        }
+    };
+}
+exports._Segment = _Segment;
+_a = _Segment;

package/StreamResponse.d.ts

@@ -0,0 +1,16 @@
+import { _KnownAny as KnownAny, _StreamAbortMessage as StreamAbortMessage } from './types';
+import './utils/shim';
+export declare class _StreamResponse<T> extends Response {
+    static defaultHeaders: {
+        'Content-Type': string;
+    };
+    isClosed: boolean;
+    controller?: ReadableStreamDefaultController;
+    readonly encoder: TextEncoder;
+    readonly readableStream: ReadableStream;
+    constructor(init?: ResponseInit);
+    send(data: T | StreamAbortMessage): void;
+    close(): void;
+    throw(e: KnownAny): void;
+    [Symbol.dispose](): void;
+}

package/StreamResponse.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._StreamResponse = void 0;
+require("./utils/shim");
+class _StreamResponse extends Response {
+    static defaultHeaders = {
+        'Content-Type': 'text/plain; charset=utf-8',
+    };
+    isClosed = false;
+    controller;
+    encoder;
+    readableStream;
+    constructor(init) {
+        const encoder = new TextEncoder();
+        let readableController;
+        const readableStream = new ReadableStream({
+            cancel: () => {
+                this.isClosed = true;
+            },
+            start: (controller) => {
+                readableController = controller;
+            },
+        });
+        super(readableStream, {
+            ...init,
+            headers: init?.headers ?? _StreamResponse.defaultHeaders,
+        });
+        this.readableStream = readableStream;
+        this.encoder = encoder;
+        this.controller = readableController;
+    }
+    send(data) {
+        const { controller, encoder } = this;
+        if (this.isClosed)
+            return;
+        return controller?.enqueue(encoder.encode(JSON.stringify(data) + '\n'));
+    }
+    close() {
+        const { controller } = this;
+        if (this.isClosed)
+            return;
+        this.isClosed = true;
+        controller?.close();
+    }
+    throw(e) {
+        this.send({ isError: true, reason: e instanceof Error ? e.message : e });
+        return this.close();
+    }
+    [Symbol.dispose]() {
+        this.close();
+    }
+}
+exports._StreamResponse = _StreamResponse;

package/client/clientizeController.d.ts

@@ -0,0 +1,4 @@
+import { type _VovkControllerMetadata as VovkControllerMetadata, type _KnownAny as KnownAny } from '../types';
+import { type _VovkClientOptions as VovkClientOptions, type _VovkClient as VovkClient, type _VovkDefaultFetcherOptions as VovkDefaultFetcherOptions } from './types';
+export declare const ARRAY_QUERY_KEY = "_vovkarr";
+export declare const _clientizeController: <T, OPTS extends Record<string, KnownAny> = VovkDefaultFetcherOptions>(givenController: VovkControllerMetadata, segmentName: string, options?: VovkClientOptions<OPTS>) => VovkClient<T, OPTS>;

package/client/clientizeController.js

@@ -0,0 +1,92 @@
+"use strict";
+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 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 (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 _clientizeController = (givenController, segmentName, options) => {
+    const controller = givenController;
+    const client = {};
+    if (!controller)
+        throw new Error(`Unable to clientize. Controller metadata is not provided`);
+    const metadata = controller._handlers;
+    if (!metadata)
+        throw new Error(`Unable to clientize. No metadata for controller ${String(controller?._controllerName)}`);
+    const controllerPrefix = trimPath(controller._prefix ?? '');
+    const { fetcher: settingsFetcher = defaultFetcher_1.default } = options ?? {};
+    for (const [staticMethodName, { path, httpMethod, clientValidators }] of Object.entries(metadata)) {
+        const getEndpoint = ({ prefix, params, query, }) => {
+            const mainPrefix = (prefix.startsWith('http://') || prefix.startsWith('https://') || prefix.startsWith('/') ? '' : '/') +
+                (prefix.endsWith('/') ? prefix : `${prefix}/`) +
+                (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 ?? {});
+            };
+            const internalOptions = {
+                name: staticMethodName,
+                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 ?? {},
+                segmentName,
+                // 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;
+        };
+        // @ts-expect-error TODO: Fix this
+        client[staticMethodName] = handler;
+    }
+    return client;
+};
+exports._clientizeController = _clientizeController;

package/client/defaultFetcher.d.ts

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

package/client/defaultFetcher.js

@@ -0,0 +1,49 @@
+"use strict";
+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';
+// 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', segmentName = '', ...options }) => {
+    const endpoint = getEndpoint({ prefix, segmentName, 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)
+                throw e;
+            // otherwise, throw HttpException with status 0
+            throw new HttpException_1._HttpException(types_1._HttpStatus.NULL, e.message ?? exports.DEFAULT_ERROR_MESSAGE);
+        }
+    }
+    const init = {
+        method: httpMethod,
+        ...options,
+    };
+    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);
+    }
+    if (response.headers.get('content-type')?.includes('application/json')) {
+        return defaultHandler(response);
+    }
+    if (response.headers.get('content-type')?.includes('text/plain; charset=utf-8')) {
+        return defaultStreamHandler(response);
+    }
+    return response;
+};
+exports.default = defaultFetcher;

package/client/defaultHandler.d.ts

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

package/client/defaultHandler.js

@@ -0,0 +1,21 @@
+"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
+        throw new HttpException_1._HttpException(response.status, result?.message ?? exports.DEFAULT_ERROR_MESSAGE);
+    }
+    return result;
+};
+exports._defaultHandler = _defaultHandler;

package/client/defaultStreamHandler.d.ts

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