@fleet-sdk/blockchain-providers 0.5.0 → 0.6.0

package/src/utils/_tests.ts

@@ -1,12 +1,8 @@
-export const mockResponse = (data: string) => {
-  return {
+// export const mockSuccessResponse = (data: unknown) => resolveString(JSON.stringify(data));
+
+export const resolveString = (data: string) =>
+  ({
     text: () => new Promise((resolve) => resolve(data))
-  } as unknown as Response;
-};
+  }) as unknown as Response;
 
-export const mockChunkedResponse = (chunks: string[]) => {
-  let i = 0;
-  return {
-    text: () => new Promise((resolve) => resolve(chunks[i++]))
-  } as unknown as Response;
-};
+export const resolveData = (data: unknown) => resolveString(JSON.stringify(data));

package/src/utils/graphql.ts

@@ -5,17 +5,15 @@ import {
   isEmpty,
   some
 } from "@fleet-sdk/common";
+import type { FallbackRetryOptions, ParserLike } from "./networking";
+import { request } from "./networking";
 
 const OP_NAME_REGEX = /(query|mutation)\s?([\w\-_]+)?/;
-export const DEFAULT_HEADERS: Headers = {
+export const DEFAULT_HEADERS = {
   "content-type": "application/json; charset=utf-8",
   accept: "application/graphql-response+json, application/json"
 };
 
-type Credentials = RequestCredentials;
-type Headers = HeadersInit;
-type Fetcher = typeof fetch;
-
 export type GraphQLVariables = Record<string, unknown> | null;
 
 export interface GraphQLError {
@@ -36,84 +34,80 @@ export type GraphQLResponse<T = unknown> =
   | GraphQLSuccessResponse<T>
   | GraphQLErrorResponse;
 
-export type GraphQLOperation<
+export type GraphQLOperation<R extends GraphQLResponse, V extends GraphQLVariables> = (
+  variables?: V,
+  url?: string
+) => Promise<R>;
+
+export type GraphQLRequiredUrlOperation<
   R extends GraphQLResponse,
   V extends GraphQLVariables
-> = (variables?: V) => Promise<R>;
+> = (variables: V | undefined, url: string) => Promise<R>;
 
-export interface ResponseParser {
-  parse<T>(text: string): T;
-  stringify<T>(value: T): string;
-}
-
-export interface RequestParams {
+interface RequestParams {
   operationName?: string | null;
   query: string;
   variables?: Record<string, unknown> | null;
 }
 
 export interface GraphQLRequestOptions {
-  url: URL | string;
-  headers?: Headers;
-  parser?: ResponseParser;
-  fetcher?: Fetcher;
-  credentials?: Credentials;
+  url?: string;
+  parser?: ParserLike;
+  retry?: FallbackRetryOptions;
   throwOnNonNetworkErrors?: boolean;
+  httpOptions?: Omit<RequestInit, "body" | "method">;
 }
 
-export interface GraphQLThrowableOptions extends GraphQLRequestOptions {
-  throwOnNonNetworkErrors: true;
-}
-
-export function createGqlOperation<
-  R,
-  V extends GraphQLVariables = GraphQLVariables
->(
+export function createGqlOperation<R, V extends GraphQLVariables = GraphQLVariables>(
   query: string,
-  options: GraphQLThrowableOptions
+  options: GraphQLRequestOptions & { throwOnNonNetworkErrors: true }
 ): GraphQLOperation<GraphQLSuccessResponse<R>, V>;
-export function createGqlOperation<
-  R,
-  V extends GraphQLVariables = GraphQLVariables
->(
+export function createGqlOperation<R, V extends GraphQLVariables = GraphQLVariables>(
+  query: string,
+  options?: GraphQLRequestOptions & { url: undefined }
+): GraphQLRequiredUrlOperation<GraphQLResponse<R>, V>;
+export function createGqlOperation<R, V extends GraphQLVariables = GraphQLVariables>(
+  query: string,
+  options: GraphQLRequestOptions & { url: undefined; throwOnNonNetworkErrors: true }
+): GraphQLRequiredUrlOperation<GraphQLSuccessResponse<R>, V>;
+export function createGqlOperation<R, V extends GraphQLVariables = GraphQLVariables>(
   query: string,
   options: GraphQLRequestOptions
 ): GraphQLOperation<GraphQLResponse<R>, V>;
-export function createGqlOperation<
-  R,
-  V extends GraphQLVariables = GraphQLVariables
->(
+export function createGqlOperation<R, V extends GraphQLVariables = GraphQLVariables>(
   query: string,
-  options: GraphQLRequestOptions
-): GraphQLOperation<GraphQLResponse<R>, V> {
-  return async (variables?: V): Promise<GraphQLResponse<R>> => {
-    const response = await (options.fetcher ?? fetch)(options.url, {
-      method: "POST",
-      headers: ensureDefaults(options.headers, DEFAULT_HEADERS),
-      credentials: options.credentials,
-      body: (options.parser ?? JSON).stringify({
-        operationName: getOpName(query),
-        query,
-        variables: variables ? clearUndefined(variables) : undefined
-      } as RequestParams)
+  options?: GraphQLRequestOptions
+):
+  | GraphQLOperation<GraphQLResponse<R>, V>
+  | GraphQLRequiredUrlOperation<GraphQLResponse<R>, V> {
+  return async (variables?: V, url?: string): Promise<GraphQLResponse<R>> => {
+    url = url ?? options?.url;
+    if (!url) throw new Error("URL is required");
+
+    const response = await request<GraphQLResponse<R>>(url, {
+      ...options,
+      httpOptions: {
+        ...options?.httpOptions,
+        method: "POST",
+        headers: ensureDefaults(options?.httpOptions?.headers, DEFAULT_HEADERS),
+        body: (options?.parser ?? JSON).stringify({
+          operationName: getOpName(query),
+          query,
+          variables: variables ? clearUndefined(variables) : undefined
+        } as RequestParams)
+      }
     });
 
-    const rawData = await response.text();
-    const parsedData = (options.parser ?? JSON).parse(
-      rawData
-    ) as GraphQLResponse<R>;
-
     if (
-      options.throwOnNonNetworkErrors &&
-      some(parsedData.errors) &&
-      isEmpty(parsedData.data)
+      options?.throwOnNonNetworkErrors &&
+      some(response.errors) &&
+      isEmpty(response.data)
     ) {
-      throw new BlockchainProviderError(parsedData.errors[0].message, {
-        cause: parsedData.errors
-      });
+      const msg = response.errors[0].message;
+      throw new BlockchainProviderError(msg, { cause: response.errors });
     }
 
-    return parsedData;
+    return response;
   };
 }
 
@@ -126,7 +120,5 @@ export function getOpName(query: string): string | undefined {
 }
 
 export function isRequestParam(obj: unknown): obj is GraphQLRequestOptions {
-  return (
-    typeof obj === "object" && (obj as GraphQLRequestOptions).url !== undefined
-  );
+  return typeof obj === "object" && (obj as GraphQLRequestOptions).url !== undefined;
 }

package/src/utils/networking.ts

@@ -0,0 +1,84 @@
+import { some } from "@fleet-sdk/common";
+import { isEmpty } from "packages/common/src";
+
+export interface ParserLike {
+  parse<T>(text: string): T;
+  stringify<T>(value: T): string;
+}
+
+export type Route = { base: string; path: string; query?: Record<string, unknown> };
+export type URLLike = string | Route;
+export type FallbackRetryOptions = { fallbacks?: URLLike[] } & RetryOptions;
+
+export type FetchOptions = {
+  parser?: ParserLike;
+  base?: string;
+  query?: Record<string, unknown>;
+  retry?: FallbackRetryOptions;
+  httpOptions?: RequestInit;
+};
+
+export async function request<T>(path: string, opt?: Partial<FetchOptions>): Promise<T> {
+  const url = buildURL(path, opt?.query, opt?.base);
+
+  let response: Response;
+  if (opt?.retry) {
+    const routes = some(opt.retry.fallbacks) ? [url, ...opt.retry.fallbacks] : [url];
+    const attempts = opt.retry.attempts;
+    response = await exponentialRetry(
+      (r) => fetch(resolveUrl(routes, attempts - r), opt.httpOptions),
+      opt.retry
+    );
+  } else {
+    response = await fetch(url, opt?.httpOptions);
+  }
+
+  return (opt?.parser || JSON).parse(await response.text());
+}
+
+function resolveUrl(routes: URLLike[], attempt: number) {
+  const route = routes[attempt % routes.length];
+  return typeof route === "string"
+    ? route
+    : buildURL(route.path, route.query, route.base).toString();
+}
+
+function buildURL(path: string, query?: Record<string, unknown>, base?: string) {
+  if (!base && !query) return path;
+
+  const url = new URL(path, base);
+  if (some(query)) {
+    for (const key in query) url.searchParams.append(key, String(query[key]));
+  }
+
+  return url.toString();
+}
+
+export type RetryOptions = {
+  attempts: number;
+  delay: number;
+};
+
+/**
+ * Retries an asynchronous operation a specified number of times with a delay
+ * growing exponentially between each attempt.
+ * @param operation - The asynchronous operation to retry.
+ * @param options - The retry options.
+ * @returns A promise that resolves to the result of the operation, or undefined
+ * if all attempts fail.
+ */
+export async function exponentialRetry<T>(
+  operation: (remainingAttempts: number) => Promise<T>,
+  { attempts, delay }: RetryOptions
+): Promise<T> {
+  try {
+    return await operation(attempts);
+  } catch (e) {
+    if (attempts > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      return exponentialRetry(operation, { attempts: attempts - 1, delay: delay * 2 });
+    }
+
+    throw e;
+  }
+}