graphql-typed-client/src/render/common/RenderContext.ts

A tool that generates a strongly typed client library for any GraphQL endpoint. The client allows writing GraphQL queries as plain JS objects (with type safety, awesome code completion experience, custom scalar type mapping, type guards and more)

import { GraphQLSchema } from 'graphql'
import { BuiltInParserName } from 'prettier'
import { Config } from '../../config'
import { prettify } from '../../helpers/prettify'
import { relativeImportPath } from './relativeImportPath'

interface Import {
  isDefault: boolean
  module?: string
  alias?: string
}

interface ImportMap {
  [from: string]: Import[]
}

export class RenderContext {
  protected codeBlocks: string[] = []
  protected imports: ImportMap = {}
  protected importAliasCounter = 0

  constructor(public schema?: GraphQLSchema, public config?: Config) {}

  addCodeBlock(block: string) {
    this.codeBlocks.push(block)
  }

  addImport(from: string, isDefault: boolean, module?: string, fromAbsolute?: boolean, noAlias?: boolean) {
    if (this.config && this.config.output) {
      from = fromAbsolute ? from : relativeImportPath(this.config.output, from)
    }

    if (!this.imports[from]) this.imports[from] = []

    const imports = this.imports[from]

    const existing = imports.find(i => (isDefault && i.isDefault) || (!isDefault && i.module === module))

    if (existing) return existing.alias

    this.importAliasCounter++
    const alias = noAlias ? undefined : `a${this.importAliasCounter}`
    imports.push({ isDefault, module, alias })

    return alias
  }

  protected getImportBlock() {
    const imports: string[] = []

    Object.keys(this.imports).forEach(from => {
      let defaultImport = this.imports[from].find(i => i.isDefault)
      const namedImports = this.imports[from].filter(i => !i.isDefault)
      const statements = []

      if (defaultImport) {
        statements.push(defaultImport.alias)
      }

      if (namedImports.length > 0) {
        statements.push(`{${namedImports.map(i => (i.alias ? `${i.module} as ${i.alias}` : i.module)).join(',')}}`)
      }

      imports.push(`import ${statements.join(',')} from '${from}'`)
    })

    if (imports.length > 0) return imports.join('\n')
    else return
  }

  toCode(parser?: BuiltInParserName) {
    const blocks = [...this.codeBlocks]

    if (parser && (parser === 'typescript' || parser === 'babel')) {
      const importBlock = this.getImportBlock()
      if (importBlock) blocks.unshift(importBlock)
    }

    return parser ? prettify(blocks.join('\n\n'), parser) : blocks.join('')
  }
}