@avantstay/graphql-ts-client 10.5.0

package/src/graphqlRequest.ts

@@ -0,0 +1,95 @@
+import _axios, { AxiosStatic } from 'axios'
+import { ClientConfig, GraphQLClientError, ResponseData } from './types'
+
+const sleep = (ms = 0) =>
+  new Promise<void>(resolve => {
+    setTimeout(() => resolve(), ms)
+  })
+
+export async function graphqlRequest({
+  shouldRetry = true,
+  axios = _axios,
+  queryName,
+  client,
+  query,
+  requestHeaders = {},
+  variables,
+  failureMode,
+  errorsParser,
+}: {
+  shouldRetry?: boolean
+  failureMode: 'loud' | 'silent'
+  axios?: AxiosStatic
+  client: ClientConfig
+  queryName: string
+  query: string
+  requestHeaders?: { [_key: string]: any }
+  variables: { [_key: string]: any }
+  errorsParser?: (errors: any[]) => any
+}) {
+  let lastResponse: ResponseData
+
+  const maxRetrials = shouldRetry ? client.retryConfig.max : 0
+
+  for (let trial = 0; true; trial++) {
+    const infoParams = {
+      _q: queryName,
+      ...(trial > 0 ? { _retrial: trial + 1 } : {}),
+    }
+
+    const {
+      data: responseData = {} as any,
+      headers,
+      status,
+    } = await axios.post(
+      client.url,
+      { query, variables, operationName: queryName },
+      {
+        params: infoParams,
+        headers: {
+          'Content-Type': 'application/json',
+          ...client.headers,
+          ...requestHeaders,
+        },
+        validateStatus: () => true,
+      }
+    )
+
+    let { data, errors, warnings } = responseData
+
+    if (status >= 400 && !errors?.length) {
+      errors = [{ message: `Request "${queryName}" failed with status ${status}` }]
+    }
+
+    lastResponse = {
+      errors: errorsParser ? errorsParser(errors) : errors,
+      data,
+      warnings,
+      headers,
+      status,
+    }
+
+    if (!errors?.length) {
+      break
+    } else if (trial < maxRetrials && typeof client.retryConfig?.before === 'function') {
+      await client.retryConfig?.before({
+        queryName,
+        query,
+        variables,
+        response: lastResponse,
+      })
+
+      if (client.retryConfig.waitBeforeRetry) {
+        await sleep(client.retryConfig.waitBeforeRetry)
+      }
+    } else if (trial >= maxRetrials) {
+      break
+    }
+  }
+
+  if (failureMode === 'loud' && lastResponse!.errors && lastResponse!.errors?.length) {
+    throw new GraphQLClientError(lastResponse)
+  }
+
+  return lastResponse!
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { generateTypescriptClient } from './generateTypescriptClient'
+
+export * from './types'

package/src/jsonToGraphQLQuery.test.ts

@@ -0,0 +1,66 @@
+import { jsonToGraphQLQuery } from './jsonToGraphQLQuery'
+
+describe('jsonToGraphQLQuery', () => {
+  it('use args without mutating', () => {
+    const jsonQuery = {
+      __args: {
+        foo: 'Bar',
+      },
+
+      something: true,
+    }
+
+    const originalArgs = JSON.stringify(jsonQuery)
+
+    const response = jsonToGraphQLQuery({
+      kind: 'query',
+      queryName: 'testing',
+      jsonQuery,
+      typesTree: {
+        Query: {
+          get testing(): any {
+            return {
+              __args: {
+                foo: 'UUID!',
+              },
+            }
+          },
+        },
+      },
+    })
+
+    expect(response).not.toBeNull()
+    expect(originalArgs).toBe(JSON.stringify(jsonQuery))
+  })
+
+  it('variables are correctly named', () => {
+    const jsonQuery = {
+      __args: {
+        foo: 'Bar',
+      },
+
+      something: true,
+    }
+
+    const response = jsonToGraphQLQuery({
+      kind: 'query',
+      queryName: 'testing',
+      jsonQuery,
+      typesTree: {
+        Query: {
+          get testing(): any {
+            return {
+              __args: {
+                foo: 'UUID!',
+              },
+            }
+          },
+        },
+      },
+    })
+
+    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
+    })
+  })
+})

package/src/jsonToGraphQLQuery.ts

@@ -0,0 +1,88 @@
+import omit from 'lodash/omit'
+
+const VAR_PREFIX = '@@VAR@@'
+const VAR_PREFIX_LENGTH = VAR_PREFIX.length
+
+const fromEntries: (arr: [string, any][]) => { [key: string]: any } = require('lodash/fromPairs')
+const entries: (obj: { [key: string]: any }) => [string, any][] = require('lodash/toPairs')
+const cloneDeep = require('lodash/cloneDeep')
+
+export function jsonToGraphQLQuery({
+  kind,
+  queryName,
+  jsonQuery = {},
+  typesTree,
+}: {
+  kind: 'query' | 'mutation'
+  queryName: string
+  jsonQuery: any
+  typesTree: any
+}) {
+  const variablesData = {} as any
+  const alias = jsonQuery.__alias
+  const newJsonQuery = cloneDeep(omit(jsonQuery, ['__alias', '__headers']))
+
+  extractVariables({
+    jsonQuery: { [queryName]: newJsonQuery },
+    variables: variablesData,
+    parentType: kind === 'query' ? typesTree.Query : typesTree.Mutation,
+  })
+
+  const variablesQuery = Object.keys(variablesData).length
+    ? `(${entries(variablesData)
+        .map(([queryName, { type }]: any) => `$${queryName}: ${type}`)
+        .join(', ')})`
+    : ''
+
+  const query = `${kind} ${alias || queryName}${variablesQuery} { ${alias ? `${alias}:` : ''}${queryName}${toGraphql(
+    newJsonQuery
+  )} }`
+  const variables = fromEntries(entries(variablesData).map(([k, v]: any) => [k, v.value]))
+
+  return {
+    query,
+    variables,
+  }
+}
+
+function extractVariables({ jsonQuery, variables, parentType }: { jsonQuery: any; variables: any; 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
+
+      const variableName = `${k}_${Math.random().toString(36).substr(2, 4)}`
+
+      if (jsonQuery.__args[k] !== undefined) {
+        variables[variableName] = {
+          type: parentType.__args[k],
+          value: jsonQuery.__args[k],
+        }
+        jsonQuery.__args[k] = `${VAR_PREFIX}$${variableName}`
+      }
+    })
+  }
+
+  Object.keys(jsonQuery)
+    .filter(k => k !== '__args' && typeof jsonQuery[k] === 'object')
+    .forEach(k =>
+      extractVariables({
+        jsonQuery: jsonQuery[k],
+        variables,
+        parentType: parentType.hasOwnProperty(k) ? parentType[k] : parentType.__fields ? parentType.__fields[k] : undefined,
+      })
+    )
+}
+
+function toGraphql(jsonQuery: any) {
+  const fields = entries(jsonQuery)
+    .filter(([k, v]) => k !== '__args' && v !== false && v !== undefined)
+    .map(([k, v]) => (typeof v === 'object' ? `${k}${toGraphql(v)}` : k))
+    .join(' ') as any
+
+  const validArgs = jsonQuery.__args ? entries(jsonQuery.__args).filter(([_, v]) => v !== undefined) : []
+  const argsQuery = validArgs.length ? `(${validArgs.map(([k, v]: any) => `${k}:${v.substr(VAR_PREFIX_LENGTH)}`).join(',')})` : ''
+
+  return `${argsQuery} ${fields ? `{ ${fields} }` : ''}`
+}

package/src/logging.ts

@@ -0,0 +1,33 @@
+import { LogInfo } from './types'
+
+export function logRequest(logInfo: LogInfo) {
+  let identifier = `%c#graphql-ts-client ${logInfo.kind} ${logInfo.queryName}`
+  let identifierStyles = 'color: transparent; font-size: 0px'
+
+  console.groupCollapsed(
+    `%c#graphql-ts-client %c${logInfo.kind} %c${logInfo.queryName} %c(${logInfo.duration.toFixed(2)}ms)`,
+    'color: #f90',
+    'color: #999',
+    `color: ${logInfo.response ? 'unset' : '#f00'}; font-weight: bold`,
+    'color: #999'
+  )
+
+  console.groupCollapsed(`%cQuery ${identifier}`, 'color: #999', identifierStyles)
+  console.log(logInfo.formatGraphQL(logInfo.query) + identifier, identifierStyles)
+  console.groupEnd()
+  console.groupCollapsed(`%cVariables ${identifier}`, 'color: #999', identifierStyles)
+  console.log(JSON.stringify(logInfo.variables, null, '  ') + identifier, identifierStyles)
+  console.groupEnd()
+  console.groupCollapsed(`%cTrace ${identifier}`, 'color: #999', identifierStyles)
+  console.trace(identifier, identifierStyles)
+  console.groupEnd()
+
+  if (logInfo.response) {
+    console.log('%cResponse'.padEnd(15, ' ') + identifier, 'color: #999', identifierStyles, logInfo.response)
+  }
+  if (logInfo.error) {
+    console.log('%cError'.padEnd(15, ' ') + identifier, 'color: #999', identifierStyles, logInfo.error)
+  }
+
+  console.groupEnd()
+}

package/src/testServer.ts

@@ -0,0 +1,71 @@
+import { ApolloServer, gql } from 'apollo-server'
+
+const typeDefs = gql`
+  scalar ISODate
+
+  enum BookType {
+    IPSUM
+    DOLOR
+    SIT
+  }
+
+  type Book {
+    title: String
+    author: String
+    type: BookType
+    dateCreated: ISODate
+  }
+
+  input BookSearchParamsAllOptional {
+    title: String
+    author: String
+    createdAfter: ISODate
+  }
+
+  input BookSearchParamsSomeRequired {
+    title: String!
+    author: String
+  }
+
+  type Query {
+    booksWithoutParams: [Book]
+    booksWithOptionalParams(params: BookSearchParamsAllOptional! = {}): [Book]
+    booksWithRequiredParams(params: BookSearchParamsSomeRequired!): [Book]
+    failingQuery(id: String!): String
+  }
+`
+
+const books = [
+  {
+    title: 'The Awakening',
+    author: 'Kate Chopin',
+  },
+  {
+    title: 'City of Glass',
+    author: 'Paul Auster',
+  },
+]
+
+function filterBooks(params: { title?: string; author?: string }) {
+  return books.filter(
+    book => (!params.title || book.title.includes(params.title)) && (!params.author || book.author.includes(params.author))
+  )
+}
+
+const resolvers = {
+  Query: {
+    booksWithoutParams: () => books,
+    booksWithOptionalParams: (_: any, { params = {} }: { params: { title?: string; author?: string } }) => filterBooks(params),
+    booksWithRequiredParams: (_: any, { params }: { params: { title: string; author?: string } }) => filterBooks(params),
+    failingQuery: () => {
+      throw new Error('Failed lorem ipsum dolor')
+    },
+  },
+}
+
+const testServer = new ApolloServer({
+  typeDefs,
+  resolvers,
+})
+
+export const startServer = () => testServer.listen(4123).then(({ url }) => ({ url, server: testServer }))

package/src/types.ts

@@ -0,0 +1,114 @@
+export type Maybe<T> = null | undefined | T
+export type Defined<T> = Exclude<T, undefined>
+
+export type ResponseData = {
+  data: any
+  warnings: any
+  headers: any
+  status?: number
+  errors: {
+    message: string
+  }[]
+}
+
+export type ResponseListenerInfo = {
+  queryName: string
+  query: string
+  variables: any
+  response: ResponseData
+}
+export type IResponseListener = (info: ResponseListenerInfo) => void | Promise<void>
+
+type ArrayElement<ArrayType extends readonly unknown[]> = ArrayType extends readonly (infer ElementType)[] ? ElementType : never
+
+export 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
+  ? // 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
+
+export type Replacement<M extends [any, any], T> = M extends any ? ([T] extends [M[0]] ? M[1] : never) : never
+
+export 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]
+}
+
+export type RawEndpoint<I, O, E> = <S extends I>(
+  jsonQuery?: S
+) => Promise<{ data: Projection<S, O, E>; errors: any[]; warnings: any[]; headers: any; status: any }>
+
+export type JsonOutput<O, ToBeIgnored> = DeepReplace<O, ToBeIgnored, [string | Date, string]>
+
+export 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>
+}
+
+export type ClientConfig = {
+  url: string
+  headers: {
+    [key: string]: string
+  }
+  retryConfig: {
+    max: number
+    waitBeforeRetry?: number
+    before: IResponseListener
+  }
+}
+
+export type LogInfo = {
+  query: string
+  variables: any
+  formatGraphQL: any
+  kind: string
+  queryName: string
+  response?: any
+  error?: Error
+  duration: number
+}
+
+export class GraphQLClientError extends Error {
+  responseData: ResponseData
+
+  constructor(responseData: ResponseData) {
+    super()
+    this.responseData = responseData
+    Object.setPrototypeOf(this, GraphQLClientError.prototype)
+  }
+
+  get message(): string {
+    return this.response.errors.map(it => it.message).join(';\n')
+  }
+
+  get response(): ResponseData {
+    return this.responseData
+  }
+}