@avantstay/graphql-ts-client 10.6.0 → 10.7.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@@";
@@ -610,12 +625,22 @@ function jsonToGraphQLQuery(param) {
         variables: variablesData,
         parentType: kind === "query" ? typesTree.Query : typesTree.Mutation
     });
-    var variablesQuery = Object.keys(variablesData).length ? "(".concat(entries(variablesData).map(function(param) {
+    var variableItems = Object.values(variablesData).reduce(function(variablesObj, variables2) {
+        variables2.forEach(function(variable, index) {
+            var name = variable.update(variables2.length > 1 ? index : void 0);
+            variablesObj[name] = {
+                type: variable.type,
+                value: variable.value
+            };
+        });
+        return variablesObj;
+    }, {});
+    var variablesQuery = Object.keys(variableItems).length ? "(".concat(entries(variableItems).map(function(param) {
         var _param = _slicedToArray(param, 2), queryName2 = _param[0], type = _param[1].type;
         return "$".concat(queryName2, ": ").concat(type);
     }).join(", "), ")") : "";
     var query = "".concat(kind, " ").concat(alias || queryName).concat(variablesQuery, " { ").concat(alias ? "".concat(alias, ":") : "").concat(queryName).concat(toGraphql(newJsonQuery), " }");
-    var variables = fromEntries(entries(variablesData).map(function(param) {
+    var variables = fromEntries(entries(variableItems).map(function(param) {
         var _param = _slicedToArray(param, 2), k = _param[0], v = _param[1];
         return [
             k,
@@ -633,14 +658,22 @@ function extractVariables(param) {
     if (jsonQuery.__args) {
         Object.keys(jsonQuery.__args).forEach(function(k) {
             if (typeof jsonQuery.__args[k] === "string" && jsonQuery.__args[k].startsWith(VAR_PREFIX)) return;
-            var variableName = "".concat(k, "_").concat(Math.random().toString(36).substr(2, 4));
-            if (jsonQuery.__args[k] !== void 0) {
-                variables[variableName] = {
-                    type: parentType.__args[k],
-                    value: jsonQuery.__args[k]
-                };
-                jsonQuery.__args[k] = "".concat(VAR_PREFIX, "$").concat(variableName);
+            if (jsonQuery.__args[k] === void 0) return;
+            var variableName = k;
+            if (!variables[variableName]) {
+                variables[variableName] = [];
             }
+            variables[variableName].push({
+                name: variableName,
+                type: parentType.__args[k],
+                value: jsonQuery.__args[k],
+                update: function(index) {
+                    var name = "".concat(variableName).concat(index !== void 0 ? "_".concat(index) : "");
+                    jsonQuery.__args[k] = "".concat(VAR_PREFIX, "$").concat(name);
+                    return name;
+                }
+            });
+            jsonQuery.__args[k] = VAR_PREFIX;
         });
     }
     Object.keys(jsonQuery).filter(function(k) {

package/dist/index.js

@@ -487,7 +487,7 @@ var prettier = __toESM(require("prettier"));
 // package.json
 var package_default = {
     name: "@avantstay/graphql-ts-client",
-    version: "10.6.0",
+    version: "10.7.1",
     description: "GraphQL Typescript Client Generator",
     author: "Wellington Guimaraes",
     license: "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avantstay/graphql-ts-client",
-  "version": "10.6.0",
+  "version": "10.7.1",
   "description": "GraphQL Typescript Client Generator",
   "author": "Wellington Guimaraes",
   "license": "MIT",
@@ -8,8 +8,8 @@
   "typings": "dist/index.d.ts",
   "scripts": {
     "build": "tsup src/index.ts src/endpoint.ts --dts",
-    "test": "cross-env GQL_CLIENT_DIST_PATH='.' jest --watch"
-
+    "test": "cross-env GQL_CLIENT_DIST_PATH='.' jest --watch",
+    "prepublishOnly": "yarn build"
   },
   "files": [
     "dist",

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

package/src/__testClient.d.ts

@@ -1,6 +1,6 @@
 // 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

package/src/__testClient.js

@@ -26,7 +26,7 @@ __export(exports, {
   default: () => stdin_default,
   myApiClient: () => myApiClient
 });
-var import_endpoint = __toModule(require("../dist/endpoint"));
+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] });

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.test.ts

@@ -38,8 +38,14 @@ describe('jsonToGraphQLQuery', () => {
       __args: {
         foo: 'Bar',
       },
-
       something: true,
+      another: {
+        __args: {
+          foo: 'Lorem ipsum',
+          bar: 'Dolor sit amet',
+        },
+        zeta: true,
+      },
     }
 
     const response = jsonToGraphQLQuery({
@@ -53,14 +59,24 @@ describe('jsonToGraphQLQuery', () => {
               __args: {
                 foo: 'UUID!',
               },
+              something: 'Boolean!',
+              another: {
+                __args: {
+                  foo: 'String!',
+                  bar: 'String!',
+                },
+                zeta: 'Int!',
+              },
             }
           },
         },
       },
     })
 
-    Object.keys(response.variables).forEach(varName => {
-      expect(response.query.split(varName).length - 1).toBeGreaterThanOrEqual(2) //every variable name should be present at least 2 times
+    expect(response.variables).toEqual({
+      foo_0: 'Bar',
+      foo_1: 'Lorem ipsum',
+      bar: 'Dolor sit amet',
     })
   })
 })

package/src/jsonToGraphQLQuery.ts

@@ -7,6 +7,9 @@ const fromEntries: (arr: [string, any][]) => { [key: string]: any } = require('l
 const entries: (obj: { [key: string]: any }) => [string, any][] = require('lodash/toPairs')
 const cloneDeep = require('lodash/cloneDeep')
 
+type ExtractedVariables = Record<string, (Variable & { name: string; update: (index?: number) => string })[]>
+type Variable = { type: any; value: any }
+
 export function jsonToGraphQLQuery({
   kind,
   queryName,
@@ -18,7 +21,7 @@ export function jsonToGraphQLQuery({
   jsonQuery: any
   typesTree: any
 }) {
-  const variablesData = {} as any
+  const variablesData = {} as ExtractedVariables
   const alias = jsonQuery.__alias
   const newJsonQuery = cloneDeep(omit(jsonQuery, ['__alias', '__headers']))
 
@@ -28,8 +31,17 @@ export function jsonToGraphQLQuery({
     parentType: kind === 'query' ? typesTree.Query : typesTree.Mutation,
   })
 
-  const variablesQuery = Object.keys(variablesData).length
-    ? `(${entries(variablesData)
+  const variableItems = Object.values(variablesData).reduce((variablesObj, variables) => {
+    variables.forEach((variable, index) => {
+      const name = variable.update(variables.length > 1 ? index : undefined)
+      variablesObj[name] = { type: variable.type, value: variable.value }
+    })
+
+    return variablesObj
+  }, {} as Record<string, Variable>)
+
+  const variablesQuery = Object.keys(variableItems).length
+    ? `(${entries(variableItems)
         .map(([queryName, { type }]: any) => `$${queryName}: ${type}`)
         .join(', ')})`
     : ''
@@ -37,7 +49,7 @@ export function jsonToGraphQLQuery({
   const query = `${kind} ${alias || queryName}${variablesQuery} { ${alias ? `${alias}:` : ''}${queryName}${toGraphql(
     newJsonQuery
   )} }`
-  const variables = fromEntries(entries(variablesData).map(([k, v]: any) => [k, v.value]))
+  const variables = fromEntries(entries(variableItems).map(([k, v]: any) => [k, v.value]))
 
   return {
     query,
@@ -45,22 +57,41 @@ export function jsonToGraphQLQuery({
   }
 }
 
-function extractVariables({ jsonQuery, variables, parentType }: { jsonQuery: any; variables: any; parentType: any }) {
+function extractVariables({
+  jsonQuery,
+  variables,
+  parentType,
+}: {
+  jsonQuery: any
+  variables: ExtractedVariables
+  parentType: any
+}) {
   if (!parentType) return
 
   if (jsonQuery.__args) {
     Object.keys(jsonQuery.__args).forEach(k => {
       if (typeof jsonQuery.__args[k] === 'string' && jsonQuery.__args[k].startsWith(VAR_PREFIX)) return
+      if (jsonQuery.__args[k] === undefined) return
 
-      const variableName = `${k}_${Math.random().toString(36).substr(2, 4)}`
+      const variableName = k
 
-      if (jsonQuery.__args[k] !== undefined) {
-        variables[variableName] = {
-          type: parentType.__args[k],
-          value: jsonQuery.__args[k],
-        }
-        jsonQuery.__args[k] = `${VAR_PREFIX}$${variableName}`
+      if (!variables[variableName]) {
+        variables[variableName] = []
       }
+
+      variables[variableName].push({
+        name: variableName,
+        type: parentType.__args[k],
+        value: jsonQuery.__args[k],
+        update: (index?: number) => {
+          const name = `${variableName}${index !== undefined ? `_${index}` : ''}`
+          jsonQuery.__args[k] = `${VAR_PREFIX}$${name}`
+
+          return name
+        },
+      })
+
+      jsonQuery.__args[k] = VAR_PREFIX
     })
   }