@avantstay/graphql-ts-client 11.0.0 → 12.0.0

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

@@ -76,6 +76,58 @@ const client = {
   mutations: {}
 };
 var stdin_default = client;
+",
+  "mjs": "import { getApiEndpointCreator } from "./endpoint";
+const formatGraphQL = (query) => query;
+const typesTree = {};
+let verbose = false;
+let headers = {};
+let url = "https://sample.endpoint.com/graphl";
+let retryConfig = {
+  max: 0,
+  before: void 0,
+  waitBeforeRetry: 0
+};
+let responseListeners = [];
+let errorsParser = void 0;
+let apiEndpoint = getApiEndpointCreator({
+  getClient: () => ({ url, headers, retryConfig }),
+  responseListeners,
+  maxAge: 3e4,
+  verbose,
+  typesTree,
+  formatGraphQL,
+  errorsParser
+});
+const client = {
+  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: {
+    hello: apiEndpoint("query", "hello")
+  },
+  mutations: {}
+};
+var stdin_default = client;
+export {
+  client,
+  stdin_default as default
+};
 ",
   "typings": "// noinspection TypeScriptUnresolvedVariable, ES6UnusedImports, JSUnusedLocalSymbols, TypeScriptCheckImport
 import { DeepRequired } from "ts-essentials"

package/src/__testClient.d.ts

@@ -39,16 +39,6 @@ export interface Book {
   author?: string
   type?: BookType
   dateCreated?: ISODate
-  sequence?: BookSequence
-}
-
-/**
- * @deprecated Avoid directly using this interface. Instead, create a type alias based on the query/mutation return type.
- */
-
-export interface BookSequence {
-  previousBook?: Book
-  nextBook?: Book
 }
 
 /**
@@ -88,12 +78,6 @@ export interface BookSelection {
   author?: boolean
   type?: boolean
   dateCreated?: boolean
-  sequence?: BookSequenceSelection
-}
-
-export interface BookSequenceSelection {
-  previousBook?: BookSelection
-  nextBook?: BookSelection
 }
 
 export interface BookSearchParamsAllOptionalSelection {
@@ -123,8 +107,9 @@ export declare const myApiClient: {
         __headers?: { [key: string]: string }
         __retry?: boolean
         __alias?: string
+        __url?: string
       } & BookSelection,
-      DeepRequired<Book[]>,
+      Book[],
       AllEnums
     >
     booksWithOptionalParams: Endpoint<
@@ -132,9 +117,10 @@ export declare const myApiClient: {
         __headers?: { [key: string]: string }
         __retry?: boolean
         __alias?: string
+        __url?: string
         __args?: BooksWithOptionalParamsArgs
       } & BookSelection,
-      DeepRequired<Book[]>,
+      Book[],
       AllEnums
     >
     booksWithRequiredParams: Endpoint<
@@ -142,9 +128,10 @@ export declare const myApiClient: {
         __headers?: { [key: string]: string }
         __retry?: boolean
         __alias?: string
+        __url?: string
         __args: BooksWithRequiredParamsArgs
       } & BookSelection,
-      DeepRequired<Book[]>,
+      Book[],
       AllEnums
     >
     failingQuery: Endpoint<
@@ -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,30 +58,7 @@ const typesTree = {
         }
       };
     },
-    get booksWithoutParams() {
-      return {
-        __fields: typesTree.Book
-      };
-    }
-  },
-  Book: {
-    get sequence() {
-      return {
-        __fields: typesTree.BookSequence
-      };
-    }
-  },
-  BookSequence: {
-    get previousBook() {
-      return {
-        __fields: typesTree.Book
-      };
-    },
-    get nextBook() {
-      return {
-        __fields: typesTree.Book
-      };
-    }
+    booksWithoutParams: {}
   }
 };
 let verbose = false;

package/src/__testClient.mjs

@@ -0,0 +1,87 @@
+import { getApiEndpointCreator } from "./endpoint";
+import { format as formatCode } from "prettier/standalone";
+import parserGraphql from "prettier/parser-graphql";
+const formatGraphQL = (query) => formatCode(query, { parser: "graphql", plugins: [parserGraphql] });
+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 = 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;
+export {
+  BookType,
+  stdin_default as default,
+  myApiClient
+};

package/src/endpoint.ts

@@ -2,14 +2,10 @@ import memoize from 'moize'
 import { graphqlRequest } from './graphqlRequest'
 import { jsonToGraphQLQuery } from './jsonToGraphQLQuery'
 import { logRequest } from './logging'
-import {ClientConfig, Endpoint, GraphQLClientError, IResponseListener, Projection, ResponseListenerInfo} from './types'
+import { ClientConfig, Endpoint, GraphQLClientError, IResponseListener, Projection, ResponseListenerInfo } from './types'
 
 const executeListeners = (listeners: IResponseListener[], data: ResponseListenerInfo) =>
-  setTimeout(() =>
-    listeners.forEach(runResponseListener =>
-      runResponseListener(data)
-    )
-  )
+  setTimeout(() => listeners.forEach(runResponseListener => runResponseListener(data)))
 
 export const getApiEndpointCreator =
   (apiConfig: {
@@ -61,11 +57,11 @@ export const getApiEndpointCreator =
           shouldRetry,
           failureMode,
           queryName: alias,
-          client: {...clientConfig, url },
+          client: { ...clientConfig, url },
           requestHeaders,
           query,
           variables,
-          errorsParser: apiConfig.errorsParser
+          errorsParser: apiConfig.errorsParser,
         })
 
         const response = { data, warnings, headers, status, errors }
@@ -78,7 +74,7 @@ export const getApiEndpointCreator =
           })
         }
 
-        executeListeners(apiConfig.responseListeners,{
+        executeListeners(apiConfig.responseListeners, {
           ...responseListenerData,
           response,
         })

package/src/generateTypescriptClient.test.ts

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

package/src/generateTypescriptClient.ts

@@ -6,8 +6,8 @@ import * as fs from 'fs'
 import { PathLike } from 'fs'
 import {
   buildSchema,
-  graphqlSync,
   getIntrospectionQuery,
+  graphqlSync,
   IntrospectionEnumType,
   IntrospectionField,
   IntrospectionInputObjectType,
@@ -15,7 +15,6 @@ import {
   IntrospectionObjectType,
   IntrospectionOutputTypeRef,
   IntrospectionType,
-  Source,
 } from 'graphql'
 import kebabCase from 'lodash/kebabCase'
 import orderBy from 'lodash/orderBy'
@@ -25,6 +24,7 @@ import os from 'os'
 import path from 'path'
 import * as prettier from 'prettier'
 import pkg from '../package.json'
+import { TypescriptClientOutput } from './types'
 
 const tempDir = fs.realpathSync(os.tmpdir())
 
@@ -314,7 +314,7 @@ type IClientOptions = {
   errorsParser?: (errors: any[]) => any
 }
 
-type FetchIntrospectionOptions = Omit< IClientOptions, 'output' | 'introspectionEndpoint'>
+type FetchIntrospectionOptions = Omit<IClientOptions, 'output' | 'introspectionEndpoint'>
 
 function generateClientCode(types: ReadonlyArray<IntrospectionType>, options: Omit<IClientOptions, 'output'>) {
   const typesHash = md5(`${JSON.stringify(options)}__${JSON.stringify(types)}`)
@@ -322,7 +322,11 @@ function generateClientCode(types: ReadonlyArray<IntrospectionType>, options: Om
   const clientCacheFilePath = path.resolve(tempDir, clientCacheFileName)
 
   if (!options.skipCache && fs.existsSync(clientCacheFilePath)) {
-    return JSON.parse(fs.readFileSync(clientCacheFilePath, { encoding: 'utf8' }))
+    const output: Partial<TypescriptClientOutput> = JSON.parse(fs.readFileSync(clientCacheFilePath, { encoding: 'utf8' }))
+
+    if (output.js && output.mjs && output.typings) {
+      return output as TypescriptClientOutput
+    }
   }
 
   const queries = (<IntrospectionObjectType>types.find(it => it.name === 'Query'))?.fields || []
@@ -472,8 +476,9 @@ function generateClientCode(types: ReadonlyArray<IntrospectionType>, options: Om
 
     export default ${clientName}`
 
-  const output = {
+  const output: TypescriptClientOutput = {
     js: esbuild.transformSync(jsCode, { format: 'cjs', loader: 'js' }).code,
+    mjs: esbuild.transformSync(jsCode, { format: 'esm', loader: 'js' }).code,
     typings: prettier.format(typingsCode, { semi: false, parser: 'typescript' }),
   }
 
@@ -498,18 +503,18 @@ async function fetchIntrospection({ endpoint, headers }: FetchIntrospectionOptio
           'Content-Type': 'application/json',
           ...headers,
         },
+        timeout: 5000,
       }
     )
-    .catch((e) => {
-      const errorMessage = `The GraphQL introspection request failed (${endpoint})`
+    .catch(e => {
       if (fs.existsSync(introspectionCacheFilePath)) {
         const cachedSchema = JSON.parse(fs.readFileSync(introspectionCacheFilePath, { encoding: 'utf8' }))
         loadedFromCache = true
-        console.warn(`Successfully restored from local cache.`)
+        console.warn(`Successfully restored (${endpoint}) from local cache.`)
         return { data: cachedSchema }
       } else {
         console.error(e)
-        return Promise.reject(errorMessage)
+        return Promise.reject(`The GraphQL introspection request failed (${endpoint})`)
       }
     })
 
@@ -526,10 +531,11 @@ async function fetchIntrospection({ endpoint, headers }: FetchIntrospectionOptio
   return types
 }
 
-type Client = { typings: string; js: string }
-
-function generateClient(introspectionTypes: ReadonlyArray<IntrospectionType>, {output,...restOptions}: IClientOptions): Client {
-  const { js, typings } = generateClientCode(introspectionTypes, restOptions)
+function generateClient(
+  introspectionTypes: ReadonlyArray<IntrospectionType>,
+  { output, ...restOptions }: IClientOptions
+): TypescriptClientOutput {
+  const { js, mjs, typings } = generateClientCode(introspectionTypes, restOptions)
 
   if (output && typeof output === 'string') {
     const outputDir = path.dirname(output)
@@ -540,12 +546,16 @@ function generateClient(introspectionTypes: ReadonlyArray<IntrospectionType>, {o
 
     fs.writeFileSync(output.replace(/(\.(ts|js))?$/, '.d.ts'), typings, { encoding: 'utf8' })
     fs.writeFileSync(output.replace(/(\.(ts|js))?$/, '.js'), js, { encoding: 'utf8' })
+    fs.writeFileSync(output.replace(/(\.(ts|js))?$/, '.mjs'), mjs, { encoding: 'utf8' })
   }
 
-  return { js, typings }
+  return { js, mjs, typings }
 }
 
-export async function generateTypescriptClient({ introspectionEndpoint, ...options }: IClientOptions): Promise<Client> {
+export async function generateTypescriptClient({
+  introspectionEndpoint,
+  ...options
+}: IClientOptions): Promise<TypescriptClientOutput> {
   console.log(`Generating TypeScript client (name: ${options.clientName ?? 'n/a'})`)
 
   axiosRetry(axios, { retries: 5, retryDelay: retryCount => 1000 * 2 ** retryCount })
@@ -556,14 +566,17 @@ export async function generateTypescriptClient({ introspectionEndpoint, ...optio
   })
 
   return generateClient(introspectionTypes, options)
-
 }
 
-export function generateTypescriptClientFromSDL(SDL: string, options: IClientOptions): Client {
-  console.log(`Generating TypeScript client from SDL (name: ${options.clientName ?? 'n/a'})`);
+export function generateTypescriptClientFromSDL(SDL: string, options: IClientOptions): TypescriptClientOutput {
+  console.log(`Generating TypeScript client from SDL (name: ${options.clientName ?? 'n/a'})`)
 
-  const graphqlSchemaObj = buildSchema(SDL);
-  const introspectionTypes = graphqlSync(graphqlSchemaObj, new Source(getIntrospectionQuery())).data?.__schema.types as IntrospectionType[]
+  const graphqlSchemaObj = buildSchema(SDL)
+  const introspectionResult = graphqlSync({
+    schema: graphqlSchemaObj,
+    source: getIntrospectionQuery(),
+  })
+  const introspectionTypes = (introspectionResult.data as any)?.__schema.types as IntrospectionType[]
 
   return generateClient(introspectionTypes, options)
 }

package/src/graphqlRequest.test.ts

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

package/src/jsonToGraphQLQuery.ts

@@ -31,14 +31,17 @@ export function jsonToGraphQLQuery({
     parentType: kind === 'query' ? typesTree.Query : typesTree.Mutation,
   })
 
-  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 }
-    })
+  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>)
+      return variablesObj
+    },
+    {} as Record<string, Variable>
+  )
 
   const variablesQuery = Object.keys(variableItems).length
     ? `(${entries(variableItems)

package/src/types.ts

@@ -24,30 +24,31 @@ type ArrayElement<ArrayType extends readonly unknown[]> = ArrayType extends read
 type Primitive = Date | string | number | boolean | null | undefined
 
 // Projection is the resulting type of Selection (type generated out of a query) applied to Base (generated graphql type)
-export type Projection<Selection, Base, E = never> = Base extends Array<any>
-  ? ArrayElement<Base> extends Primitive | E
-    ? ArrayElement<Base>[]
-    : Projection<Defined<Selection>, ArrayElement<Base>, E>[]
-  : Base extends Primitive | E
-  ? // Is primitive and extends undefined
-    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>
-    }
+export type Projection<Selection, Base, E = never> =
+  Base extends Array<any>
+    ? ArrayElement<Base> extends Primitive | E
+      ? ArrayElement<Base>[]
+      : Projection<Defined<Selection>, ArrayElement<Base>, E>[]
+    : Base extends Primitive | E
+      ? // Is primitive and extends undefined
+        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>
+        }
 
 export type Unpacked<T> = T extends (infer U)[]
   ? U
   : T extends (...args: any[]) => infer U
-  ? U
-  : T extends Promise<infer U>
-  ? U
-  : T
+    ? U
+    : T extends Promise<infer U>
+      ? U
+      : T
 
 export type Replacement<M extends [any, any], T> = M extends any ? ([T] extends [M[0]] ? M[1] : never) : never
 
@@ -59,8 +60,8 @@ export type DeepReplace<T, Ignore, M extends [any, any]> = {
         : T[P]
       : Replacement<M, T[P]>
     : T[P] extends object
-    ? DeepReplace<T[P], Ignore, M>
-    : T[P]
+      ? DeepReplace<T[P], Ignore, M>
+      : T[P]
 }
 
 export type RawEndpoint<I, O, E> = <S extends I>(
@@ -98,6 +99,12 @@ export type LogInfo = {
   duration: number
 }
 
+export type TypescriptClientOutput = {
+  js: string
+  mjs: string
+  typings: string
+}
+
 export class GraphQLClientError extends Error {
   responseData: ResponseData