@naturalcycles/js-lib 14.265.0 → 14.266.0

package/dist/bot.js

@@ -64,7 +64,7 @@ class BotDetectionService {
         // if (userAgent.includes('Chrome') && !(globalThis as any).chrome) {
         //   return BotReason.ChromeWithoutChrome // Headless Chrome
         // }
-        if (this.cfg.treatCDPAsBotReason && this.detectCDP()) {
+        if (this.cfg.treatCDPAsBotReason && this.isCDP()) {
             return BotReason.CDP;
         }
         return null;

package/dist/http/fetcher.d.ts

@@ -3,7 +3,7 @@
 /// <reference lib="dom.iterable" preserve="true" />
 import { HttpRequestError } from '../error/error.util';
 import { ErrorDataTuple } from '../types';
-import type { FetcherAfterResponseHook, FetcherBeforeRequestHook, FetcherBeforeRetryHook, FetcherCfg, FetcherNormalizedCfg, FetcherOnErrorHook, FetcherOptions, FetcherResponse, RequestInitNormalized } from './fetcher.model';
+import { FetcherAfterResponseHook, FetcherBeforeRequestHook, FetcherBeforeRetryHook, FetcherCfg, FetcherGraphQLOptions, FetcherNormalizedCfg, FetcherOnErrorHook, FetcherOptions, FetcherResponse, RequestInitNormalized } from './fetcher.model';
 /**
  * Experimental wrapper around Fetch.
  * Works in both Browser and Node, using `globalThis.fetch`.
@@ -43,6 +43,18 @@ export declare class Fetcher {
     patchVoid: (url: string, opt?: FetcherOptions) => Promise<void>;
     deleteVoid: (url: string, opt?: FetcherOptions) => Promise<void>;
     headVoid: (url: string, opt?: FetcherOptions) => Promise<void>;
+    /**
+     * Small convenience wrapper that allows to issue GraphQL queries.
+     * In practice, all it does is:
+     * - Defines convenience `query` input option
+     * - Unwraps `response.data`
+     * - Unwraps `response.errors` and throws, if it's defined (as GQL famously returns http 200 even for errors)
+     *
+     * Currently it only unwraps and uses the first error from the `errors` array, for simplicity.
+     *
+     * @experimental
+     */
+    queryGraphQL<T = unknown>(opt: FetcherGraphQLOptions): Promise<T>;
     /**
      * Returns raw fetchResponse.body, which is a ReadableStream<Uint8Array>
      *

package/dist/http/fetcher.js

@@ -106,6 +106,43 @@ class Fetcher {
     static create(cfg = {}) {
         return new Fetcher(cfg);
     }
+    /**
+     * Small convenience wrapper that allows to issue GraphQL queries.
+     * In practice, all it does is:
+     * - Defines convenience `query` input option
+     * - Unwraps `response.data`
+     * - Unwraps `response.errors` and throws, if it's defined (as GQL famously returns http 200 even for errors)
+     *
+     * Currently it only unwraps and uses the first error from the `errors` array, for simplicity.
+     *
+     * @experimental
+     */
+    async queryGraphQL(opt) {
+        opt.json = {
+            query: opt.query,
+            variables: opt.variables,
+        };
+        const res = await this.doFetch(opt);
+        if (res.err) {
+            throw res.err;
+        }
+        if (res.body.errors) {
+            // unwrap errors and throw
+            const err = res.body.errors[0];
+            // todo: consider creating a new GraphQLError class for this
+            throw new error_util_1.HttpRequestError(err.message, {
+                errors: res.body.errors, // full errors payload returned
+                response: res.fetchResponse,
+                responseStatusCode: res.statusCode,
+                requestUrl: res.req.fullUrl,
+                requestBaseUrl: this.cfg.baseUrl,
+                requestMethod: res.req.init.method,
+                requestSignature: res.signature,
+                requestDuration: Date.now() - res.req.started,
+            });
+        }
+        return res.body.data;
+    }
     // responseType=readableStream
     /**
      * Returns raw fetchResponse.body, which is a ReadableStream<Uint8Array>

package/dist/http/fetcher.model.d.ts

@@ -116,6 +116,10 @@ export interface FetcherRequest extends Omit<FetcherOptions, 'method' | 'headers
     retry5xx: boolean;
     started: UnixTimestampMillis;
 }
+export interface FetcherGraphQLOptions extends FetcherOptions {
+    query: string;
+    variables?: AnyObject;
+}
 export interface FetcherOptions {
     method?: HttpMethod;
     /**
@@ -253,3 +257,19 @@ export type FetcherResponseType = 'json' | 'text' | 'void' | 'arrayBuffer' | 'bl
  * e.g when mocking.
  */
 export type FetchFunction = (url: string, init: RequestInitNormalized) => Promise<Response>;
+export type GraphQLResponse<DATA> = GraphQLSuccessResponse<DATA> | GraphQLErrorResponse;
+export interface GraphQLSuccessResponse<DATA> {
+    data: DATA;
+    errors: never;
+}
+export interface GraphQLErrorResponse {
+    data: never;
+    errors: GraphQLFormattedError[];
+}
+/**
+ * Copy-pasted from `graphql` package, slimmed down.
+ * See: https://spec.graphql.org/draft/#sec-Errors
+ */
+export interface GraphQLFormattedError {
+    message: string;
+}

package/dist-esm/bot.js

@@ -61,7 +61,7 @@ export class BotDetectionService {
         // if (userAgent.includes('Chrome') && !(globalThis as any).chrome) {
         //   return BotReason.ChromeWithoutChrome // Headless Chrome
         // }
-        if (this.cfg.treatCDPAsBotReason && this.detectCDP()) {
+        if (this.cfg.treatCDPAsBotReason && this.isCDP()) {
             return BotReason.CDP;
         }
         return null;

package/dist-esm/http/fetcher.js

@@ -99,6 +99,43 @@ export class Fetcher {
     static create(cfg = {}) {
         return new _a(cfg);
     }
+    /**
+     * Small convenience wrapper that allows to issue GraphQL queries.
+     * In practice, all it does is:
+     * - Defines convenience `query` input option
+     * - Unwraps `response.data`
+     * - Unwraps `response.errors` and throws, if it's defined (as GQL famously returns http 200 even for errors)
+     *
+     * Currently it only unwraps and uses the first error from the `errors` array, for simplicity.
+     *
+     * @experimental
+     */
+    async queryGraphQL(opt) {
+        opt.json = {
+            query: opt.query,
+            variables: opt.variables,
+        };
+        const res = await this.doFetch(opt);
+        if (res.err) {
+            throw res.err;
+        }
+        if (res.body.errors) {
+            // unwrap errors and throw
+            const err = res.body.errors[0];
+            // todo: consider creating a new GraphQLError class for this
+            throw new HttpRequestError(err.message, {
+                errors: res.body.errors, // full errors payload returned
+                response: res.fetchResponse,
+                responseStatusCode: res.statusCode,
+                requestUrl: res.req.fullUrl,
+                requestBaseUrl: this.cfg.baseUrl,
+                requestMethod: res.req.init.method,
+                requestSignature: res.signature,
+                requestDuration: Date.now() - res.req.started,
+            });
+        }
+        return res.body.data;
+    }
     // responseType=readableStream
     /**
      * Returns raw fetchResponse.body, which is a ReadableStream<Uint8Array>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.265.0",
+  "version": "14.266.0",
   "scripts": {
     "prepare": "husky",
     "build": "dev-lib build-esm-cjs",

package/src/bot.ts

@@ -96,7 +96,7 @@ export class BotDetectionService {
     //   return BotReason.ChromeWithoutChrome // Headless Chrome
     // }
 
-    if (this.cfg.treatCDPAsBotReason && this.detectCDP()) {
+    if (this.cfg.treatCDPAsBotReason && this.isCDP()) {
       return BotReason.CDP
     }
 

package/src/http/fetcher.model.ts

@@ -152,6 +152,11 @@ export interface FetcherRequest
   started: UnixTimestampMillis
 }
 
+export interface FetcherGraphQLOptions extends FetcherOptions {
+  query: string
+  variables?: AnyObject
+}
+
 export interface FetcherOptions {
   method?: HttpMethod
 
@@ -325,3 +330,23 @@ export type FetcherResponseType =
  * e.g when mocking.
  */
 export type FetchFunction = (url: string, init: RequestInitNormalized) => Promise<Response>
+
+export type GraphQLResponse<DATA> = GraphQLSuccessResponse<DATA> | GraphQLErrorResponse
+
+export interface GraphQLSuccessResponse<DATA> {
+  data: DATA
+  errors: never
+}
+
+export interface GraphQLErrorResponse {
+  data: never
+  errors: GraphQLFormattedError[]
+}
+
+/**
+ * Copy-pasted from `graphql` package, slimmed down.
+ * See: https://spec.graphql.org/draft/#sec-Errors
+ */
+export interface GraphQLFormattedError {
+  message: string
+}

package/src/http/fetcher.ts

@@ -29,11 +29,12 @@ import { _jsonParse, _jsonParseIfPossible } from '../string/json.util'
 import { _stringify } from '../string/stringify'
 import { _ms, _since } from '../time/time.util'
 import { ErrorDataTuple, NumberOfMilliseconds, UnixTimestampMillis } from '../types'
-import type {
+import {
   FetcherAfterResponseHook,
   FetcherBeforeRequestHook,
   FetcherBeforeRetryHook,
   FetcherCfg,
+  FetcherGraphQLOptions,
   FetcherNormalizedCfg,
   FetcherOnErrorHook,
   FetcherOptions,
@@ -41,6 +42,7 @@ import type {
   FetcherResponse,
   FetcherResponseType,
   FetcherRetryOptions,
+  GraphQLResponse,
   RequestInitNormalized,
 } from './fetcher.model'
 import type { HttpStatusFamily } from './http.model'
@@ -171,6 +173,48 @@ export class Fetcher {
   deleteVoid!: (url: string, opt?: FetcherOptions) => Promise<void>
   headVoid!: (url: string, opt?: FetcherOptions) => Promise<void>
 
+  /**
+   * Small convenience wrapper that allows to issue GraphQL queries.
+   * In practice, all it does is:
+   * - Defines convenience `query` input option
+   * - Unwraps `response.data`
+   * - Unwraps `response.errors` and throws, if it's defined (as GQL famously returns http 200 even for errors)
+   *
+   * Currently it only unwraps and uses the first error from the `errors` array, for simplicity.
+   *
+   * @experimental
+   */
+  async queryGraphQL<T = unknown>(opt: FetcherGraphQLOptions): Promise<T> {
+    opt.json = {
+      query: opt.query,
+      variables: opt.variables,
+    }
+
+    const res = await this.doFetch<GraphQLResponse<T>>(opt)
+    if (res.err) {
+      throw res.err
+    }
+
+    if (res.body.errors) {
+      // unwrap errors and throw
+      const err = res.body.errors[0]!
+
+      // todo: consider creating a new GraphQLError class for this
+      throw new HttpRequestError(err.message, {
+        errors: res.body.errors, // full errors payload returned
+        response: res.fetchResponse,
+        responseStatusCode: res.statusCode,
+        requestUrl: res.req.fullUrl,
+        requestBaseUrl: this.cfg.baseUrl,
+        requestMethod: res.req.init.method,
+        requestSignature: res.signature,
+        requestDuration: Date.now() - res.req.started,
+      })
+    }
+
+    return res.body.data
+  }
+
   // responseType=readableStream
   /**
    * Returns raw fetchResponse.body, which is a ReadableStream<Uint8Array>