@naturalcycles/js-lib 14.141.0 → 14.143.0

package/src/http/fetcher.ts

@@ -3,7 +3,7 @@
 import { isServerSide } from '../env'
 import { ErrorObject } from '../error/error.model'
 import { _anyToError, _anyToErrorObject, _errorToErrorObject } from '../error/error.util'
-import { HttpError } from '../error/http.error'
+import { HttpRequestError } from '../error/httpRequestError'
 import { _clamp } from '../number/number.util'
 import {
   _filterNullishValues,
@@ -13,8 +13,9 @@ import {
   _omit,
 } from '../object/object.util'
 import { pDelay } from '../promise/pDelay'
-import { _jsonParseIfPossible } from '../string/json.util'
+import { _jsonParse, _jsonParseIfPossible } from '../string/json.util'
 import { _since } from '../time/time.util'
+import { UnixTimestampNumber } from '../types'
 import type {
   FetcherAfterResponseHook,
   FetcherBeforeRequestHook,
@@ -218,7 +219,7 @@ export class Fetcher {
         )
       } else {
         // !res.ok
-        await this.onNotOkResponse(res, timeout)
+        await this.onNotOkResponse(res, started, timeout)
       }
     }
 
@@ -231,7 +232,7 @@ export class Fetcher {
 
   private async onOkResponse(
     res: FetcherResponse<any> & { fetchResponse: Response },
-    started: number,
+    started: UnixTimestampNumber,
     timeout?: number,
   ): Promise<void> {
     const { req } = res
@@ -244,14 +245,21 @@ export class Fetcher {
         if (text) {
           try {
             res.body = text
-            res.body = JSON.parse(text, req.jsonReviver)
+            res.body = _jsonParse(text, req.jsonReviver)
           } catch (err) {
-            const { message } = _anyToError(err)
-            res.err = new HttpError([res.signature, message].join('\n'), {
-              httpStatusCode: 0,
-              url: req.url,
-            })
+            // Error while parsing json
+            // res.err = _anyToError(err, HttpRequestError, {
+            //   requestUrl: res.req.url,
+            //   requestBaseUrl: this.cfg.baseUrl,
+            //   requestMethod: res.req.init.method,
+            //   requestSignature: res.signature,
+            //   requestDuration: Date.now() - started,
+            //   responseStatusCode: res.fetchResponse.status,
+            // } satisfies HttpRequestErrorData)
+            res.err = _anyToError(err)
             res.ok = false
+
+            return await this.onNotOkResponse(res, started, timeout)
           }
         } else {
           // Body had a '' (empty string)
@@ -302,42 +310,44 @@ export class Fetcher {
     return await globalThis.fetch(url, init)
   }
 
-  private async onNotOkResponse(res: FetcherResponse, timeout?: number): Promise<void> {
+  private async onNotOkResponse(
+    res: FetcherResponse,
+    started: UnixTimestampNumber,
+    timeout?: number,
+  ): Promise<void> {
     clearTimeout(timeout)
 
-    let errObj: ErrorObject
+    let cause: ErrorObject | undefined
 
-    if (res.fetchResponse) {
+    if (res.err) {
+      // This is only possible on JSON.parse error (or CORS error!)
+      // This check should go first, to avoid calling .text() twice (which will fail)
+      cause = _errorToErrorObject(res.err)
+    } else if (res.fetchResponse) {
       const body = _jsonParseIfPossible(await res.fetchResponse.text())
-      errObj = _anyToErrorObject(body)
-    } else if (res.err) {
-      errObj = _errorToErrorObject(res.err)
-    } else {
-      errObj = {} as ErrorObject
+      if (body) {
+        cause = _anyToErrorObject(body)
+      }
     }
 
-    const originalMessage = errObj.message
-    errObj.message = [
-      [res.fetchResponse?.status, res.signature].filter(Boolean).join(' '),
-      originalMessage,
-    ]
-      .filter(Boolean)
-      .join('\n')
-
-    res.err = new HttpError(
-      errObj.message,
+    const message = [res.fetchResponse?.status, res.signature].filter(Boolean).join(' ')
 
+    res.err = new HttpRequestError(
+      message,
       _filterNullishValues({
-        ...errObj.data,
-        originalMessage,
-        httpStatusCode: res.fetchResponse?.status || 0,
+        responseStatusCode: res.fetchResponse?.status || 0,
         // These properties are provided to be used in e.g custom Sentry error grouping
         // Actually, disabled now, to avoid unnecessary error printing when both msg and data are printed
         // Enabled, cause `data` is not printed by default when error is HttpError
         // method: req.method,
-        url: res.req.url,
         // tryCount: req.tryCount,
+        requestUrl: res.req.url,
+        requestBaseUrl: this.cfg.baseUrl || (null as any),
+        requestMethod: res.req.init.method,
+        requestSignature: res.signature,
+        requestDuration: Date.now() - started,
       }),
+      cause,
     )
 
     await this.processRetry(res)

package/src/http/http.model.ts

@@ -3,4 +3,9 @@ export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD'
 
 export type HttpStatusFamily = 5 | 4 | 3 | 2 | 1
 
+/**
+ * Number, representing a valid Http status code (e.g 401, 500, etc)
+ */
+export type HttpStatusCode = number
+
 export const HTTP_METHODS: HttpMethod[] = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD']

package/src/index.ts

@@ -20,9 +20,10 @@ export * from './enum.util'
 export * from './error/error.model'
 export * from './error/error.util'
 export * from './error/errorMode'
-export * from './error/http.error'
+export * from './error/httpRequestError'
 export * from './error/try'
 export * from './error/tryCatch'
+export * from './error/jsonParseError'
 export * from './json-schema/from-data/generateJsonSchemaFromData'
 export * from './json-schema/jsonSchema.cnst'
 export * from './json-schema/jsonSchema.model'

package/src/promise/pTimeout.ts

@@ -1,11 +1,11 @@
 import { AppError } from '../error/app.error'
-import type { ErrorData } from '../error/error.model'
+import type { ErrorData, ErrorObject } from '../error/error.model'
 import { _errorDataAppend } from '../error/error.util'
 import type { AnyAsyncFunction } from '../types'
 
 export class TimeoutError extends AppError {
-  constructor(message: string, data = {}, opt?: ErrorOptions) {
-    super(message, data, opt, 'TimeoutError')
+  constructor(message: string, data = {}, cause?: ErrorObject) {
+    super(message, data, cause, 'TimeoutError')
   }
 }
 

package/src/string/json.util.ts

@@ -1,3 +1,6 @@
+import { JsonParseError } from '../error/jsonParseError'
+import { Reviver } from '../types'
+
 // const possibleJsonStartTokens = ['{', '[', '"']
 const DETECT_JSON = /^\s*[{["\-\d]/
 
@@ -5,10 +8,7 @@ const DETECT_JSON = /^\s*[{["\-\d]/
  * Attempts to parse object as JSON.
  * Returns original object if JSON parse failed (silently).
  */
-export function _jsonParseIfPossible(
-  obj: any,
-  reviver?: (this: any, key: string, value: any) => any,
-): any {
+export function _jsonParseIfPossible(obj: any, reviver?: Reviver): any {
   // Optimization: only try to parse if it looks like JSON: starts with a json possible character
   if (typeof obj === 'string' && obj && DETECT_JSON.test(obj)) {
     try {
@@ -18,3 +18,19 @@ export function _jsonParseIfPossible(
 
   return obj
 }
+
+/**
+ * Same as JSON.parse, but throws JsonParseError:
+ *
+ * 1. It's message includes a piece of source text (truncated)
+ * 2. It's data.text contains full source text
+ */
+export function _jsonParse(s: string, reviver?: Reviver): unknown {
+  try {
+    return JSON.parse(s, reviver)
+  } catch {
+    throw new JsonParseError({
+      text: s,
+    })
+  }
+}

package/src/string/stringifyAny.ts

@@ -1,4 +1,4 @@
-import { _isErrorObject, _isHttpErrorObject, _isHttpErrorResponse } from '../error/error.util'
+import { _isErrorObject, _isBackendErrorResponseObject } from '../error/error.util'
 import type { Reviver } from '../types'
 import { _jsonParseIfPossible } from './json.util'
 import { _safeJsonStringify } from './safeJsonStringify'
@@ -88,7 +88,7 @@ export function _stringifyAny(obj: any, opt: StringifyAnyOptions = {}): string {
   //
   // HttpErrorResponse
   //
-  if (_isHttpErrorResponse(obj)) {
+  if (_isBackendErrorResponseObject(obj)) {
     return _stringifyAny(obj.error, opt)
   }
 
@@ -103,12 +103,12 @@ export function _stringifyAny(obj: any, opt: StringifyAnyOptions = {}): string {
     // if (obj?.name === 'Error') {
     //   s = obj.message
     // }
-    if (_isErrorObject(obj) && _isHttpErrorObject(obj)) {
-      // Printing (0) to avoid ambiguity
-      s = `${obj.name}(${obj.data.httpStatusCode}): ${obj.message}`
-    }
+    // if (_isErrorObject(obj) && _isHttpErrorObject(obj)) {
+    //   // Printing (0) to avoid ambiguity
+    //   s = `${obj.name}(${obj.data.httpStatusCode}): ${obj.message}`
+    // }
 
-    s ||= [obj.name, obj.message].filter(Boolean).join(': ')
+    s = [obj.name, obj.message].filter(Boolean).join(': ')
 
     if (typeof (obj as any).code === 'string') {
       // Error that has no `data`, but has `code` property

package/src/types.ts

@@ -222,15 +222,26 @@ export type UnixTimestampMillisNumber = number
  */
 export type UnixTimestamp = number
 
+export type NumberOfSeconds = number
+export type NumberOfMilliseconds = number
+
 /**
  * Same as `number`, but with semantic meaning that it's an Integer.
  */
 export type Integer = number
 
+/**
+ * Used as a compact representation of truthy value.
+ * undefined ('' or other short falsy value) should be used as falsy value.
+ */
+export type ShortBoolean = '1'
+
 export type Base64String = string
 export type Base64UrlString = string
 export type JWTString = string
 
+export type SemVerString = string
+
 /**
  * Named type for JSON.parse / JSON.stringify second argument
  */

package/dist/error/http.error.d.ts

@@ -1,8 +0,0 @@
-import { AppError } from './app.error';
-import type { HttpErrorData } from './error.model';
-/**
- * Base class for HTTP errors - errors that define HTTP error code.
- */
-export declare class HttpError<DATA_TYPE extends HttpErrorData = HttpErrorData> extends AppError<DATA_TYPE> {
-    constructor(message: string, data: DATA_TYPE, opt?: ErrorOptions);
-}

package/dist/error/http.error.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpError = void 0;
-const app_error_1 = require("./app.error");
-/**
- * Base class for HTTP errors - errors that define HTTP error code.
- */
-class HttpError extends app_error_1.AppError {
-    constructor(message, data, opt) {
-        super(message, data, opt, 'HttpError');
-    }
-}
-exports.HttpError = HttpError;

package/dist-esm/error/http.error.js

@@ -1,9 +0,0 @@
-import { AppError } from './app.error';
-/**
- * Base class for HTTP errors - errors that define HTTP error code.
- */
-export class HttpError extends AppError {
-    constructor(message, data, opt) {
-        super(message, data, opt, 'HttpError');
-    }
-}

package/src/error/http.error.ts

@@ -1,13 +0,0 @@
-import { AppError } from './app.error'
-import type { HttpErrorData } from './error.model'
-
-/**
- * Base class for HTTP errors - errors that define HTTP error code.
- */
-export class HttpError<
-  DATA_TYPE extends HttpErrorData = HttpErrorData,
-> extends AppError<DATA_TYPE> {
-  constructor(message: string, data: DATA_TYPE, opt?: ErrorOptions) {
-    super(message, data, opt, 'HttpError')
-  }
-}