@avantstay/graphql-ts-client 10.8.0 → 10.8.1

package/dist/endpoint.d.ts

@@ -1,13 +1,13 @@
-import { C as ClientConfig, I as IResponseListener, E as Endpoint } from './types-85e628f6.js';
+import { C as ClientConfig, I as IResponseListener, E as Endpoint } from './types-4ecbabdf.js';
 
-declare const getApiEndpointCreator: (apiConfig: {
-    getClient: () => ClientConfig;
-    responseListeners: IResponseListener[];
-    typesTree: any;
-    maxAge: number;
-    verbose: boolean;
-    formatGraphQL: any;
-    errorsParser?: ((errors: any[]) => any) | undefined;
+declare const getApiEndpointCreator: (apiConfig: {
+    getClient: () => ClientConfig;
+    responseListeners: IResponseListener[];
+    typesTree: any;
+    maxAge: number;
+    verbose: boolean;
+    formatGraphQL: any;
+    errorsParser?: ((errors: any[]) => any) | undefined;
 }) => <I = any, O = any, E = any>(kind: 'mutation' | 'query', queryName: string) => Endpoint<I, O, E>;
 
 export { getApiEndpointCreator };

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

@@ -1,24 +1,24 @@
 import { PathLike } from 'fs';
-export { C as ClientConfig, c as DeepReplace, D as Defined, E as Endpoint, G as GraphQLClientError, I as IResponseListener, J as JsonOutput, L as LogInfo, M as Maybe, P as Projection, d as RawEndpoint, b as Replacement, R as ResponseData, a as ResponseListenerInfo, U as Unpacked } from './types-85e628f6.js';
+export { C as ClientConfig, c as DeepReplace, D as Defined, E as Endpoint, G as GraphQLClientError, I as IResponseListener, J as JsonOutput, L as LogInfo, M as Maybe, P as Projection, d as RawEndpoint, b as Replacement, R as ResponseData, a as ResponseListenerInfo, U as Unpacked } from './types-4ecbabdf.js';
 
-type IClientOptions = {
-    output?: PathLike;
-    clientName?: string;
-    headers?: {
-        [key: string]: string;
-    };
-    introspectionEndpoint?: string;
-    endpoint: string;
-    verbose?: boolean;
-    formatGraphQL?: boolean;
-    skipCache?: boolean;
-    errorsParser?: (errors: any[]) => any;
-};
-type Client = {
-    typings: string;
-    js: string;
-};
-declare function generateTypescriptClient({ introspectionEndpoint, ...options }: IClientOptions): Promise<Client>;
+type IClientOptions = {
+    output?: PathLike;
+    clientName?: string;
+    headers?: {
+        [key: string]: string;
+    };
+    introspectionEndpoint?: string;
+    endpoint: string;
+    verbose?: boolean;
+    formatGraphQL?: boolean;
+    skipCache?: boolean;
+    errorsParser?: (errors: any[]) => any;
+};
+type Client = {
+    typings: string;
+    js: string;
+};
+declare function generateTypescriptClient({ introspectionEndpoint, ...options }: IClientOptions): Promise<Client>;
 declare function generateTypescriptClientFromSDL(SDL: string, options: IClientOptions): Client;
 
 export { generateTypescriptClient, generateTypescriptClientFromSDL };

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.8.0",
+    version: "10.8.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.8.0",
+  "version": "10.8.1",
   "description": "GraphQL Typescript Client Generator",
   "author": "Wellington Guimaraes",
   "license": "MIT",

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/dist/types-85e628f6.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 };