@hyper-fetch/graphql 7.5.2 → 8.0.0

package/__tests__/features/adapter/adapter.browser.spec.ts

@@ -0,0 +1,259 @@
+import { Client, getErrorMessage } from "@hyper-fetch/core";
+import { createGraphqlMockingServer } from "@hyper-fetch/testing";
+
+import { GraphqlAdapter } from "adapter";
+import type { GetUserQueryResponse } from "../../constants/queries.constants";
+import { getUserQuery, getUserQueryString } from "../../constants/queries.constants";
+import type { LoginMutationVariables } from "../../constants/mutations.constants";
+import { loginMutation } from "../../constants/mutations.constants";
+
+const { startServer, stopServer, resetMocks, mockRequest } = createGraphqlMockingServer();
+
+describe("Graphql Adapter [ Browser ]", () => {
+  let client = new Client({ url: "https://shared-base-url/graphql" }).setAdapter(GraphqlAdapter());
+  let request = client.createRequest<{ response: GetUserQueryResponse }>()({ endpoint: getUserQuery });
+  let mutation = client.createRequest<{ response: GetUserQueryResponse; payload: LoginMutationVariables }>()({
+    endpoint: loginMutation,
+  });
+
+  beforeAll(() => {
+    startServer();
+  });
+
+  beforeEach(() => {
+    client = new Client({ url: "https://shared-base-url/graphql" }).setAdapter(GraphqlAdapter());
+    request = client.createRequest<{ response: GetUserQueryResponse }>()({ endpoint: getUserQuery });
+    mutation = client.createRequest<{ response: GetUserQueryResponse; payload: LoginMutationVariables }>()({
+      endpoint: loginMutation,
+    });
+
+    resetMocks();
+    vi.resetAllMocks();
+  });
+
+  afterAll(() => {
+    stopServer();
+  });
+
+  it("should make a request and return success data with status", async () => {
+    const expected = mockRequest(request, { data: { username: "prc", firstName: "Maciej" } });
+
+    const { data, error, status, extra } = await request.send();
+
+    expect(expected.data).toStrictEqual(data);
+    expect(status).toBe(200);
+    expect(error).toBe(null);
+    expect(extra).toStrictEqual({
+      headers: { "content-type": "application/json", "content-length": "48" },
+      extensions: {},
+    });
+  });
+
+  it("should make a request with string endpoint", async () => {
+    const expected = mockRequest(request, { data: { username: "prc", firstName: "Maciej" } });
+
+    const { data, error, status, extra } = await client.createRequest()({ endpoint: getUserQueryString }).send({});
+
+    expect(expected.data).toStrictEqual(data);
+    expect(status).toBe(200);
+    expect(error).toBe(null);
+    expect(extra).toStrictEqual({
+      headers: { "content-type": "application/json", "content-length": "48" },
+      extensions: {},
+    });
+  });
+
+  it("should make a request and return error data with status", async () => {
+    const expected = mockRequest(request, { status: 400 });
+
+    const { data, error, status, extra } = await request.send();
+
+    expect(data).toBe(null);
+    expect(status).toBe(400);
+    expect(error).toStrictEqual(expected.errors);
+    expect(extra).toStrictEqual({
+      headers: { "content-type": "application/json", "content-length": "42" },
+      extensions: {},
+    });
+  });
+
+  it("should allow to make mutation request", async () => {
+    const expected = mockRequest(
+      mutation.setPayload({
+        username: "Kacper",
+        password: "Kacper1234",
+      }),
+      { data: { username: "prc", firstName: "Maciej" } },
+    );
+
+    const { data, error, status, extra } = await mutation
+      .setPayload({
+        username: "Kacper",
+        password: "Kacper1234",
+      })
+      .send();
+
+    expect(expected.data).toStrictEqual(data);
+    expect(status).toBe(200);
+    expect(error).toBe(null);
+    expect(extra).toStrictEqual({
+      headers: { "content-type": "application/json", "content-length": "48" },
+      extensions: {},
+    });
+  });
+
+  it("should allow to cancel request and return error", async () => {
+    mockRequest(request, { delay: 5 });
+
+    setTimeout(() => {
+      request.abort();
+    }, 2);
+
+    const { data, error } = await request.send();
+
+    expect(data).toBe(null);
+    expect(error).toStrictEqual([getErrorMessage("abort")]);
+  });
+
+  // it("should not throw when XMLHttpRequest is not available on window", async () => {
+  //   const expected = mockRequest(request, { delay: 20 });
+  //   const xml = window.XMLHttpRequest;
+  //   window.XMLHttpRequest = undefined as any;
+
+  //   const { data, error, status, extra } = await request.send();
+
+  //   expect(expected.data).toStrictEqual(data);
+  //   expect(status).toBe(200);
+  //   expect(error).toBe(null);
+  //   expect(extra).toMatchObject({
+  //     headers: { "content-type": "application/json", "content-length": "11" },
+  //     extensions: {},
+  //   });
+  //   window.XMLHttpRequest = xml;
+  // });
+
+  it("should allow to set options and timeout the request", async () => {
+    const timeoutRequest = request.setOptions({ timeout: 5 });
+    mockRequest(timeoutRequest, { delay: 500 });
+
+    const { data, error, status } = await timeoutRequest.send();
+
+    expect(data).toBeNull();
+    expect(status).toBe(0);
+    expect(error).toStrictEqual(getErrorMessage("timeout"));
+  });
+
+  it("should handle undefined response data as null", async () => {
+    mockRequest(request, { data: null });
+    const { data } = await request.send();
+    expect(data).toBe(null);
+  });
+
+  it("should use default error message when errors are null", async () => {
+    mockRequest(request, {
+      status: 400,
+      error: null,
+    });
+
+    const { error } = await request.send();
+    expect(error).toStrictEqual([getErrorMessage()]);
+  });
+
+  it("should fallback to response.text() when body.getReader is not available", async () => {
+    const responseData = JSON.stringify({ data: { username: "prc", firstName: "Maciej" } });
+    const originalFetch = global.fetch;
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      headers: new Headers({ "content-type": "application/json" }),
+      body: null,
+      text: () => Promise.resolve(responseData),
+    });
+
+    const { data, status, error } = await request.send();
+
+    expect(status).toBe(200);
+    expect(data).toStrictEqual({ username: "prc", firstName: "Maciej" });
+    expect(error).toBe(null);
+
+    global.fetch = originalFetch;
+  });
+
+  it("should handle network error in catch block when not aborted", async () => {
+    const originalFetch = global.fetch;
+    const networkError = new Error("Network failure");
+    global.fetch = vi.fn().mockRejectedValue(networkError);
+
+    const { data, error, status } = await request.send();
+
+    expect(data).toBeNull();
+    expect(status).toBe(0);
+    expect(error).toBe(networkError);
+
+    global.fetch = originalFetch;
+  });
+
+  it("should handle request with abort controller present", async () => {
+    mockRequest(request, { data: { username: "prc", firstName: "Maciej" } });
+
+    const { data, status, error } = await request.send();
+
+    expect(status).toBe(200);
+    expect(data).toStrictEqual({ username: "prc", firstName: "Maciej" });
+    expect(error).toBe(null);
+  });
+
+  it("should handle response with content-length header for progress tracking", async () => {
+    const responseData = JSON.stringify({ data: { username: "prc", firstName: "Maciej" } });
+    const encoder = new TextEncoder();
+    const encoded = encoder.encode(responseData);
+    const originalFetch = global.fetch;
+
+    let readerDone = false;
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      headers: new Headers({
+        "content-type": "application/json",
+        "content-length": String(encoded.length),
+      }),
+      body: {
+        getReader: () => ({
+          read: () => {
+            if (!readerDone) {
+              readerDone = true;
+              return Promise.resolve({ done: false, value: encoded });
+            }
+            return Promise.resolve({ done: true, value: undefined });
+          },
+        }),
+      },
+    });
+
+    const { data, status } = await request.send();
+
+    expect(status).toBe(200);
+    expect(data).toStrictEqual({ username: "prc", firstName: "Maciej" });
+
+    global.fetch = originalFetch;
+  });
+
+  it("should handle failure response when body has no getReader", async () => {
+    const originalFetch = global.fetch;
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: false,
+      status: 500,
+      headers: new Headers({ "content-type": "application/json" }),
+      body: null,
+      text: () => Promise.resolve(JSON.stringify({ errors: ["Internal Server Error"] })),
+    });
+
+    const { data, error, status } = await request.send();
+
+    expect(data).toBeNull();
+    expect(status).toBe(500);
+    expect(error).toStrictEqual(["Internal Server Error"]);
+
+    global.fetch = originalFetch;
+  });
+});

package/__tests__/features/adapter/adapter.server.spec.ts

@@ -0,0 +1,234 @@
+/**
+ * @vitest-environment node
+ */
+import { Client, getErrorMessage } from "@hyper-fetch/core";
+import { createGraphqlMockingServer } from "@hyper-fetch/testing";
+
+import { GraphqlAdapter, GraphqlMethod } from "../../../src/adapter";
+import type { GetUserQueryResponse } from "../../constants/queries.constants";
+import { getUserQuery, getUserQueryString } from "../../constants/queries.constants";
+import type { LoginMutationVariables } from "../../constants/mutations.constants";
+import { loginMutation } from "../../constants/mutations.constants";
+
+const { startServer, stopServer, resetMocks, mockRequest } = createGraphqlMockingServer();
+
+describe("Graphql Adapter [ Server ]", () => {
+  const requestId = "test";
+  let clientHttp = new Client({ url: "http://shared-base-url/graphql" }).setAdapter(GraphqlAdapter()).setDebug(true);
+  let client = new Client({ url: "https://shared-base-url/graphql" }).setAdapter(GraphqlAdapter()).setDebug(true);
+  let requestHttp = clientHttp.createRequest<{ response: GetUserQueryResponse }>()({ endpoint: getUserQuery });
+  let request = client.createRequest<{ response: GetUserQueryResponse }>()({ endpoint: getUserQuery });
+  let mutation = client.createRequest<{ response: GetUserQueryResponse; payload: LoginMutationVariables }>()({
+    endpoint: loginMutation,
+  });
+
+  beforeAll(() => {
+    startServer();
+  });
+
+  beforeEach(() => {
+    clientHttp = new Client({ url: "http://shared-base-url/graphql" }).setAdapter(GraphqlAdapter());
+    client = new Client({ url: "https://shared-base-url/graphql" }).setAdapter(GraphqlAdapter());
+    requestHttp = clientHttp.createRequest<{ response: GetUserQueryResponse }>()({ endpoint: getUserQuery });
+    request = client.createRequest<{ response: GetUserQueryResponse }>()({ endpoint: getUserQuery });
+    mutation = client.createRequest<{ response: GetUserQueryResponse; payload: LoginMutationVariables }>()({
+      endpoint: loginMutation,
+    });
+    client.appManager.isBrowser = false;
+  });
+
+  afterEach(() => {
+    client.clear();
+    vi.resetAllMocks();
+    vi.clearAllMocks();
+    vi.restoreAllMocks();
+    resetMocks();
+  });
+
+  afterAll(() => {
+    stopServer();
+  });
+
+  it("should pick correct adapter and not throw", async () => {
+    mockRequest(request);
+    client.appManager.isBrowser = true;
+
+    const adapter = GraphqlAdapter();
+
+    expect(adapter).toBeDefined();
+  });
+
+  it("should pick http module", async () => {
+    mockRequest(requestHttp);
+    clientHttp.requestManager.addAbortController(requestHttp.abortKey, requestId);
+
+    const res = await clientHttp.adapter.fetch(
+      clientHttp.createRequest<{ response: GetUserQueryResponse }>()({ endpoint: getUserQuery }),
+      requestId,
+    );
+
+    expect(res.data).toBeDefined();
+  });
+
+  it("should handle http and https urls", async () => {
+    mockRequest(requestHttp);
+
+    const res = await requestHttp.send();
+
+    expect(res.data).toBeDefined();
+  });
+
+  it("should make a request and return success data with status", async () => {
+    const expected = mockRequest(request, { delay: 10, data: { username: "prc", firstName: "Maciej" } });
+
+    const { data, error, status, extra } = await request.send();
+
+    expect(error).toBe(null);
+    expect(expected.data).toStrictEqual(data);
+    expect(status).toBe(200);
+    expect(extra).toMatchObject({
+      headers: { "content-type": "application/json", "content-length": "48" },
+      extensions: {},
+    });
+  });
+
+  it("should make a request with string endpoint", async () => {
+    const expected = mockRequest(request, { data: { username: "prc", firstName: "Maciej" } });
+
+    const { data, error, status, extra } = await client.createRequest()({ endpoint: getUserQueryString }).send({});
+
+    expect(expected.data).toStrictEqual(data);
+    expect(status).toBe(200);
+    expect(error).toBe(null);
+    expect(extra).toMatchObject({
+      headers: { "content-type": "application/json", "content-length": "48" },
+      extensions: {},
+    });
+  });
+  it("should make a get request with string endpoint", async () => {
+    const req = client.createRequest<{ response: GetUserQueryResponse }>()({
+      endpoint: getUserQueryString,
+      method: GraphqlMethod.GET,
+    });
+    const expected = mockRequest(req, { data: { username: "prc", firstName: "Maciej" } });
+
+    const { data, error, status, extra } = await req.send({});
+
+    expect(expected.data).toStrictEqual(data);
+    expect(status).toBe(200);
+    expect(error).toBe(null);
+    expect(extra).toMatchObject({
+      headers: { "content-type": "application/json", "content-length": "48" },
+      extensions: {},
+    });
+  });
+
+  it("should make a request and return error data with status", async () => {
+    const expected = mockRequest(request, { status: 400 });
+
+    const { data, error, status, extra } = await request.send();
+
+    expect(data).toBe(null);
+    expect(status).toBe(400);
+    expect(error).toStrictEqual(expected.errors);
+    expect(extra).toMatchObject({
+      headers: { "content-type": "application/json", "content-length": "42" },
+      extensions: {},
+    });
+  });
+
+  it("should allow to make mutation request", async () => {
+    const req = mutation.setPayload({
+      username: "Kacper",
+      password: "Kacper1234",
+    });
+    const expected = mockRequest(req, { data: { username: "prc", firstName: "Maciej" } });
+
+    const { data, error, status, extra } = await req.send();
+
+    expect(data).toStrictEqual(expected.data);
+    expect(status).toBe(200);
+    expect(error).toBe(null);
+    expect(extra).toMatchObject({
+      headers: { "content-type": "application/json", "content-length": "48" },
+      extensions: {},
+    });
+  });
+
+  it("should handle undefined response data as null", async () => {
+    mockRequest(request, { data: null });
+    const { data } = await request.send();
+    expect(data).toBe(null);
+  });
+
+  it("should use default error message when errors are null", async () => {
+    mockRequest(request, {
+      status: 400,
+      error: null,
+    });
+
+    const { error } = await request.send();
+    expect(error).toStrictEqual([getErrorMessage()]);
+  });
+
+  it("should allow to set options and timeout the request", async () => {
+    const timeoutRequest = request.setOptions({ timeout: 5 });
+    mockRequest(timeoutRequest, { delay: 500 });
+
+    const { data, error, status } = await timeoutRequest.send();
+
+    expect(data).toBeNull();
+    expect(status).toBe(0);
+    expect(error).toStrictEqual(getErrorMessage("timeout"));
+  });
+
+  // it("should allow to calculate payload size", async () => {
+  //   let receivedOptions: any;
+
+  //   vi.spyOn(https, "request").mockImplementation((url, options, callback) => {
+  //     receivedOptions = options;
+  //     return requestCopy(options, callback);
+  //   });
+  //   mockRequest(mutation);
+
+  //   await mutation.send({
+  //     payload: {
+  //       username: "Kacper",
+  //       password: "Kacper1234",
+  //     },
+  //   });
+
+  //   expect(receivedOptions.headers["Content-Length"]).toBeGreaterThan(0);
+  // });
+
+  // it("should allow to calculate Buffer size", async () => {
+  //   let receivedOptions: any;
+
+  //   vi.spyOn(https, "request").mockImplementation((url, options, callback) => {
+  //     receivedOptions = options;
+  //     return requestCopy(options, callback);
+  //   });
+  //   mockRequest(mutation);
+
+  //   const buffer = Buffer.from("test");
+
+  //   await mutation.send({
+  //     payload: buffer as any,
+  //   });
+
+  //   expect(receivedOptions.headers["Content-Length"]).toBeGreaterThan(0);
+  // });
+
+  it("should allow to cancel request and return error", async () => {
+    mockRequest(request, { delay: 5 });
+
+    setTimeout(() => {
+      request.abort();
+    }, 2);
+
+    const { data, error } = await request.send();
+
+    expect(data).toBe(null);
+    expect(error).toStrictEqual([getErrorMessage("abort")]);
+  });
+});

package/__tests__/features/adapter/adapter.utils.spec.ts

@@ -0,0 +1,86 @@
+import { Client } from "@hyper-fetch/core";
+
+import { GraphqlMethod, getRequestValues, GraphqlAdapter } from "adapter";
+import { gqlEndpointNameMapper } from "../../../src/adapter/adapter.utils";
+import { getUserQuery, getUserQueryString } from "../../constants/queries.constants";
+
+describe("Graphql Adapter [ Utils ]", () => {
+  let client = new Client({ url: "https://shared-base-url/graphql" }).setAdapter(GraphqlAdapter());
+  let request = client.createRequest<{ response: any; payload: any }>()({
+    endpoint: getUserQuery,
+    method: GraphqlMethod.POST,
+  });
+  let requestGet = client.createRequest<{ response: any; payload: any }>()({
+    endpoint: getUserQueryString,
+    method: GraphqlMethod.GET,
+  });
+
+  beforeEach(() => {
+    client = new Client({ url: "https://shared-base-url/graphql" }).setAdapter(GraphqlAdapter());
+    request = client.createRequest<{ response: any; payload: any }>()({
+      endpoint: getUserQuery,
+      method: GraphqlMethod.POST,
+    });
+    requestGet = client.createRequest<{ response: any; payload: any }>()({
+      endpoint: getUserQueryString,
+      method: GraphqlMethod.GET,
+    });
+
+    vi.resetAllMocks();
+    vi.clearAllMocks();
+    vi.restoreAllMocks();
+  });
+
+  describe("When using getRequestValues", () => {
+    it("should generate values", async () => {
+      const { fullUrl, payload } = getRequestValues(request);
+
+      expect(fullUrl).toBe("https://shared-base-url/graphql");
+      expect(payload).toBe('{"query":"query GetUser {\\n  username {\\n    username\\n    firstName\\n  }\\n}"}');
+      expect(request.method).toBe("POST");
+      expect(request.endpoint).toBeString();
+    });
+    it("should generate values for GET", async () => {
+      const { fullUrl, payload } = getRequestValues(requestGet);
+
+      expect(fullUrl).toBe(
+        "https://shared-base-url/graphql?query=%0Aquery%20GetUser%20%7B%0A%20%20username%20%7B%0A%20%20%20%20username%0A%20%20%20%20firstName%0A%20%20%7D%0A%7D%0A",
+      );
+      expect(payload).toBeNull();
+      expect(requestGet.method).toBe("GET");
+      expect(requestGet.endpoint).toBeString();
+    });
+  });
+
+  describe("When using gqlEndpointNameMapper", () => {
+    it("should return operation name for a named query", () => {
+      const result = gqlEndpointNameMapper("query GetUser { username { username firstName } }");
+      expect(result).toBe("GetUser");
+    });
+
+    it("should return field name when operation has no name", () => {
+      const result = gqlEndpointNameMapper("query { username { username firstName } }");
+      expect(result).toBe("username");
+    });
+
+    it("should fallback when operation has no name and selection is not a Field", () => {
+      const result = gqlEndpointNameMapper("query { ... on User { username } }");
+      expect(result).toBe("User");
+    });
+
+    it("should return 'graphql-request' when endpoint is empty after cleanup", () => {
+      const result = gqlEndpointNameMapper("{}");
+      expect(result).toBe("graphql-request");
+    });
+
+    it("should use fallback when parse throws (invalid graphql)", () => {
+      const result = gqlEndpointNameMapper("not a valid graphql string at all");
+      expect(result).toBe("not");
+    });
+
+    it("should return 'graphql-request' when entire fallback string is empty", () => {
+      const result = gqlEndpointNameMapper("query");
+      expect(result).toBe("graphql-request");
+    });
+  });
+});

package/__tests__/request-module.d.ts

@@ -0,0 +1,12 @@
+/** Ambient shim: core uses `baseUrl` `request` → `src/request`; gql test tsconfig resolves bare `request` to npm. */
+declare module "request" {
+  export type RequestInstance = object;
+
+  export function getProgressValue(event: { loaded?: number; total?: number }): number;
+
+  export function getRequestEta(
+    startDate: Date,
+    progressDate: Date,
+    event: { total: number; loaded: number },
+  ): { sizeLeft: number; timeLeft: number | null };
+}

package/__tests__/shared/callbacks.shared.ts

@@ -0,0 +1,11 @@
+import type { Mock } from "vitest";
+
+export const testCallbacksExecution = (callbacks: Array<Mock>) => {
+  callbacks.forEach((spyFn, index) => {
+    const nextSpy = callbacks[index + 1];
+    if (nextSpy) {
+      expect(spyFn).toHaveBeenCalledBefore(nextSpy);
+    }
+    expect(spyFn).toHaveBeenCalledTimes(1);
+  });
+};

package/__tests__/shared/index.ts

@@ -0,0 +1,2 @@
+export * from "./callbacks.shared";
+export * from "./progress.shared";

package/__tests__/shared/progress.shared.ts

@@ -0,0 +1,40 @@
+import type { RequestInstance } from "request";
+import { getProgressValue, getRequestEta } from "request";
+
+export const testProgressSpy = (props: {
+  spy: () => void;
+  requestId: string;
+  request: RequestInstance;
+  startTimestamp: number;
+  progressTimestamp?: number;
+  total?: number;
+  loaded?: number;
+  timeLeft?: number;
+}) => {
+  const { spy, requestId, request, startTimestamp, total, loaded, timeLeft, progressTimestamp } = props;
+
+  const totalValue = total ?? 1;
+  const loadedValue = loaded ?? 0;
+
+  const estimatedTime = getRequestEta(new Date(startTimestamp), new Date(progressTimestamp || startTimestamp), {
+    total: totalValue,
+    loaded: loadedValue,
+  }).timeLeft;
+  const timeToSend = loadedValue ? estimatedTime : null;
+
+  expect(spy).toHaveBeenCalledTimes(1);
+  expect(spy).toHaveBeenCalledWith(
+    {
+      loaded: loadedValue,
+      progress: getProgressValue({ total: totalValue, loaded: loadedValue }),
+      sizeLeft: totalValue - loadedValue,
+      startTimestamp,
+      timeLeft: timeLeft ?? timeToSend,
+      total: totalValue,
+    },
+    {
+      request,
+      requestId,
+    },
+  );
+};

package/__tests__/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "lib": ["dom", "dom.iterable", "ESNext"],
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "types": ["vitest/globals", "jest-extended", "@types/node"],
+    "baseUrl": "../src",
+    "paths": {
+      "@hyper-fetch/graphql": ["../src"]
+    }
+  },
+  "include": ["**/*.ts", "**/*.tsx", "../../../global.d.ts", "../../../vitest.d.ts"]
+}

package/__tests__/vitest.setup.ts

@@ -0,0 +1,10 @@
+/// <reference types="vitest/globals" />
+import { AbortController } from "abortcontroller-polyfill/dist/cjs-ponyfill";
+import * as matchers from "jest-extended";
+import { expect } from "vitest";
+
+expect.extend(matchers);
+
+if (!globalThis.AbortController) {
+  globalThis.AbortController = AbortController as any;
+}

package/dist/adapter/adapter.constants.d.ts

@@ -0,0 +1,4 @@
+import { GraphQlExtraType } from './adapter.types';
+export declare const defaultTimeout: number;
+export declare const gqlExtra: GraphQlExtraType;
+//# sourceMappingURL=adapter.constants.d.ts.map