@avantstay/graphql-ts-client 10.7.0 → 10.9.0

package/package.json

@@ -1,57 +1,44 @@
 {
   "name": "@avantstay/graphql-ts-client",
-  "version": "10.7.0",
+  "version": "10.9.0",
   "description": "GraphQL Typescript Client Generator",
-  "author": "Wellington Guimaraes",
-  "license": "MIT",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
-  "scripts": {
-    "build": "tsup src/index.ts src/endpoint.ts --dts",
-    "test": "cross-env GQL_CLIENT_DIST_PATH='.' jest --watch",
-    "prepublishOnly": "yarn build"
-  },
-  "files": [
-    "dist",
-    "src"
-  ],
-  "engines": {
-    "node": ">=12"
-  },
+  "homepage": "https://github.com/avantstay/graphql-ts-client",
   "bugs": {
     "url": "https://github.com/avantstay/graphql-ts-client/issues"
   },
-  "homepage": "https://github.com/avantstay/graphql-ts-client#readme",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/avantstay/graphql-ts-client.git"
   },
-  "peerDependencies": {},
-  "prettier": {
-    "trailingComma": "es5",
-    "tabWidth": 2,
-    "proseWrap": "always",
-    "bracketSpacing": true,
-    "jsxBracketSameLine": false,
-    "semi": false,
-    "singleQuote": true,
-    "arrowParens": "avoid",
-    "endOfLine": "lf",
-    "printWidth": 130,
-    "htmlWhitespaceSensitivity": "ignore",
-    "jsxSingleQuote": false
-  },
-  "module": "dist/graphql-ts-client.esm.js",
-  "size-limit": [
-    {
-      "path": "dist/graphql-ts-client.cjs.production.min.js",
-      "limit": "10 KB"
+  "license": "MIT",
+  "author": "Wellington Guimaraes",
+  "contributors": [
+    "Felipe Pinheiro <felipe.pinheiro.90@hotmail.com>"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
     },
-    {
-      "path": "dist/graphql-ts-client.esm.js",
-      "limit": "10 KB"
+    "./dist/endpoint": {
+      "import": "./dist/endpoint.mjs",
+      "require": "./dist/endpoint.js",
+      "types": "./dist/endpoint.d.ts"
     }
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "typings": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
   ],
+  "scripts": {
+    "build": "tsup src/index.ts src/endpoint.ts --dts --format cjs,esm",
+    "prepublishOnly": "yarn build",
+    "test": "cross-env GQL_CLIENT_DIST_PATH='.' jest --watch"
+  },
   "dependencies": {
     "@types/md5": "^2.3.2",
     "axios": "^0.24.0",
@@ -87,7 +74,21 @@
     "tsup": "^6.5.0",
     "typescript": "^4.9.4"
   },
+  "peerDependencies": {},
+  "engines": {
+    "node": ">=12"
+  },
   "publishConfig": {
     "@avantstay:registry": "https://registry.npmjs.org/"
-  }
+  },
+  "size-limit": [
+    {
+      "path": "dist/graphql-ts-client.cjs.production.min.js",
+      "limit": "10 KB"
+    },
+    {
+      "path": "dist/graphql-ts-client.esm.js",
+      "limit": "10 KB"
+    }
+  ]
 }

package/src/__snapshots__/generateTypescriptClient.test.ts.snap

@@ -29,7 +29,7 @@ __export(exports, {
   client: () => client,
   default: () => stdin_default
 });
-var import_endpoint = __toModule(require("../dist/endpoint"));
+var import_endpoint = __toModule(require("./endpoint"));
 const formatGraphQL = (query) => query;
 const typesTree = {};
 let verbose = false;
@@ -79,7 +79,7 @@ var stdin_default = client;
 ",
   "typings": "// noinspection TypeScriptUnresolvedVariable, ES6UnusedImports, JSUnusedLocalSymbols, TypeScriptCheckImport
 import { DeepRequired } from "ts-essentials"
-import { Maybe, IResponseListener, Endpoint } from "../dist"
+import { Maybe, IResponseListener, Endpoint } from "."
 
 // Scalars
 export type IDate = string | Date
@@ -119,6 +119,7 @@ export declare const client: {
         __headers?: { [key: string]: string }
         __retry?: boolean
         __alias?: string
+        __url?: string
       },
       string,
       AllEnums

package/src/__testClient.d.ts

@@ -0,0 +1,164 @@
+// noinspection TypeScriptUnresolvedVariable, ES6UnusedImports, JSUnusedLocalSymbols, TypeScriptCheckImport
+import { DeepRequired } from "ts-essentials"
+import { Maybe, IResponseListener, Endpoint } from "."
+
+// Scalars
+export type IDate = string | Date
+export declare type ISODate = IDate
+
+// Enums
+
+export declare enum BookType {
+  dolor = "DOLOR",
+  ipsum = "IPSUM",
+  sit = "SIT",
+}
+
+type AllEnums = BookType
+
+// Args
+export interface BooksWithoutParamsArgs {}
+export interface BooksWithOptionalParamsArgs {
+  params?: BookSearchParamsAllOptional
+}
+export interface BooksWithRequiredParamsArgs {
+  params: BookSearchParamsSomeRequired
+}
+export interface FailingQueryArgs {
+  id: string
+}
+
+// Input/Output Types
+
+/**
+ * @deprecated Avoid directly using this interface. Instead, create a type alias based on the query/mutation return type.
+ */
+
+export interface Book {
+  title?: string
+  author?: string
+  type?: BookType
+  dateCreated?: ISODate
+  sequence?: BookSequence
+}
+
+/**
+ * @deprecated Avoid directly using this interface. Instead, create a type alias based on the query/mutation return type.
+ */
+
+export interface BookSequence {
+  previousBook?: Book
+  nextBook?: Book
+}
+
+/**
+ * @deprecated Avoid directly using this interface. Instead, create a type alias based on the query/mutation return type.
+ */
+
+export interface BookSearchParamsAllOptional {
+  title?: string
+  author?: string
+  createdAfter?: ISODate
+}
+
+/**
+ * @deprecated Avoid directly using this interface. Instead, create a type alias based on the query/mutation return type.
+ */
+
+export interface BookSearchParamsSomeRequired {
+  title: string
+  author?: string
+}
+
+/**
+ * @deprecated Avoid directly using this interface. Instead, create a type alias based on the query/mutation return type.
+ */
+
+export interface Query {
+  booksWithoutParams?: Book[]
+  booksWithOptionalParams?: Book[]
+  booksWithRequiredParams?: Book[]
+  failingQuery?: string
+}
+
+// Selection Types
+
+export interface BookSelection {
+  title?: boolean
+  author?: boolean
+  type?: boolean
+  dateCreated?: boolean
+  sequence?: BookSequenceSelection
+}
+
+export interface BookSequenceSelection {
+  previousBook?: BookSelection
+  nextBook?: BookSelection
+}
+
+export interface BookSearchParamsAllOptionalSelection {
+  title?: boolean
+  author?: boolean
+  createdAfter?: boolean
+}
+
+export interface BookSearchParamsSomeRequiredSelection {
+  title?: boolean
+  author?: boolean
+}
+
+export declare const myApiClient: {
+  addResponseListener: (listener: IResponseListener) => void
+  setHeader: (key: string, value: string) => void
+  setHeaders: (newHeaders: { [k: string]: string }) => void
+  setUrl: (url: string) => void
+  setRetryConfig: (options: {
+    max: number
+    waitBeforeRetry?: number
+    before?: IResponseListener
+  }) => void
+  queries: {
+    booksWithoutParams: Endpoint<
+      {
+        __headers?: { [key: string]: string }
+        __retry?: boolean
+        __alias?: string
+      } & BookSelection,
+      DeepRequired<Book[]>,
+      AllEnums
+    >
+    booksWithOptionalParams: Endpoint<
+      {
+        __headers?: { [key: string]: string }
+        __retry?: boolean
+        __alias?: string
+        __args?: BooksWithOptionalParamsArgs
+      } & BookSelection,
+      DeepRequired<Book[]>,
+      AllEnums
+    >
+    booksWithRequiredParams: Endpoint<
+      {
+        __headers?: { [key: string]: string }
+        __retry?: boolean
+        __alias?: string
+        __args: BooksWithRequiredParamsArgs
+      } & BookSelection,
+      DeepRequired<Book[]>,
+      AllEnums
+    >
+    failingQuery: Endpoint<
+      {
+        __headers?: { [key: string]: string }
+        __retry?: boolean
+        __alias?: string
+        __args: FailingQueryArgs
+      },
+      string,
+      AllEnums
+    >
+  }
+  mutations: {}
+}
+
+export default myApiClient

package/src/__testClient.js

@@ -0,0 +1,135 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  BookType: () => BookType,
+  default: () => stdin_default,
+  myApiClient: () => myApiClient
+});
+var import_endpoint = __toModule(require("./endpoint"));
+var import_standalone = __toModule(require("prettier/standalone"));
+var import_parser_graphql = __toModule(require("prettier/parser-graphql"));
+const formatGraphQL = (query) => (0, import_standalone.format)(query, { parser: "graphql", plugins: [import_parser_graphql.default] });
+const BookType = {
+  dolor: "DOLOR",
+  ipsum: "IPSUM",
+  sit: "SIT"
+};
+const typesTree = {
+  Query: {
+    get booksWithOptionalParams() {
+      return {
+        __fields: typesTree.Book,
+        __args: {
+          params: "BookSearchParamsAllOptional!"
+        }
+      };
+    },
+    get booksWithRequiredParams() {
+      return {
+        __fields: typesTree.Book,
+        __args: {
+          params: "BookSearchParamsSomeRequired!"
+        }
+      };
+    },
+    get failingQuery() {
+      return {
+        __args: {
+          id: "String!"
+        }
+      };
+    },
+    get booksWithoutParams() {
+      return {
+        __fields: typesTree.Book
+      };
+    }
+  },
+  Book: {
+    get sequence() {
+      return {
+        __fields: typesTree.BookSequence
+      };
+    }
+  },
+  BookSequence: {
+    get previousBook() {
+      return {
+        __fields: typesTree.Book
+      };
+    },
+    get nextBook() {
+      return {
+        __fields: typesTree.Book
+      };
+    }
+  }
+};
+let verbose = false;
+let headers = {};
+let url = "http://localhost:4123/graphql";
+let retryConfig = {
+  max: 0,
+  before: void 0,
+  waitBeforeRetry: 0
+};
+let responseListeners = [];
+let errorsParser = void 0;
+let apiEndpoint = (0, import_endpoint.getApiEndpointCreator)({
+  getClient: () => ({ url, headers, retryConfig }),
+  responseListeners,
+  maxAge: 3e4,
+  verbose,
+  typesTree,
+  formatGraphQL,
+  errorsParser
+});
+const myApiClient = {
+  addResponseListener: (listener) => responseListeners.push(listener),
+  setHeader: (key, value) => {
+    headers[key] = value;
+  },
+  setHeaders: (newHeaders) => {
+    headers = newHeaders;
+  },
+  setRetryConfig: (options) => {
+    if (!Number.isInteger(options.max) || options.max < 0) {
+      throw new Error("retryOptions.max should be a non-negative integer");
+    }
+    retryConfig = {
+      max: options.max,
+      waitBeforeRetry: options.waitBeforeRetry,
+      before: options.before
+    };
+  },
+  setUrl: (_url) => url = _url,
+  queries: {
+    booksWithoutParams: apiEndpoint("query", "booksWithoutParams"),
+    booksWithOptionalParams: apiEndpoint("query", "booksWithOptionalParams"),
+    booksWithRequiredParams: apiEndpoint("query", "booksWithRequiredParams"),
+    failingQuery: apiEndpoint("query", "failingQuery")
+  },
+  mutations: {}
+};
+var stdin_default = myApiClient;

package/src/endpoint.ts

@@ -2,14 +2,10 @@ import memoize from 'moize'
 import { graphqlRequest } from './graphqlRequest'
 import { jsonToGraphQLQuery } from './jsonToGraphQLQuery'
 import { logRequest } from './logging'
-import {ClientConfig, Endpoint, GraphQLClientError, IResponseListener, Projection, ResponseListenerInfo} from './types'
+import { ClientConfig, Endpoint, GraphQLClientError, IResponseListener, Projection, ResponseListenerInfo } from './types'
 
 const executeListeners = (listeners: IResponseListener[], data: ResponseListenerInfo) =>
-  setTimeout(() =>
-    listeners.forEach(runResponseListener =>
-      runResponseListener(data)
-    )
-  )
+  setTimeout(() => listeners.forEach(runResponseListener => runResponseListener(data)))
 
 export const getApiEndpointCreator =
   (apiConfig: {
@@ -32,7 +28,10 @@ export const getApiEndpointCreator =
       headers: any
       status: any
     }> => {
+      const clientConfig = apiConfig.getClient()
+
       const alias = (jsonQuery as any)?.__alias ?? queryName
+      const url = (jsonQuery as any)?.__url ?? clientConfig.url
       const shouldRetry = (jsonQuery as any)?.__retry ?? true
       const requestHeaders = (jsonQuery as any)?.__headers ?? {}
       const { query, variables } = jsonToGraphQLQuery({ kind, queryName, jsonQuery, typesTree: apiConfig.typesTree })
@@ -58,11 +57,11 @@ export const getApiEndpointCreator =
           shouldRetry,
           failureMode,
           queryName: alias,
-          client: apiConfig.getClient(),
+          client: { ...clientConfig, url },
           requestHeaders,
           query,
           variables,
-          errorsParser: apiConfig.errorsParser
+          errorsParser: apiConfig.errorsParser,
         })
 
         const response = { data, warnings, headers, status, errors }
@@ -75,7 +74,7 @@ export const getApiEndpointCreator =
           })
         }
 
-        executeListeners(apiConfig.responseListeners,{
+        executeListeners(apiConfig.responseListeners, {
           ...responseListenerData,
           response,
         })

package/src/generateTypescriptClient.test.ts

@@ -125,12 +125,12 @@ describe('Generated Client', () => {
     expect(responseData?.response.errors.length).toBeGreaterThan(0)
   })
 
-  it('should generate proper code from SDL', ()=>{
+  it('should generate proper code from SDL', () => {
     const sdlString = `
   type Query {
     hello: String
   }
-`;
-    expect(generateTypescriptClientFromSDL(sdlString, {endpoint: 'https://sample.endpoint.com/graphl'})).toMatchSnapshot()
+`
+    expect(generateTypescriptClientFromSDL(sdlString, { endpoint: 'https://sample.endpoint.com/graphl' })).toMatchSnapshot()
   })
 })

package/src/generateTypescriptClient.ts

@@ -6,8 +6,8 @@ import * as fs from 'fs'
 import { PathLike } from 'fs'
 import {
   buildSchema,
-  graphqlSync,
   getIntrospectionQuery,
+  graphqlSync,
   IntrospectionEnumType,
   IntrospectionField,
   IntrospectionInputObjectType,
@@ -17,7 +17,7 @@ import {
   IntrospectionType,
   Source,
 } from 'graphql'
-import { kebabCase } from 'lodash'
+import kebabCase from 'lodash/kebabCase'
 import orderBy from 'lodash/orderBy'
 import set from 'lodash/set'
 import md5 from 'md5'
@@ -25,6 +25,7 @@ import os from 'os'
 import path from 'path'
 import * as prettier from 'prettier'
 import pkg from '../package.json'
+import { TypescriptClientOutput } from './types'
 
 const tempDir = fs.realpathSync(os.tmpdir())
 
@@ -108,7 +109,7 @@ function gqlFieldToTypescript(
       })
     )
 
-    fieldTypeDefinition = `{ __headers?: {[key: string]: string}; __retry?: boolean; __alias?: string; __args${
+    fieldTypeDefinition = `{ __headers?: {[key: string]: string}; __retry?: boolean; __alias?: string; __url?: string; __args${
       fieldsOnArgs.every(arg => arg.isOptional) ? '?' : ''
     }: { ${fieldsOnArgs.map(arg => arg.code).join(', ')} }}${fieldTypeDefinition ? ` & ${fieldTypeDefinition}` : ''}`
   }
@@ -148,14 +149,14 @@ function gqlEndpointToCode(kind: 'mutation' | 'query', endpoint: IntrospectionFi
     __headers?: {[key: string]: string};
     __retry?: boolean;
     __alias?: string;
+    __url?: string;
     ${argsType ? `__args${argsType.optional ? '?' : ''}: ${argsType.alias}` : ''}
   }${selectionType ? ` & ${selectionType}` : ''}`
 
   const outputType = gqlTypeToTypescript(endpoint.type, { required: true })
-  const wrappedOutputType = /^(string|number|boolean)$/.test(outputType) ? outputType : `DeepRequired<${outputType}>`
 
   return codeOutputType === 'ts'
-    ? `${endpoint.name}: Endpoint<${inputType}, ${wrappedOutputType}, AllEnums>`
+    ? `${endpoint.name}: Endpoint<${inputType}, ${outputType}, AllEnums>`
     : `${endpoint.name}: apiEndpoint('${kind}', '${endpoint.name}')`
 }
 
@@ -314,7 +315,7 @@ type IClientOptions = {
   errorsParser?: (errors: any[]) => any
 }
 
-type FetchIntrospectionOptions = Omit< IClientOptions, 'output' | 'introspectionEndpoint'>
+type FetchIntrospectionOptions = Omit<IClientOptions, 'output' | 'introspectionEndpoint'>
 
 function generateClientCode(types: ReadonlyArray<IntrospectionType>, options: Omit<IClientOptions, 'output'>) {
   const typesHash = md5(`${JSON.stringify(options)}__${JSON.stringify(types)}`)
@@ -322,7 +323,11 @@ function generateClientCode(types: ReadonlyArray<IntrospectionType>, options: Om
   const clientCacheFilePath = path.resolve(tempDir, clientCacheFileName)
 
   if (!options.skipCache && fs.existsSync(clientCacheFilePath)) {
-    return JSON.parse(fs.readFileSync(clientCacheFilePath, { encoding: 'utf8' }))
+    const output: Partial<TypescriptClientOutput> = JSON.parse(fs.readFileSync(clientCacheFilePath, { encoding: 'utf8' }))
+
+    if (output.js && output.mjs && output.typings) {
+      return output as TypescriptClientOutput
+    }
   }
 
   const queries = (<IntrospectionObjectType>types.find(it => it.name === 'Query'))?.fields || []
@@ -472,8 +477,9 @@ function generateClientCode(types: ReadonlyArray<IntrospectionType>, options: Om
 
     export default ${clientName}`
 
-  const output = {
+  const output: TypescriptClientOutput = {
     js: esbuild.transformSync(jsCode, { format: 'cjs', loader: 'js' }).code,
+    mjs: esbuild.transformSync(jsCode, { format: 'esm', loader: 'js' }).code,
     typings: prettier.format(typingsCode, { semi: false, parser: 'typescript' }),
   }
 
@@ -500,7 +506,7 @@ async function fetchIntrospection({ endpoint, headers }: FetchIntrospectionOptio
         },
       }
     )
-    .catch(() => {
+    .catch(e => {
       const errorMessage = `The GraphQL introspection request failed (${endpoint})`
       if (fs.existsSync(introspectionCacheFilePath)) {
         const cachedSchema = JSON.parse(fs.readFileSync(introspectionCacheFilePath, { encoding: 'utf8' }))
@@ -508,6 +514,7 @@ async function fetchIntrospection({ endpoint, headers }: FetchIntrospectionOptio
         console.warn(`Successfully restored from local cache.`)
         return { data: cachedSchema }
       } else {
+        console.error(e)
         return Promise.reject(errorMessage)
       }
     })
@@ -525,10 +532,11 @@ async function fetchIntrospection({ endpoint, headers }: FetchIntrospectionOptio
   return types
 }
 
-type Client = { typings: string; js: string }
-
-function generateClient(introspectionTypes: ReadonlyArray<IntrospectionType>, {output,...restOptions}: IClientOptions): Client {
-  const { js, typings } = generateClientCode(introspectionTypes, restOptions)
+function generateClient(
+  introspectionTypes: ReadonlyArray<IntrospectionType>,
+  { output, ...restOptions }: IClientOptions
+): TypescriptClientOutput {
+  const { js, mjs, typings } = generateClientCode(introspectionTypes, restOptions)
 
   if (output && typeof output === 'string') {
     const outputDir = path.dirname(output)
@@ -539,12 +547,16 @@ function generateClient(introspectionTypes: ReadonlyArray<IntrospectionType>, {o
 
     fs.writeFileSync(output.replace(/(\.(ts|js))?$/, '.d.ts'), typings, { encoding: 'utf8' })
     fs.writeFileSync(output.replace(/(\.(ts|js))?$/, '.js'), js, { encoding: 'utf8' })
+    fs.writeFileSync(output.replace(/(\.(ts|js))?$/, '.mjs'), mjs, { encoding: 'utf8' })
   }
 
-  return { js, typings }
+  return { js, mjs, typings }
 }
 
-export async function generateTypescriptClient({ introspectionEndpoint, ...options }: IClientOptions): Promise<Client> {
+export async function generateTypescriptClient({
+  introspectionEndpoint,
+  ...options
+}: IClientOptions): Promise<TypescriptClientOutput> {
   console.log(`Generating TypeScript client (name: ${options.clientName ?? 'n/a'})`)
 
   axiosRetry(axios, { retries: 5, retryDelay: retryCount => 1000 * 2 ** retryCount })
@@ -555,14 +567,14 @@ export async function generateTypescriptClient({ introspectionEndpoint, ...optio
   })
 
   return generateClient(introspectionTypes, options)
-
 }
 
-export function generateTypescriptClientFromSDL(SDL: string, options: IClientOptions): Client {
-  console.log(`Generating TypeScript client from SDL (name: ${options.clientName ?? 'n/a'})`);
+export function generateTypescriptClientFromSDL(SDL: string, options: IClientOptions): TypescriptClientOutput {
+  console.log(`Generating TypeScript client from SDL (name: ${options.clientName ?? 'n/a'})`)
 
-  const graphqlSchemaObj = buildSchema(SDL);
-  const introspectionTypes = graphqlSync(graphqlSchemaObj, new Source(getIntrospectionQuery())).data?.__schema.types as IntrospectionType[]
+  const graphqlSchemaObj = buildSchema(SDL)
+  const introspectionTypes = graphqlSync(graphqlSchemaObj, new Source(getIntrospectionQuery())).data?.__schema
+    .types as IntrospectionType[]
 
   return generateClient(introspectionTypes, options)
 }

package/src/graphqlRequest.test.ts

@@ -2,10 +2,10 @@ import { graphqlRequest } from './graphqlRequest'
 
 describe('GraphQLRequest', () => {
   it('Should request have proper structure', async () => {
-    let request: any;
+    let request: any
 
     const mockedAxios = {
-      post: function() {
+      post: function () {
         request = arguments
         return {
           status: 200,
@@ -19,7 +19,7 @@ describe('GraphQLRequest', () => {
       axios: mockedAxios,
       queryName: 'sampleQueryName',
       query: 'sampleQuery',
-      variables: {foo:'bar',bar:'foo'},
+      variables: { foo: 'bar', bar: 'foo' },
       client: {
         url: 'https://whatever.com',
         headers: {},
@@ -51,7 +51,6 @@ describe('GraphQLRequest', () => {
     } as any
 
     const result = await graphqlRequest({
-
       failureMode: 'loud',
       axios: mockedAxios,
       queryName: 'whatever',