@avantstay/graphql-ts-client 10.7.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@@";

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.7.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.7.0",
+  "version": "10.7.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

package/src/__testClient.d.ts

@@ -0,0 +1,148 @@
+// 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
+}
+
+/**
+ * @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
+}
+
+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,110 @@
+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 {
+        __args: {
+          params: "BookSearchParamsAllOptional!"
+        }
+      };
+    },
+    get booksWithRequiredParams() {
+      return {
+        __args: {
+          params: "BookSearchParamsSomeRequired!"
+        }
+      };
+    },
+    get failingQuery() {
+      return {
+        __args: {
+          id: "String!"
+        }
+      };
+    },
+    booksWithoutParams: {}
+  }
+};
+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/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')
+  })
+})