@hyper-fetch/graphql 7.5.2 → 7.5.3

package/__tests__/constants/mutations.constants.ts

@@ -0,0 +1,15 @@
+import gql from "graphql-tag";
+
+export const loginMutation = gql`
+  mutation Login($username: String!, $password: String!) {
+    login(username: $username, password: $password) {
+      username
+      password
+    }
+  }
+`;
+
+export type LoginMutationVariables = {
+  username: string;
+  password: string;
+};

package/__tests__/constants/queries.constants.ts

@@ -0,0 +1,24 @@
+import gql from "graphql-tag";
+
+export const getUserQueryString = `
+query GetUser {
+  username {
+    username
+    firstName
+  }
+}
+`;
+
+export const getUserQuery = gql`
+  query GetUser {
+    username {
+      username
+      firstName
+    }
+  }
+`;
+
+export type GetUserQueryResponse = {
+  username: string;
+  firstName: string;
+};

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

@@ -0,0 +1,169 @@
+import { Client, getErrorMessage } from "@hyper-fetch/core";
+import { createGraphqlMockingServer } from "@hyper-fetch/testing";
+
+import { GraphqlAdapter } from "adapter";
+import { GetUserQueryResponse, getUserQuery, getUserQueryString } from "../../constants/queries.constants";
+import { LoginMutationVariables, 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();
+    jest.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", async () => {
+    const xml = window.XMLHttpRequest;
+    let instance: null | XMLHttpRequest = null;
+    class ExtendedXml extends XMLHttpRequest {
+      constructor() {
+        super();
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        instance = this;
+      }
+    }
+
+    window.XMLHttpRequest = ExtendedXml;
+
+    const timeoutRequest = request.setOptions({ timeout: 50 });
+    mockRequest(timeoutRequest, { delay: 20 });
+    await timeoutRequest.send();
+    expect(instance!.timeout).toBe(50);
+
+    window.XMLHttpRequest = xml;
+  });
+
+  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()]);
+  });
+});

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

@@ -0,0 +1,241 @@
+/**
+ * @jest-environment node
+ */
+import { Client, getErrorMessage } from "@hyper-fetch/core";
+import { createGraphqlMockingServer } from "@hyper-fetch/testing";
+import https from "https";
+
+import { GraphqlAdapter, GraphqlMethod } from "../../../src/adapter";
+import { GetUserQueryResponse, getUserQuery, getUserQueryString } from "../../constants/queries.constants";
+import { LoginMutationVariables, loginMutation } from "../../constants/mutations.constants";
+
+const { startServer, stopServer, resetMocks, mockRequest } = createGraphqlMockingServer();
+
+describe("Graphql Adapter [ Server ]", () => {
+  const requestId = "test";
+  const requestCopy = https.request;
+  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();
+    jest.resetAllMocks();
+    jest.clearAllMocks();
+    jest.restoreAllMocks();
+    https.globalAgent.destroy();
+    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 pick https module", async () => {
+    mockRequest(request);
+    client.requestManager.addAbortController(request.abortKey, requestId);
+
+    const res = await clientHttp.adapter.fetch(request, requestId);
+
+    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", async () => {
+    let receivedOptions: any;
+
+    jest.spyOn(https, "request").mockImplementation((url, options, callback) => {
+      receivedOptions = options;
+      return requestCopy(options, callback);
+    });
+
+    const timeoutRequest = request.setOptions({ timeout: 10 });
+    mockRequest(timeoutRequest, { delay: 20 });
+
+    await timeoutRequest.send();
+
+    expect(receivedOptions.timeout).toBe(10);
+  });
+
+  // it("should allow to calculate payload size", async () => {
+  //   let receivedOptions: any;
+
+  //   jest.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;
+
+  //   jest.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,53 @@
+import { Client } from "@hyper-fetch/core";
+
+import { GraphqlMethod, getRequestValues, GraphqlAdapter } from "adapter";
+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,
+    });
+
+    jest.resetAllMocks();
+    jest.clearAllMocks();
+    jest.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();
+    });
+  });
+});

package/__tests__/global.d.ts

@@ -0,0 +1 @@
+import "jest-extended";

package/__tests__/jest.setup.ts

@@ -0,0 +1 @@
+import "jest-extended";

package/__tests__/shared/callbacks.shared.ts

@@ -0,0 +1,9 @@
+export const testCallbacksExecution = (callbacks: Array<jest.Mock<any, any>>) => {
+  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,39 @@
+import { RequestInstance, 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,13 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "noEmit": true,
+    "baseUrl": "../src",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "paths": {
+      "@hyper-fetch/graphql": ["../src"]
+    }
+  }
+}

package/jest.config.ts

@@ -0,0 +1,6 @@
+import type { Config } from "@jest/types";
+
+import { getJestConfig } from "../../jest.config";
+
+const config: Config.InitialOptions = getJestConfig();
+export default config;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyper-fetch/graphql",
-  "version": "7.5.2",
+  "version": "7.5.3",
   "description": "Simple graphql adapter",
   "author": "Maciej Pyrc <maciekpyrc@gmail.com>, Kacper Skawina <kacper.skawina@gmail.com>",
   "homepage": "https://hyperfetch.bettertyped.com/",

package/project.json

@@ -0,0 +1,4 @@
+{
+  "name": "graphql",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json"
+}