vovk 3.0.0-draft.206 → 3.0.0-draft.207

package/bin/index.mjs

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import { spawn } from 'child_process';
 
+console.warn(`Vovk CLI requires vovk-cli package. Running "npx vovk-cli ${process.argv.slice(2).join(' ')}" instead.`);
+
 spawn('npx', ['vovk-cli', ...process.argv.slice(2)], { stdio: 'inherit' }).on('exit', (code) => {
   process.exit(code);
 });

package/cjs/HttpException.js

@@ -1,15 +1,15 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
+"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;
-  }
+    statusCode;
+    message;
+    cause;
+    constructor(statusCode, message, cause) {
+        super(message);
+        this.statusCode = statusCode;
+        this.message = message;
+        this.cause = cause;
+    }
 }
 exports.HttpException = HttpException;

package/cjs/JSONLinesResponse.d.ts

@@ -1,4 +1,4 @@
-import type { headers } from 'next/headers';
+import { headers } from 'next/headers';
 import type { KnownAny, StreamAbortMessage } from './types.js';
 import './utils/shim.js';
 export declare class JSONLinesResponse<T> extends Response {

package/cjs/JSONLinesResponse.js

@@ -1,57 +1,59 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.JSONLinesResponse = void 0;
-require('./utils/shim.js');
+require("./utils/shim.js");
 class JSONLinesResponse extends Response {
-  isClosed = false;
-  controller;
-  encoder;
-  readableStream;
-  constructor(requestHeaders, init) {
-    const encoder = new TextEncoder();
-    let readableController;
-    const readableStream = new ReadableStream({
-      cancel: () => {
+    isClosed = false;
+    controller;
+    encoder;
+    readableStream;
+    constructor(requestHeaders, init) {
+        const encoder = new TextEncoder();
+        let readableController;
+        const readableStream = new ReadableStream({
+            cancel: () => {
+                this.isClosed = true;
+            },
+            start: (controller) => {
+                readableController = controller;
+            },
+        });
+        if (!requestHeaders) {
+            throw new Error('Request headers are required');
+        }
+        const accept = requestHeaders.get('accept');
+        super(readableStream, {
+            ...init,
+            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;
+        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;
-      },
-      start: (controller) => {
-        readableController = controller;
-      },
-    });
-    if (!requestHeaders) {
-      throw new Error('Request headers are required');
+        controller?.close();
+    }
+    throw(e) {
+        this.send({ isError: true, reason: e instanceof Error ? e.message : e });
+        return this.close();
+    }
+    [Symbol.dispose]() {
+        this.close();
     }
-    const accept = requestHeaders.get('accept');
-    super(readableStream, {
-      ...init,
-      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;
-    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.JSONLinesResponse = JSONLinesResponse;

package/cjs/VovkApp.js

@@ -1,199 +1,189 @@
-'use strict';
-var __importDefault =
-  (this && this.__importDefault) ||
-  function (mod) {
-    return mod && mod.__esModule ? mod : { default: mod };
-  };
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 var _a;
-Object.defineProperty(exports, '__esModule', { value: true });
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.VovkApp = void 0;
-const types_js_1 = require('./types.js');
-const HttpException_js_1 = require('./HttpException.js');
-const JSONLinesResponse_js_1 = require('./JSONLinesResponse.js');
-const reqQuery_js_1 = __importDefault(require('./utils/reqQuery.js'));
-const reqMeta_js_1 = __importDefault(require('./utils/reqMeta.js'));
-const reqForm_js_1 = __importDefault(require('./utils/reqForm.js'));
-const headers_1 = require('next/headers');
+const types_js_1 = require("./types.js");
+const HttpException_js_1 = require("./HttpException.js");
+const JSONLinesResponse_js_1 = require("./JSONLinesResponse.js");
+const reqQuery_js_1 = __importDefault(require("./utils/reqQuery.js"));
+const reqMeta_js_1 = __importDefault(require("./utils/reqMeta.js"));
+const reqForm_js_1 = __importDefault(require("./utils/reqForm.js"));
+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',
+    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(),
     };
-    const headers = {
-      ...(options.cors ? corsHeaders : {}),
-      ...(options.headers ?? {}),
+    GET = async (req, data) => this.#callMethod(types_js_1.HttpMethod.GET, req, await data.params);
+    POST = async (req, data) => this.#callMethod(types_js_1.HttpMethod.POST, req, await data.params);
+    PUT = async (req, data) => this.#callMethod(types_js_1.HttpMethod.PUT, req, await data.params);
+    PATCH = async (req, data) => this.#callMethod(types_js_1.HttpMethod.PATCH, req, await data.params);
+    DELETE = async (req, data) => this.#callMethod(types_js_1.HttpMethod.DELETE, req, await data.params);
+    HEAD = async (req, data) => this.#callMethod(types_js_1.HttpMethod.HEAD, req, await data.params);
+    OPTIONS = async (req, data) => this.#callMethod(types_js_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),
+            },
+        });
     };
-    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_js_1.HttpMethod.GET, req, await data.params);
-  POST = async (req, data) => this.#callMethod(types_js_1.HttpMethod.POST, req, await data.params);
-  PUT = async (req, data) => this.#callMethod(types_js_1.HttpMethod.PUT, req, await data.params);
-  PATCH = async (req, data) => this.#callMethod(types_js_1.HttpMethod.PATCH, req, await data.params);
-  DELETE = async (req, data) => this.#callMethod(types_js_1.HttpMethod.DELETE, req, await data.params);
-  HEAD = async (req, data) => this.#callMethod(types_js_1.HttpMethod.HEAD, req, await data.params);
-  OPTIONS = async (req, data) => this.#callMethod(types_js_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_js_1.HttpException(
-                types_js_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;
-          }
+    #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 };
         }
-        return true;
-      });
-    }
-    if (methodKeys.length > 1) {
-      throw new HttpException_js_1.HttpException(
-        types_js_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_js_1.HttpException(
-          types_js_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_js_1.HttpStatus.NOT_FOUND,
-        `${Object.keys(handlers)} - Route ${path.join('/')} is not found`
-      );
-    }
-    const { staticMethod, controller } = handler;
-    req.vovk = {
-      body: () => req.json(),
-      query: () => (0, reqQuery_js_1.default)(req),
-      meta: (meta) => (0, reqMeta_js_1.default)(req, meta),
-      form: () => (0, reqForm_js_1.default)(req),
-      params: () => 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_js_1.HttpException(types_js_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_js_1.HttpException(types_js_1.HttpStatus.INTERNAL_SERVER_ERROR, `Conflicting routes found: ${methodKeys.join(', ')}`);
+        }
+        const [methodKey] = methodKeys;
+        if (methodKey) {
+            return { handler: handlers[methodKey], methodParams };
+        }
+        return { handler: null, methodParams };
     };
-    try {
-      await staticMethod._options?.before?.call(controller, req);
-      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 JSONLinesResponse_js_1.JSONLinesResponse(await (0, headers_1.headers)(), {
-          headers: {
-            ..._a.getHeadersFromOptions(staticMethod._options),
-          },
+    #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_js_1.HttpException(types_js_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 };
+            });
         });
-        void (async () => {
-          try {
-            for await (const chunk of result) {
-              streamResponse.send(chunk);
+        const { handler, methodParams } = this.#getHandler({ handlers, path, params });
+        if (!handler) {
+            return this.#respondWithError(types_js_1.HttpStatus.NOT_FOUND, `${Object.keys(handlers)} - Route ${path.join('/')} is not found`);
+        }
+        const { staticMethod, controller } = handler;
+        req.vovk = {
+            body: () => req.json(),
+            query: () => (0, reqQuery_js_1.default)(req),
+            meta: (meta) => (0, reqMeta_js_1.default)(req, meta),
+            form: () => (0, reqForm_js_1.default)(req),
+            params: () => methodParams,
+        };
+        try {
+            await staticMethod._options?.before?.call(controller, req);
+            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 JSONLinesResponse_js_1.JSONLinesResponse(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;
             }
-          } 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_js_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
-    }
-  };
+            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_js_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/cjs/client/createRPC.d.ts

@@ -1,3 +1,3 @@
 import type { KnownAny, VovkSchema } from '../types.js';
-import type { VovkClient, VovkDefaultFetcherOptions } from './types.js';
-export declare const createRPC: <T, OPTS extends Record<string, KnownAny> = Record<string, never>>(schema: VovkSchema, segmentName: string, rpcModuleName: string, options?: VovkDefaultFetcherOptions<OPTS>) => VovkClient<T, OPTS>;
+import type { VovkClient, VovkClientFetcher, VovkDefaultFetcherOptions } from './types.js';
+export declare const createRPC: <T, OPTS extends Record<string, KnownAny> = Record<string, never>>(schema: VovkSchema, segmentName: string, rpcModuleName: string, fetcher?: VovkClientFetcher<OPTS>, options?: VovkDefaultFetcherOptions<OPTS>) => VovkClient<T, OPTS>;

package/cjs/client/createRPC.js

@@ -17,20 +17,20 @@ const getHandlerPath = (endpoint, params, query) => {
     }
     return `${result}${queryStr ? '?' : ''}${queryStr}`;
 };
-const createRPC = (schema, segmentName, rpcModuleName, options) => {
+const createRPC = (schema, segmentName, rpcModuleName, fetcher = fetcher_js_1.fetcher, options) => {
     const segmentNamePath = options?.segmentNameOverride ?? segmentName;
     const segmentSchema = schema.segments[segmentName];
     if (!segmentSchema)
-        throw new Error(`Unable to create RPC object. Segment schema is missing. Check client template.`);
+        throw new Error(`Unable to create RPC module. Segment schema is missing. Check client template.`);
     const controllerSchema = schema.segments[segmentName]?.controllers[rpcModuleName];
     const client = {};
     if (!controllerSchema)
-        throw new Error(`Unable to create RPC object. Controller schema is missing. Check client template.`);
+        throw new Error(`Unable to create RPC module. Controller schema is missing. Check client template.`);
     const controllerPrefix = trimPath(controllerSchema.prefix ?? '');
-    const { fetcher: settingsFetcher = fetcher_js_1.fetcher } = options ?? {};
     for (const [staticMethodName, handlerSchema] of Object.entries(controllerSchema.handlers ?? {})) {
         const { path, httpMethod, validation } = handlerSchema;
         const getEndpoint = ({ apiRoot, params, query, }) => {
+            apiRoot ??= options?.apiRoot ?? '/api';
             const endpoint = [
                 apiRoot.startsWith('http://') || apiRoot.startsWith('https://') || apiRoot.startsWith('/') ? '' : '/',
                 apiRoot,
@@ -42,7 +42,6 @@ const createRPC = (schema, segmentName, rpcModuleName, options) => {
             return endpoint;
         };
         const handler = (input = {}) => {
-            const fetcher = input.fetcher ?? settingsFetcher;
             const validate = async ({ body, query, params, endpoint, }) => {
                 const validateOnClient = input.validateOnClient ?? options?.validateOnClient;
                 if (validateOnClient && validation) {
@@ -61,17 +60,12 @@ const createRPC = (schema, segmentName, rpcModuleName, options) => {
                 defaultStreamHandler: defaultStreamHandler_js_1.defaultStreamHandler,
             };
             const internalInput = {
-                ...options?.defaultOptions,
+                ...options,
                 ...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);

package/cjs/client/defaultHandler.js

@@ -1,25 +1,22 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultHandler = exports.DEFAULT_ERROR_MESSAGE = void 0;
-const HttpException_js_1 = require('../HttpException.js');
+const HttpException_js_1 = require("../HttpException.js");
 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_js_1.HttpException(response.status, e?.message ?? exports.DEFAULT_ERROR_MESSAGE);
-  }
-  if (!response.ok) {
-    // handle server errors
-    const errorResponse = result;
-    throw new HttpException_js_1.HttpException(
-      response.status,
-      errorResponse?.message ?? exports.DEFAULT_ERROR_MESSAGE,
-      errorResponse?.cause
-    );
-  }
-  return result;
+    let result;
+    try {
+        result = await response.json();
+    }
+    catch (e) {
+        // handle parsing errors
+        throw new HttpException_js_1.HttpException(response.status, e?.message ?? exports.DEFAULT_ERROR_MESSAGE);
+    }
+    if (!response.ok) {
+        // handle server errors
+        const errorResponse = result;
+        throw new HttpException_js_1.HttpException(response.status, errorResponse?.message ?? exports.DEFAULT_ERROR_MESSAGE, errorResponse?.cause);
+    }
+    return result;
 };
 exports.defaultHandler = defaultHandler;