@avantstay/graphql-ts-client 11.0.0-beta.1 → 11.0.1

package/dist/endpoint.js

@@ -508,7 +508,9 @@ function _graphqlRequest() {
                     ];
                 case 2:
                     _ref = _state.sent(), tmp = _ref.data, responseData = tmp === void 0 ? {} : tmp, headers = _ref.headers, status = _ref.status;
-                    data = responseData.data, errors = responseData.errors, warnings = responseData.warnings;
+                    data = responseData.data;
+                    errors = liftErrorExtensions(responseData.errors);
+                    warnings = readWarnings(responseData);
                     if (status >= 400 && !(errors === null || errors === void 0 ? void 0 : errors.length)) {
                         errors = [
                             {
@@ -590,6 +592,19 @@ function _graphqlRequest() {
     });
     return _graphqlRequest.apply(this, arguments);
 }
+function readWarnings(responseData) {
+    var _responseData_extensions;
+    var _responseData_extensions_warnings;
+    return (_responseData_extensions_warnings = (_responseData_extensions = responseData.extensions) === null || _responseData_extensions === void 0 ? void 0 : _responseData_extensions.warnings) !== null && _responseData_extensions_warnings !== void 0 ? _responseData_extensions_warnings : responseData.warnings;
+}
+function liftErrorExtensions(errors) {
+    if (!Array.isArray(errors)) return errors;
+    return errors.map(function(error) {
+        return (error === null || error === void 0 ? void 0 : error.extensions) ? Object.assign({}, error.extensions.details, error.extensions.code != null ? {
+            code: error.extensions.code
+        } : {}, error) : error;
+    });
+}
 // src/jsonToGraphQLQuery.ts
 var import_omit = __toESM(require("lodash/omit"));
 var VAR_PREFIX = "@@VAR@@";
@@ -603,7 +618,8 @@ function jsonToGraphQLQuery(param) {
     var alias = jsonQuery.__alias;
     var newJsonQuery = cloneDeep((0, import_omit.default)(jsonQuery, [
         "__alias",
-        "__headers"
+        "__headers",
+        "__url"
     ]));
     extractVariables({
         jsonQuery: _defineProperty({}, queryName, newJsonQuery),
@@ -723,11 +739,13 @@ var getApiEndpointCreator = function(apiConfig) {
     return function(kind, queryName) {
         var rawEndpoint = function() {
             var _ref = _asyncToGenerator(function(failureMode, jsonQuery) {
-                var _jsonQuery___alias, alias, _jsonQuery___retry, shouldRetry, _jsonQuery___headers, requestHeaders, _jsonToGraphQLQuery, query, variables, start, logOptions, responseListenerData, _ref, data, errors, warnings, headers, status, response, error;
+                var clientConfig, _jsonQuery___alias, alias, _jsonQuery___url, url, _jsonQuery___retry, shouldRetry, _jsonQuery___headers, requestHeaders, _jsonToGraphQLQuery, query, variables, start, logOptions, responseListenerData, _ref, data, errors, warnings, headers, status, response, error;
                 return __generator(this, function(_state) {
                     switch(_state.label){
                         case 0:
+                            clientConfig = apiConfig.getClient();
                             alias = (_jsonQuery___alias = jsonQuery === null || jsonQuery === void 0 ? void 0 : jsonQuery.__alias) !== null && _jsonQuery___alias !== void 0 ? _jsonQuery___alias : queryName;
+                            url = (_jsonQuery___url = jsonQuery === null || jsonQuery === void 0 ? void 0 : jsonQuery.__url) !== null && _jsonQuery___url !== void 0 ? _jsonQuery___url : clientConfig.url;
                             shouldRetry = (_jsonQuery___retry = jsonQuery === null || jsonQuery === void 0 ? void 0 : jsonQuery.__retry) !== null && _jsonQuery___retry !== void 0 ? _jsonQuery___retry : true;
                             requestHeaders = (_jsonQuery___headers = jsonQuery === null || jsonQuery === void 0 ? void 0 : jsonQuery.__headers) !== null && _jsonQuery___headers !== void 0 ? _jsonQuery___headers : {};
                             _jsonToGraphQLQuery = jsonToGraphQLQuery({
@@ -764,7 +782,9 @@ var getApiEndpointCreator = function(apiConfig) {
                                     shouldRetry: shouldRetry,
                                     failureMode: failureMode,
                                     queryName: alias,
-                                    client: apiConfig.getClient(),
+                                    client: _objectSpreadProps(_objectSpread({}, clientConfig), {
+                                        url: url
+                                    }),
                                     requestHeaders: requestHeaders,
                                     query: query,
                                     variables: variables,

package/dist/index.js

@@ -477,7 +477,7 @@ var import_case = __toESM(require("case"));
 var esbuild = __toESM(require("esbuild"));
 var fs = __toESM(require("fs"));
 var import_graphql = require("graphql");
-var import_lodash = require("lodash");
+var import_kebabCase = __toESM(require("lodash/kebabCase"));
 var import_orderBy = __toESM(require("lodash/orderBy"));
 var import_set = __toESM(require("lodash/set"));
 var import_md5 = __toESM(require("md5"));
@@ -487,7 +487,7 @@ var prettier = __toESM(require("prettier"));
 // package.json
 var package_default = {
     name: "@avantstay/graphql-ts-client",
-    version: "11.0.0-beta.1",
+    version: "11.0.1",
     description: "GraphQL Typescript Client Generator",
     author: "Wellington Guimaraes",
     license: "MIT",
@@ -639,7 +639,7 @@ function gqlFieldToTypescript(field, param) {
                 selection: false
             });
         });
-        fieldTypeDefinition = "{ __headers?: {[key: string]: string}; __retry?: boolean; __alias?: string; __args".concat(fieldsOnArgs.every(function(arg) {
+        fieldTypeDefinition = "{ __headers?: {[key: string]: string}; __retry?: boolean; __alias?: string; __url?: string; __args".concat(fieldsOnArgs.every(function(arg) {
             return arg.isOptional;
         }) ? "?" : "", ": { ").concat(fieldsOnArgs.map(function(arg) {
             return arg.code;
@@ -679,7 +679,7 @@ function gqlEndpointToCode(kind, endpoint, codeOutputType) {
         selection: true
     });
     var argsType = endpoint.args && endpoint.args.length ? getArgsType(endpoint) : null;
-    var inputType = "{\n    __headers?: {[key: string]: string};\n    __retry?: boolean;\n    __alias?: string;\n    ".concat(argsType ? "__args".concat(argsType.optional ? "?" : "", ": ").concat(argsType.alias) : "", "\n  }").concat(selectionType ? " & ".concat(selectionType) : "");
+    var inputType = "{\n    __headers?: {[key: string]: string};\n    __retry?: boolean;\n    __alias?: string;\n    __url?: string;\n    ".concat(argsType ? "__args".concat(argsType.optional ? "?" : "", ": ").concat(argsType.alias) : "", "\n  }").concat(selectionType ? " & ".concat(selectionType) : "");
     var outputType = gqlTypeToTypescript(endpoint.type, {
         required: true
     });
@@ -866,7 +866,7 @@ function _fetchIntrospection() {
             switch(_state.label){
                 case 0:
                     endpoint = param.endpoint, headers = param.headers;
-                    introspectionCacheFileName = "gql-ts-client__introspection__".concat((0, import_lodash.kebabCase)(endpoint), ".json");
+                    introspectionCacheFileName = "gql-ts-client__introspection__".concat((0, import_kebabCase.default)(endpoint), ".json");
                     introspectionCacheFilePath = import_path.default.resolve(tempDir, introspectionCacheFileName);
                     loadedFromCache = false;
                     return [
@@ -877,7 +877,7 @@ function _fetchIntrospection() {
                             headers: _objectSpread({
                                 "Content-Type": "application/json"
                             }, headers)
-                        }).catch(function() {
+                        }).catch(function(e) {
                             var errorMessage = "The GraphQL introspection request failed (".concat(endpoint, ")");
                             if (fs.existsSync(introspectionCacheFilePath)) {
                                 var cachedSchema = JSON.parse(fs.readFileSync(introspectionCacheFilePath, {
@@ -889,6 +889,7 @@ function _fetchIntrospection() {
                                     data: cachedSchema
                                 };
                             } else {
+                                console.error(e);
                                 return Promise.reject(errorMessage);
                             }
                         })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avantstay/graphql-ts-client",
-  "version": "11.0.0-beta.1",
+  "version": "11.0.1",
   "description": "GraphQL Typescript Client Generator",
   "author": "Wellington Guimaraes",
   "license": "MIT",

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

@@ -30,15 +30,6 @@ export interface FailingQueryArgs {
 
 // Input/Output Types
 
-/**
- * @deprecated Avoid directly using this interface. Instead, create a type alias based on the query/mutation return type.
- */
-
-export interface Image {
-  url?: string
-  alt?: string
-}
-
 /**
  * @deprecated Avoid directly using this interface. Instead, create a type alias based on the query/mutation return type.
  */
@@ -48,7 +39,6 @@ export interface Book {
   author?: string
   type?: BookType
   dateCreated?: ISODate
-  images?: Image[]
 }
 
 /**
@@ -83,17 +73,11 @@ export interface Query {
 
 // Selection Types
 
-export interface ImageSelection {
-  url?: boolean
-  alt?: boolean
-}
-
 export interface BookSelection {
   title?: boolean
   author?: boolean
   type?: boolean
   dateCreated?: boolean
-  images?: ImageSelection
 }
 
 export interface BookSearchParamsAllOptionalSelection {
@@ -123,6 +107,7 @@ export declare const myApiClient: {
         __headers?: { [key: string]: string }
         __retry?: boolean
         __alias?: string
+        __url?: string
       } & BookSelection,
       Book[],
       AllEnums
@@ -132,6 +117,7 @@ export declare const myApiClient: {
         __headers?: { [key: string]: string }
         __retry?: boolean
         __alias?: string
+        __url?: string
         __args?: BooksWithOptionalParamsArgs
       } & BookSelection,
       Book[],
@@ -142,6 +128,7 @@ export declare const myApiClient: {
         __headers?: { [key: string]: string }
         __retry?: boolean
         __alias?: string
+        __url?: string
         __args: BooksWithRequiredParamsArgs
       } & BookSelection,
       Book[],
@@ -152,6 +139,7 @@ export declare const myApiClient: {
         __headers?: { [key: string]: string }
         __retry?: boolean
         __alias?: string
+        __url?: string
         __args: FailingQueryArgs
       },
       string,

package/src/__testClient.js

@@ -39,7 +39,6 @@ const typesTree = {
   Query: {
     get booksWithOptionalParams() {
       return {
-        __fields: typesTree.Book,
         __args: {
           params: "BookSearchParamsAllOptional!"
         }
@@ -47,7 +46,6 @@ const typesTree = {
     },
     get booksWithRequiredParams() {
       return {
-        __fields: typesTree.Book,
         __args: {
           params: "BookSearchParamsSomeRequired!"
         }
@@ -60,14 +58,7 @@ const typesTree = {
         }
       };
     },
-    get booksWithoutParams() {
-      return {
-        __fields: typesTree.Book
-      };
-    }
-  },
-  Book: {
-    images: {}
+    booksWithoutParams: {}
   }
 };
 let verbose = false;

package/src/endpoint.ts

@@ -32,7 +32,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,7 +61,7 @@ export const getApiEndpointCreator =
           shouldRetry,
           failureMode,
           queryName: alias,
-          client: apiConfig.getClient(),
+          client: {...clientConfig, url },
           requestHeaders,
           query,
           variables,

package/src/generateTypescriptClient.ts

@@ -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'
@@ -108,7 +108,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,6 +148,7 @@ 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}` : ''}`
 
@@ -499,7 +500,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' }))
@@ -507,6 +508,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)
       }
     })

package/src/graphqlRequest.ts

@@ -55,7 +55,9 @@ export async function graphqlRequest({
       }
     )
 
-    let { data, errors, warnings } = responseData
+    const { data } = responseData
+    let errors = liftErrorExtensions(responseData.errors)
+    const warnings = readWarnings(responseData)
 
     if (status >= 400 && !errors?.length) {
       errors = [{ message: `Request "${queryName}" failed with status ${status}` }]
@@ -93,3 +95,29 @@ export async function graphqlRequest({
 
   return lastResponse!
 }
+
+// The Arriere monolith (arriere@16aefc85) moved request warnings from the top level to
+// `extensions.warnings`, and each error's `code` and public fields to `errors[].extensions.code`
+// and `errors[].extensions.details`. These helpers restore the legacy top-level shape so existing
+// readers of `warnings` and `errors[].code` keep working against both old and new servers.
+
+// Extension warnings win whenever they are present, an empty array included.
+function readWarnings(responseData: any) {
+  return responseData.extensions?.warnings ?? responseData.warnings
+}
+
+// Fields already on the error win over lifted ones, and `extensions` stays untouched.
+function liftErrorExtensions(errors: any) {
+  if (!Array.isArray(errors)) return errors
+
+  return errors.map((error: any) =>
+    error?.extensions
+      ? Object.assign(
+          {},
+          error.extensions.details,
+          error.extensions.code != null ? { code: error.extensions.code } : {},
+          error
+        )
+      : error
+  )
+}

package/src/graphqlResponseShape.test.ts

@@ -0,0 +1,246 @@
+import axios from 'axios'
+import { getApiEndpointCreator } from './endpoint'
+import { graphqlRequest } from './graphqlRequest'
+import { GraphQLClientError } from './types'
+
+// The Arriere monolith moved `warnings` to `extensions.warnings` and each error's `code` and
+// public fields to `errors[].extensions`. graphqlRequest restores the legacy top-level shape
+// before anything else (errorsParser, retry hooks, response listeners, callers) sees it.
+
+const legacyWarnings = [{ code: 'LEGACY', message: 'Legacy warning' }]
+const extensionWarnings = [{ code: 'COUPON_DISABLED', message: 'Coupon is disabled' }]
+
+const client = (retryConfig: { max: number; before: (info: any) => any }) => ({
+  url: 'https://example.invalid/graphql',
+  headers: {},
+  retryConfig,
+})
+
+const requestOnce = (response: { status: number; data?: any }, options: Partial<Parameters<typeof graphqlRequest>[0]> = {}) =>
+  graphqlRequest({
+    shouldRetry: false,
+    failureMode: 'silent',
+    queryName: 'booking',
+    query: 'query booking { booking }',
+    variables: {},
+    client: client({ max: 0, before: () => undefined }),
+    axios: { post: jest.fn().mockResolvedValue({ headers: {}, ...response }) } as any,
+    ...options,
+  })
+
+describe('warnings', () => {
+  it.each([
+    { name: 'legacy top-level warnings are kept', body: { warnings: legacyWarnings }, expected: legacyWarnings },
+    { name: 'extension warnings are read', body: { extensions: { warnings: extensionWarnings } }, expected: extensionWarnings },
+    {
+      name: 'extension warnings win over legacy ones',
+      body: { warnings: legacyWarnings, extensions: { warnings: extensionWarnings } },
+      expected: extensionWarnings,
+    },
+    {
+      name: 'an empty extension warnings array wins',
+      body: { warnings: legacyWarnings, extensions: { warnings: [] } },
+      expected: [],
+    },
+    { name: 'null extensions fall back to legacy', body: { warnings: legacyWarnings, extensions: null }, expected: legacyWarnings },
+    {
+      name: 'null extension warnings fall back to legacy',
+      body: { warnings: legacyWarnings, extensions: { warnings: null } },
+      expected: legacyWarnings,
+    },
+    {
+      name: 'unrelated extensions fall back to legacy',
+      body: { warnings: legacyWarnings, extensions: { tracing: {} } },
+      expected: legacyWarnings,
+    },
+    { name: 'absent warnings stay absent', body: {}, expected: undefined },
+  ])('$name', async ({ body, expected }) => {
+    const response = await requestOnce({ status: 200, data: { data: { booking: null }, ...body } })
+
+    expect(response.warnings).toEqual(expected)
+    expect(response.data).toEqual({ booking: null })
+  })
+})
+
+describe('errors', () => {
+  it('lifts extensions.code and extensions.details to the top level and keeps extensions', async () => {
+    const error = {
+      message: 'Calendar is blocked',
+      path: ['createBooking'],
+      extensions: { code: 'CALENDAR_BLOCKED', details: { homeId: 'home-1', nights: 3 } },
+    }
+
+    const response = await requestOnce({ status: 200, data: { data: null, errors: [error] } })
+
+    expect(response.errors).toEqual([
+      {
+        homeId: 'home-1',
+        nights: 3,
+        code: 'CALENDAR_BLOCKED',
+        message: 'Calendar is blocked',
+        path: ['createBooking'],
+        extensions: { code: 'CALENDAR_BLOCKED', details: { homeId: 'home-1', nights: 3 } },
+      },
+    ])
+    expect((response.errors[0] as any).extensions).toBe(error.extensions)
+  })
+
+  it('keeps fields already on the error over lifted ones', async () => {
+    const error = {
+      message: 'Top-level message',
+      code: 'LEGACY_CODE',
+      homeId: 'legacy-home',
+      extensions: { code: 'CART_EXPIRED', details: { message: 'Details message', homeId: 'details-home', cartId: 'cart-1' } },
+    }
+
+    const response = await requestOnce({ status: 200, data: { data: null, errors: [error] } })
+
+    expect(response.errors[0]).toEqual({ ...error, cartId: 'cart-1' })
+  })
+
+  it('lifts details without inventing a code and leaves errors without extensions alone', async () => {
+    const plain = { message: 'No extensions' }
+    const detailsOnly = { message: 'Details only', extensions: { details: { field: 'email' } } }
+
+    const response = await requestOnce({ status: 200, data: { data: null, errors: [plain, detailsOnly, null] } })
+
+    expect(response.errors[0]).toBe(plain)
+    expect(response.errors[1]).toEqual({ field: 'email', ...detailsOnly })
+    expect(response.errors[1]).not.toHaveProperty('code')
+    expect(response.errors[2]).toBeNull()
+  })
+
+  it('does not mutate the response body', async () => {
+    const error = { message: 'Cart expired', extensions: { code: 'CART_EXPIRED' } }
+
+    await requestOnce({ status: 200, data: { data: null, errors: [error] } })
+
+    expect(error).toEqual({ message: 'Cart expired', extensions: { code: 'CART_EXPIRED' } })
+  })
+
+  it('normalizes errors on a 422 that carries errors', async () => {
+    const response = await requestOnce({
+      status: 422,
+      data: { errors: [{ message: 'Cart expired', extensions: { code: 'CART_EXPIRED' } }] },
+    })
+
+    expect(response.status).toBe(422)
+    expect(response.errors).toEqual([{ code: 'CART_EXPIRED', message: 'Cart expired', extensions: { code: 'CART_EXPIRED' } }])
+  })
+
+  it('falls back to the synthetic message on a 500 without a body', async () => {
+    const response = await requestOnce({ status: 500 })
+
+    expect(response.errors).toEqual([{ message: 'Request "booking" failed with status 500' }])
+    expect(response.warnings).toBeUndefined()
+  })
+
+  it('throws a GraphQLClientError carrying the normalized errors in loud mode', async () => {
+    const error = await requestOnce(
+      { status: 200, data: { data: null, errors: [{ message: 'Calendar is blocked', extensions: { code: 'CALENDAR_BLOCKED' } }] } },
+      { failureMode: 'loud' }
+    ).catch(e => e)
+
+    expect(error).toBeInstanceOf(GraphQLClientError)
+    expect(error.response.errors[0].code).toBe('CALENDAR_BLOCKED')
+  })
+
+  it('passes the normalized errors to errorsParser', async () => {
+    const errorsParser = jest.fn((errors: any[]) => errors.map(e => e.code))
+
+    const response = await requestOnce(
+      { status: 200, data: { data: null, errors: [{ message: 'Cart expired', extensions: { code: 'CART_EXPIRED' } }] } },
+      { errorsParser }
+    )
+
+    expect(errorsParser).toHaveBeenCalledWith([
+      { code: 'CART_EXPIRED', message: 'Cart expired', extensions: { code: 'CART_EXPIRED' } },
+    ])
+    expect(response.errors).toEqual(['CART_EXPIRED'])
+  })
+})
+
+describe('retries', () => {
+  it('shows the normalized shape to the retry hook', async () => {
+    const before = jest.fn()
+    const post = jest
+      .fn()
+      .mockResolvedValueOnce({
+        status: 200,
+        headers: {},
+        data: {
+          data: null,
+          errors: [{ message: 'Cart expired', extensions: { code: 'CART_EXPIRED', details: { cartId: 'cart-1' } } }],
+          extensions: { warnings: extensionWarnings },
+        },
+      })
+      .mockResolvedValueOnce({ status: 200, headers: {}, data: { data: { booking: { id: 'booking-1' } } } })
+
+    const response = await graphqlRequest({
+      failureMode: 'silent',
+      axios: { post } as any,
+      queryName: 'booking',
+      query: 'query booking { booking }',
+      variables: {},
+      client: client({ max: 1, before }),
+    })
+
+    expect(post).toHaveBeenCalledTimes(2)
+    expect(before).toHaveBeenCalledTimes(1)
+    expect(before.mock.calls[0][0].response).toMatchObject({
+      errors: [{ code: 'CART_EXPIRED', cartId: 'cart-1', message: 'Cart expired' }],
+      warnings: extensionWarnings,
+    })
+    expect(response.errors).toBeUndefined()
+    expect(response.data).toEqual({ booking: { id: 'booking-1' } })
+  })
+})
+
+describe('response listeners', () => {
+  afterEach(() => jest.restoreAllMocks())
+
+  const createEndpoint = (listener: jest.Mock) =>
+    getApiEndpointCreator({
+      getClient: () => client({ max: 0, before: () => undefined }),
+      responseListeners: [listener],
+      typesTree: {},
+      maxAge: 0,
+      verbose: false,
+      formatGraphQL: (query: string) => query,
+    })('mutation', 'booking')
+
+  const mockServer = (body: any) => jest.spyOn(axios, 'post').mockResolvedValue({ status: 200, headers: {}, data: body })
+
+  const flushListeners = () => new Promise(resolve => setTimeout(resolve, 0))
+
+  it('sees normalized warnings and errors on raw requests', async () => {
+    const listener = jest.fn()
+    mockServer({
+      data: { booking: null },
+      errors: [{ message: 'Coupon rejected', extensions: { code: 'COUPON_INVALID' } }],
+      extensions: { warnings: extensionWarnings },
+    })
+
+    const response = await createEndpoint(listener).raw({ __alias: 'booking' })
+    await flushListeners()
+
+    const expected = {
+      warnings: extensionWarnings,
+      errors: [{ code: 'COUPON_INVALID', message: 'Coupon rejected', extensions: { code: 'COUPON_INVALID' } }],
+    }
+    expect(response).toMatchObject(expected)
+    expect(listener).toHaveBeenCalledWith(expect.objectContaining({ response: expect.objectContaining(expected) }))
+  })
+
+  it('sees normalized errors when a loud request throws', async () => {
+    const listener = jest.fn()
+    mockServer({ data: null, errors: [{ message: 'Calendar is blocked', extensions: { code: 'CALENDAR_BLOCKED' } }] })
+
+    const error = await createEndpoint(listener)({ __alias: 'booking' }).catch((e: any) => e)
+    await flushListeners()
+
+    expect(error).toBeInstanceOf(GraphQLClientError)
+    expect(error.response.errors[0].code).toBe('CALENDAR_BLOCKED')
+    expect(listener.mock.calls[0][0].response.errors[0].code).toBe('CALENDAR_BLOCKED')
+  })
+})

package/src/jsonToGraphQLQuery.ts

@@ -23,7 +23,7 @@ export function jsonToGraphQLQuery({
 }) {
   const variablesData = {} as ExtractedVariables
   const alias = jsonQuery.__alias
-  const newJsonQuery = cloneDeep(omit(jsonQuery, ['__alias', '__headers']))
+  const newJsonQuery = cloneDeep(omit(jsonQuery, ['__alias', '__headers', '__url']))
 
   extractVariables({
     jsonQuery: { [queryName]: newJsonQuery },

package/dist/types-4ecbabdf.d.ts

@@ -1,69 +0,0 @@
-type Maybe<T> = null | undefined | T;
-type Defined<T> = Exclude<T, undefined>;
-type ResponseData = {
-    data: any;
-    warnings: any;
-    headers: any;
-    status?: number;
-    errors: {
-        message: string;
-    }[];
-};
-type ResponseListenerInfo = {
-    queryName: string;
-    query: string;
-    variables: any;
-    response: ResponseData;
-};
-type IResponseListener = (info: ResponseListenerInfo) => void | Promise<void>;
-type ArrayElement<ArrayType extends readonly unknown[]> = ArrayType extends readonly (infer ElementType)[] ? ElementType : never;
-type Projection<Selection, Base, E = never> = Base extends Array<any> ? ArrayElement<Base> extends Date | string | number | boolean | null | undefined | E ? ArrayElement<Base>[] : Projection<Defined<Selection>, ArrayElement<Base>, E>[] : Base extends Date | string | number | boolean | null | E ? Selection extends undefined ? Base | undefined : Base : {
-    [k in keyof Selection & keyof Base]: Selection[k] extends boolean ? Base[k] : Base[k] extends Array<infer A> ? Projection<Defined<Selection[k]>, A, E>[] : Projection<Defined<Selection[k]>, Base[k], E>;
-};
-type Unpacked<T> = T extends (infer U)[] ? U : T extends (...args: any[]) => infer U ? U : T extends Promise<infer U> ? U : T;
-type Replacement<M extends [any, any], T> = M extends any ? ([T] extends [M[0]] ? M[1] : never) : never;
-type DeepReplace<T, Ignore, M extends [any, any]> = {
-    [P in keyof T]: T[P] extends M[0] ? T[P] extends Ignore ? T[P] extends object ? DeepReplace<T[P], Ignore, M> : T[P] : Replacement<M, T[P]> : T[P] extends object ? DeepReplace<T[P], Ignore, M> : T[P];
-};
-type RawEndpoint<I, O, E> = <S extends I>(jsonQuery?: S) => Promise<{
-    data: Projection<S, O, E>;
-    errors: any[];
-    warnings: any[];
-    headers: any;
-    status: any;
-}>;
-type JsonOutput<O, ToBeIgnored> = DeepReplace<O, ToBeIgnored, [string | Date, string]>;
-type Endpoint<I, O, E> = (<S extends I>(jsonQuery?: S) => Promise<Projection<S, JsonOutput<O, E>, E>>) & {
-    memo: <S extends I>(jsonQuery?: S) => Promise<Projection<S, JsonOutput<O, E>, E>>;
-    memoRaw: RawEndpoint<I, JsonOutput<O, E>, E>;
-    raw: RawEndpoint<I, JsonOutput<O, E>, E>;
-};
-type ClientConfig = {
-    url: string;
-    headers: {
-        [key: string]: string;
-    };
-    retryConfig: {
-        max: number;
-        waitBeforeRetry?: number;
-        before: IResponseListener;
-    };
-};
-type LogInfo = {
-    query: string;
-    variables: any;
-    formatGraphQL: any;
-    kind: string;
-    queryName: string;
-    response?: any;
-    error?: Error;
-    duration: number;
-};
-declare class GraphQLClientError extends Error {
-    responseData: ResponseData;
-    constructor(responseData: ResponseData);
-    get message(): string;
-    get response(): ResponseData;
-}
-
-export { ClientConfig as C, Defined as D, Endpoint as E, GraphQLClientError as G, IResponseListener as I, JsonOutput as J, LogInfo as L, Maybe as M, Projection as P, ResponseData as R, Unpacked as U, ResponseListenerInfo as a, Replacement as b, DeepReplace as c, RawEndpoint as d };