@stepzen/transpiler 0.0.33 → 0.0.36

package/src/actions/merge.ts

@@ -0,0 +1,202 @@
+import * as fs from 'fs-extra'
+import * as glob from 'glob'
+import {mergeTypeDefs} from '@graphql-tools/merge'
+import {parse, visit} from 'graphql'
+import * as os from 'os'
+import * as path from 'path'
+
+import {
+  dedupeTempFolder,
+  findQueryMutationInSchema,
+  findTypeInSchema,
+  getSchema,
+  mergeQueryMutationIntoSchema,
+  removeQueryMutationFromSchema,
+  mergeTypeIntoSchema,
+  removeTypeFromSchema,
+  getConfiguration,
+  findNextAvailableSubfolder,
+} from '../utils/merge-helpers'
+import print from './print'
+import setFilesInSDL from '../utils/set-files-in-sdl'
+import stripEmptyQueriesAndMutations from '../utils/strip-empty-queries-and-mutations'
+
+const BLANK_INDEX_TEMPLATE = `
+schema @sdl(files: []) {
+  query: Query
+}
+
+type Query {
+  __query: String
+}
+`.trim()
+
+export default async (
+  original: string,
+  imported: {
+    name: string
+    source: string
+  },
+  options: {
+    answers: any
+    output: string | null
+    silent: boolean
+    /** when `false` merge only covers config files and updates @sdl directrive */
+    mergeTypes?: boolean
+  } = {
+    answers: {},
+    output: null,
+    silent: false,
+    mergeTypes: true,
+  },
+) => {
+  // Make sure there is an output directory
+  if (!options.answers) options.answers = {}
+  if (!options.output)
+    options.output = path.join(os.tmpdir(), `stepzen-tmp-${Date.now()}`)
+  if (!options.silent) options.silent = false
+  if (options.mergeTypes === undefined) options.mergeTypes = true
+
+  // To stop things like
+  // C:\Users\Darren\AppData\Local\Temp\stepzen-tmp-config-1638293497187\C:\Users\Darren\AppData\Local\Temp\stepzen-tmp-1638293496286
+  options.output = dedupeTempFolder(options.output)
+
+  // Ensure original, importing and output directories exist
+  if (!fs.existsSync(original))
+    throw new Error(`Cannot find original directory ${original}`)
+  if (!fs.existsSync(imported.source))
+    throw new Error(`Cannot find imported source directory ${imported.source}`)
+  fs.ensureDirSync(options.output)
+
+  // Copy the original into the output.
+  fs.copySync(original, options.output)
+
+  // Ensure an index.graphql exists
+  const outputIndex = path.join(options.output, 'index.graphql')
+  if (!fs.existsSync(outputIndex)) {
+    fs.writeFileSync(outputIndex, BLANK_INDEX_TEMPLATE)
+  }
+
+  const targetSubfolder = findNextAvailableSubfolder(original, imported.name)
+
+  if (options.mergeTypes) {
+    const merged = mergeTypeDefs([
+      await getSchema(options.output),
+      await getSchema(imported.source),
+    ])
+
+    let queries: any[] = []
+    let mutations: any[] = []
+    let types: any[] = []
+
+    visit(merged, {
+      ObjectTypeDefinition(node) {
+        if (node.name.value === 'Query') queries = queries.concat(node.fields)
+        else if (node.name.value === 'Mutation')
+          mutations = mutations.concat(node.fields)
+        else types = types.concat(node)
+      },
+    })
+
+    const details = {
+      original: glob.sync('**/*.graphql', {cwd: options.output}).map(file => {
+        const content = fs.readFileSync(`${options.output}/${file}`, 'utf8')
+        return {ast: parse(content), file}
+      }),
+      imported: glob.sync('**/*.graphql', {cwd: imported.source}).map(file => {
+        const content = fs.readFileSync(`${imported.source}/${file}`, 'utf8')
+        return {ast: parse(content), file}
+      }),
+    }
+
+    // Merge Queries and Mutations
+    for (const type of [...queries, ...mutations]) {
+      const isInOriginal = findQueryMutationInSchema(
+        type.name.value,
+        details.original,
+      )
+      const isInImported = findQueryMutationInSchema(
+        type.name.value,
+        details.imported,
+      )
+
+      if (isInOriginal && isInImported) {
+        details.original = mergeQueryMutationIntoSchema(type, details.original)
+        details.imported = removeQueryMutationFromSchema(
+          type.name.value,
+          details.imported,
+        )
+      }
+    }
+
+    // Merge Types
+    for (const type of types) {
+      const isInOriginal = findTypeInSchema(type.name.value, details.original)
+      const isInImported = findTypeInSchema(type.name.value, details.imported)
+
+      if (isInOriginal && isInImported) {
+        details.original = mergeTypeIntoSchema(type, details.original)
+        details.imported = removeTypeFromSchema(
+          type.name.value,
+          details.imported,
+        )
+      }
+    }
+
+    // Clean up the files. Remove empty Query / Mutation types, filter out now-empty files
+    const cleaned = {
+      original: details.original
+        .map(item => ({
+          ...item,
+          ast: stripEmptyQueriesAndMutations(item.ast),
+        }))
+        .filter(item => item.ast.definitions.length > 0),
+      imported: details.imported
+        .map(item => ({
+          ...item,
+          ast: stripEmptyQueriesAndMutations(item.ast),
+        }))
+        .filter(item => item.ast.definitions.length > 0),
+    }
+
+    // Write the files to the output directory
+    cleaned.original.forEach((a: any) => {
+      // eslint-disable-next-line
+      const file = path.join(options.output as any, a.file)
+      const deduped = dedupeTempFolder(file)
+
+      fs.ensureFileSync(deduped)
+      fs.writeFileSync(deduped, print(a.ast))
+    })
+
+    cleaned.imported.forEach(a => {
+      // eslint-disable-next-line
+      const file = path.join(options.output as any, targetSubfolder, a.file)
+      const deduped = dedupeTempFolder(file)
+
+      fs.ensureFileSync(deduped)
+      fs.writeFileSync(deduped, print(a.ast))
+    })
+  } else {
+    // Write the files to the output directory
+    fs.copySync(original, options.output)
+    fs.copySync(imported.source, path.join(options.output, targetSubfolder))
+  }
+
+  // Make sure all files are referenced in @sdl
+  setFilesInSDL(options.output)
+
+  // Generate configuration
+  const config = await getConfiguration(
+    [options.output, imported.source],
+    options.silent,
+    options.answers,
+  )
+  if (config) {
+    const configFile = path.join(options.output, 'config.yaml')
+    fs.writeFileSync(configFile, config as string)
+  }
+
+  // Return a merged schema!
+  return options.output
+}

package/src/actions/print.ts

@@ -0,0 +1,8 @@
+import {DocumentNode, print} from 'graphql'
+import * as prettier from 'prettier'
+
+export default (ast: DocumentNode): string => {
+  const printed = print(ast)
+  const formatted = prettier.format(printed, {parser: 'graphql'})
+  return formatted
+}

package/src/actions/stitch.ts

@@ -0,0 +1,105 @@
+import {clone, cloneDeep} from 'lodash'
+import {parse, print, visit} from 'graphql'
+import * as fs from 'fs-extra'
+import * as glob from 'glob'
+import * as os from 'os'
+import * as path from 'path'
+import * as prettier from 'prettier'
+
+import dedupeQueryAndMutationTypes from '../utils/dedupe-query-and-mutation-types'
+
+export default (
+  source: string,
+  output: string = path.join(os.tmpdir(), `stepzen-tmp-${Date.now()}`),
+) => {
+  // Ensure source and output directories exist
+  if (!fs.existsSync(source))
+    throw new Error(`Cannot find source directory ${source}`)
+  fs.ensureDirSync(output)
+
+  // Get a list of files.
+  let ast: any
+  let files: string[] = []
+
+  // If there's an index.graphQL - get files argument in @sdl directive
+  const sourceIndex = path.join(source, 'index.graphql')
+
+  if (fs.existsSync(sourceIndex)) {
+    const index = fs.readFileSync(sourceIndex, 'utf8')
+    ast = parse(index)
+    ast = visit(ast, {
+      Directive(node) {
+        if (node.name.value === 'sdl') {
+          const list = node.arguments?.find(
+            (arg: any) => arg.name.value === 'files',
+          )
+          // If we find a 'files' argument, we copy the list, and remove the argument
+          if (list) {
+            const copy: any = clone(list.value)
+            for (const file of copy.values) {
+              files = files.concat(file.value)
+            }
+            const mutated: any = cloneDeep(node)
+            mutated.arguments = mutated.arguments.filter(
+              (arg: any) => arg.name.value !== 'files',
+            )
+            return mutated
+          }
+        }
+      },
+    })
+  } else {
+    const content = glob
+      .sync('**/*.graphql', {cwd: source})
+      .map((file: string) => {
+        const graphql = fs.readFileSync(`${source}/${file}`, 'utf8')
+        return graphql
+      })
+    ast = parse(content.join(os.EOL))
+  }
+
+  // Strip @sdl directive
+  ast = visit(ast, {
+    Directive(node) {
+      if (node.name.value === 'sdl') return null
+    },
+  })
+
+  // Check all the files exist
+  for (const file of files) {
+    const find = path.join(source, file)
+    if (!fs.existsSync(find)) {
+      throw new Error(`Cannot find file ${find}`)
+    }
+  }
+
+  // Get all the files and stitch
+  const printed = print(ast)
+  let stitched = `${printed}${os.EOL}`
+  for (const file of files) {
+    const find = path.join(source, file)
+    const content = fs.readFileSync(find, 'utf8')
+    stitched += `${content}${os.EOL}`
+  }
+
+  // Dedupe Query and Mutation types
+  stitched = dedupeQueryAndMutationTypes(stitched)
+
+  // Format
+  stitched = prettier.format(stitched, {parser: 'graphql'})
+
+  // Write to output folder
+  const outputIndex = path.join(output, 'index.graphql')
+  fs.writeFileSync(outputIndex, stitched)
+
+  // Copy config if exists, too
+  const sourceConfig = path.join(source, 'config.yaml')
+  const outputConfig = path.join(output, 'config.yaml')
+
+  if (fs.existsSync(sourceConfig)) {
+    fs.copyFileSync(sourceConfig, outputConfig)
+  }
+
+  // Return output folder
+  return output
+}

package/src/actions/transpile.ts

@@ -0,0 +1,70 @@
+import {DocumentNode, parse} from 'graphql'
+import * as dotenv from 'dotenv'
+import * as fs from 'fs'
+import * as glob from 'glob'
+import * as path from 'path'
+
+import print from '../actions/print'
+import stitch from '../actions/stitch'
+import configure from './configure'
+
+import configMutations from '../mutations/config'
+
+export default async (source: string) => {
+  // Ensure source and output directories exist
+  if (!fs.existsSync(source)) {
+    throw new Error(`Cannot find source directory ${source}`)
+  }
+
+  // Load env vars, from working and source directories
+  dotenv.config()
+  dotenv.config({path: path.resolve(source, '.env')})
+
+  // State of whether we've transpiled or not
+  let transpiledConfig = false
+  let transpiledGraphQL = false
+
+  // See whether to transpile config
+  let config: any = await configure(source, true)
+  const configCopy = config
+
+  if (config) {
+    for await (const mutation of configMutations) {
+      config = await mutation(config)
+    }
+  }
+
+  if (configCopy !== config) {
+    transpiledConfig = true
+  }
+
+  // See whether to transpile GraphQL
+  const graphqlFiles = glob.sync('**/*.graphql', {cwd: source})
+  let original: any = ''
+  let mutated: any = ''
+
+  if (graphqlFiles.length > 0) {
+    const stitched = await stitch(source)
+
+    const index = path.join(stitched, 'index.graphql')
+
+    const graphql = fs.readFileSync(index, 'utf8')
+
+    let ast: DocumentNode = parse(graphql)
+    original = parse(graphql)
+
+    // you can transpile schema ast here
+
+    mutated = print(ast)
+
+    if (print(original) !== mutated) {
+      transpiledGraphQL = true
+    }
+  }
+
+  return {
+    config,
+    schema: mutated,
+    transpiled: transpiledConfig || transpiledGraphQL,
+  }
+}

package/src/actions/validate.ts

@@ -0,0 +1,54 @@
+import {buildASTSchema, DocumentNode, parse, print} from 'graphql'
+import * as fs from 'fs-extra'
+import * as os from 'os'
+import * as path from 'path'
+
+import ensureQueryAndMutationTypes from '../utils/ensure-query-and-mutation-types'
+import {EXPERIMENTAL_EXTENSIONS} from '../utils/constants'
+import validators from '../validators'
+
+export default (
+  source: string,
+  options: {
+    extensions: string
+  } = {
+    extensions: '',
+  },
+) => {
+  // Ensure source and output directories exist
+  if (!fs.existsSync(source)) {
+    throw new Error(`Cannot find source directory ${source}`)
+  }
+
+  // Ensure index.graphql exists
+  if (!fs.existsSync(`${source}/index.graphql`)) {
+    throw new Error(`Cannot find index.graphql in ${source}`)
+  }
+
+  // Get the index.graphql file
+  const file = path.join(source, 'index.graphql')
+  const index = fs.readFileSync(file, 'utf8')
+
+  // Parse
+  let ast: DocumentNode = parse(
+    `${EXPERIMENTAL_EXTENSIONS}${os.EOL}${options.extensions}${os.EOL}${index}`,
+    {
+      noLocation: true,
+    },
+  )
+
+  // We make an exception for 'no type Query' or 'no type Mutation'
+  ast = ensureQueryAndMutationTypes(ast)
+
+  // Build and print, to validate
+  buildASTSchema(ast)
+  print(ast)
+
+  // Custom validators
+  for (const validator of validators) {
+    validator(ast, source)
+  }
+
+  // Return true
+  return true
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export {default as configure} from './actions/configure'
+export {default as lint} from './actions/lint'
+export {default as merge} from './actions/merge'
+export {default as print} from './actions/print'
+export {default as stitch} from './actions/stitch'
+export {default as transpile} from './actions/transpile'
+export {default as validate} from './actions/validate'

package/src/mutations/config/envvars.ts

@@ -0,0 +1,17 @@
+export default async (config: string): Promise<string> => {
+  const envvars = Object.keys(process.env)
+    .filter(key => {
+      return key.startsWith(`STEPZEN_`)
+    })
+    .reduce((obj: any, key) => {
+      obj[key] = process.env[key]
+      return obj
+    }, {})
+
+  for (const [key, value] of Object.entries(envvars)) {
+    const regex = new RegExp(key, 'g')
+    config = config.replace(regex, `${value}`)
+  }
+
+  return config
+}

package/src/mutations/config/index.ts

@@ -0,0 +1,3 @@
+import envvars from './envvars'
+
+export default [envvars]

package/src/utils/constants.ts

@@ -0,0 +1,16 @@
+import * as dotenv from 'dotenv'
+
+dotenv.config()
+
+const {STEPZEN_DOMAIN: ENV_VAR_STEPZEN_DOMAIN} = process.env
+
+export const EXPERIMENTAL_EXTENSIONS = `
+directive @experimental(
+  debug: Boolean
+  function: String
+  mock: String
+  setter: String
+) on OBJECT | FIELD_DEFINITION
+`
+
+export const STEPZEN_DOMAIN = ENV_VAR_STEPZEN_DOMAIN || 'stepzen.io'

package/src/utils/dedupe-query-and-mutation-types.ts

@@ -0,0 +1,74 @@
+import {DocumentNode, parse, print, visit} from 'graphql'
+
+import {cloneDeep} from '../utils/graphql-helpers'
+
+export default (schema: string): string => {
+  let ast: DocumentNode = parse(schema)
+
+  let queries: any = []
+  let mutations: any = []
+
+  // Loop through the AST and find Query and Mutation types.
+  // Store their fields.
+  // Return null to remove it from the tree
+  ast = visit(ast, {
+    ObjectTypeDefinition: {
+      enter(node) {
+        if (node.name.kind === 'Name' && node.name.value === 'Query') {
+          queries = queries.concat(node.fields)
+          return null
+        }
+        if (node.name.kind === 'Name' && node.name.value === 'Mutation') {
+          mutations = mutations.concat(node.fields)
+          return null
+        }
+      },
+    },
+  })
+
+  // This is the template for the new Query type
+  const queryTemplate = {
+    kind: 'ObjectTypeDefinition',
+    description: undefined,
+    name: {kind: 'Name', value: 'Query'},
+    interfaces: [],
+    directives: [],
+    fields: [],
+  }
+
+  // This is the template for the new Mutation type
+  const mutationTemplate = {
+    kind: 'ObjectTypeDefinition',
+    description: undefined,
+    name: {kind: 'Name', value: 'Mutation'},
+    interfaces: [],
+    directives: [],
+    fields: [],
+  }
+
+  // If there are queries, add a single Query type
+  // with all the concatenated queries
+  if (queries.length > 0) {
+    const mutated: any = cloneDeep(ast)
+    const query = {
+      ...queryTemplate,
+      fields: queries,
+    }
+    mutated.definitions.push(query)
+    ast = mutated
+  }
+
+  // If there are mutations, add a single Query type
+  // with all the concatenated mutations
+  if (mutations.length > 0) {
+    const mutated: any = cloneDeep(ast)
+    const query = {
+      ...mutationTemplate,
+      fields: mutations,
+    }
+    mutated.definitions.push(query)
+    ast = mutated
+  }
+
+  return print(ast)
+}

package/src/utils/ensure-query-and-mutation-types.ts

@@ -0,0 +1,52 @@
+import {DocumentNode, visit} from 'graphql'
+
+import {cloneDeep} from '../utils/graphql-helpers'
+
+export default (ast: DocumentNode): DocumentNode => {
+  let queries: any = []
+  let mutations: any = []
+
+  // Loop through the AST and find Query and Mutation types.
+  ast = visit(ast, {
+    ObjectTypeDefinition: {
+      enter(node) {
+        if (node.name.kind === 'Name' && node.name.value === 'Query') {
+          queries = queries.concat(node.fields)
+        }
+        if (node.name.kind === 'Name' && node.name.value === 'Mutation') {
+          mutations = mutations.concat(node.fields)
+        }
+      },
+    },
+  })
+
+  // If there are no queries, add a single empty Query type
+  if (queries.length === 0) {
+    const mutated: any = cloneDeep(ast)
+    mutated.definitions.push({
+      kind: 'ObjectTypeDefinition',
+      description: undefined,
+      name: {kind: 'Name', value: 'Query'},
+      interfaces: [],
+      directives: [],
+      fields: [],
+    })
+    ast = mutated
+  }
+
+  // If there are mutations, add a single empty Mutation type
+  if (mutations.length === 0) {
+    const mutated: any = cloneDeep(ast)
+    mutated.definitions.push({
+      kind: 'ObjectTypeDefinition',
+      description: undefined,
+      name: {kind: 'Name', value: 'Mutation'},
+      interfaces: [],
+      directives: [],
+      fields: [],
+    })
+    ast = mutated
+  }
+
+  return ast
+}

package/src/utils/graphql-helpers.ts

@@ -0,0 +1,3 @@
+export const cloneDeep = (obj: any) => {
+  return JSON.parse(JSON.stringify(obj))
+}