@stepzen/transpiler 0.0.32 → 0.0.35

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))
+}

package/src/utils/merge-helpers.ts

@@ -0,0 +1,176 @@
+import {BREAK, GraphQLSchema, visit} from 'graphql'
+import {buildSchema} from 'graphql/utilities'
+import fetch from 'node-fetch'
+import * as fs from 'fs-extra'
+import * as glob from 'glob'
+import * as os from 'os'
+import * as path from 'path'
+import {replace} from 'lodash'
+
+import {cloneDeep} from '../utils/graphql-helpers'
+import {STEPZEN_DOMAIN} from './constants'
+
+import configure from '../actions/configure'
+import transpile from '../actions/transpile'
+
+export const dedupeTempFolder = (dirpath: string) => {
+  do {
+    dirpath = replace(dirpath, os.tmpdir(), '')
+  } while (dirpath.includes(os.tmpdir()))
+
+  dirpath = path.join(os.tmpdir(), dirpath)
+
+  return dirpath
+}
+
+export const findQueryMutationInSchema = (
+  name: string,
+  files: any,
+): Boolean => {
+  for (const file of files) {
+    let found = false
+    visit(file.ast, {
+      FieldDefinition(node) {
+        if (node.name.value === name) {
+          found = true
+          return BREAK
+        }
+      },
+    })
+    if (found) return true
+  }
+  return false
+}
+
+export const findTypeInSchema = (name: string, files: any): Boolean => {
+  for (const file of files) {
+    let found = false
+    visit(file.ast, {
+      ObjectTypeDefinition(node) {
+        if (node.name.value === name) {
+          found = true
+          return BREAK
+        }
+      },
+    })
+    if (found) return true
+  }
+  return false
+}
+
+export const getConfiguration = async (
+  directories: string[],
+  silent: boolean = false,
+  answers: any = {},
+): Promise<string | boolean> => {
+  const tmp = path.join(os.tmpdir(), `stepzen-tmp-config-${Date.now()}`)
+  fs.ensureDirSync(tmp)
+
+  for (const directory of directories) {
+    const configs = [
+      ...glob.sync('**/config.yaml', {cwd: directory}),
+      ...glob.sync('**/stepzen.config.json', {cwd: directory}),
+    ]
+
+    for (const config of configs) {
+      const configFolder = path.join(directory, config)
+
+      let writeFolder = path.join(tmp, directory, config)
+      writeFolder = dedupeTempFolder(writeFolder)
+
+      const content = fs.readFileSync(configFolder, 'utf8')
+
+      fs.ensureFileSync(writeFolder)
+      fs.writeFileSync(writeFolder, content)
+    }
+  }
+
+  const configuration = await configure(tmp, silent, answers)
+  fs.removeSync(tmp)
+  return configuration
+}
+
+export const getExtensions = async (): Promise<string> => {
+  const domain = STEPZEN_DOMAIN.replace('.io', '.net')
+  const response = await fetch(`https://www.${domain}/directives.graphql`)
+  const text = await response.text()
+  return text
+}
+
+export const getSchema = async (directory: string): Promise<GraphQLSchema> => {
+  const extensions = await getExtensions()
+  const transpiled = await transpile(directory)
+  return buildSchema(`${extensions}${os.EOL}${transpiled.schema}`)
+}
+
+export const mergeQueryMutationIntoSchema = (type: any, files: any) => {
+  files = files.map((file: any) => {
+    return {
+      ...file,
+      ast: visit(file.ast, {
+        FieldDefinition(node) {
+          if (node.name.value === type.name.value) {
+            const directives = cloneDeep(type.directives)
+            const mutated: any = cloneDeep(node)
+            mutated.directives = directives
+            return mutated
+          }
+        },
+      }),
+    }
+  })
+  return files
+}
+
+export const mergeTypeIntoSchema = (type: any, files: any) => {
+  files = files.map((file: any) => {
+    return {
+      ...file,
+      ast: visit(file.ast, {
+        ObjectTypeDefinition(node) {
+          if (node.name.value === type.name.value) {
+            const directives = cloneDeep(type.directives)
+            const fields = cloneDeep(type.fields)
+            const mutated: any = cloneDeep(node)
+            mutated.directives = directives
+            mutated.fields = fields
+            return mutated
+          }
+        },
+      }),
+    }
+  })
+  return files
+}
+
+export const removeQueryMutationFromSchema = (name: string, files: any) => {
+  files = files.map((file: any) => {
+    return {
+      ...file,
+      ast: visit(file.ast, {
+        FieldDefinition(node) {
+          if (node.name.value === name) {
+            return null
+          }
+        },
+      }),
+    }
+  })
+  return files
+}
+
+export const removeTypeFromSchema = (name: string, files: any) => {
+  files = files.map((file: any) => {
+    return {
+      ...file,
+      ast: visit(file.ast, {
+        ObjectTypeDefinition(node) {
+          if (node.name.value === name) {
+            return null
+          }
+        },
+      }),
+    }
+  })
+  return files
+}

package/src/utils/set-files-in-sdl.ts

@@ -0,0 +1,40 @@
+import * as fs from 'fs'
+import * as glob from 'glob'
+import {parse, visit} from 'graphql'
+import * as path from 'path'
+
+import {cloneDeep} from './graphql-helpers'
+import print from '../actions/print'
+
+export default (source: string) => {
+  const files = glob
+    .sync('**/*.graphql', {cwd: source})
+    .filter(file => file !== 'index.graphql')
+
+  const output = path.join(source, 'index.graphql')
+
+  const index = fs.readFileSync(output, 'utf8')
+
+  let ast = parse(index)
+  ast = visit(ast, {
+    Directive(node) {
+      if (node.name.value === 'sdl') {
+        const mutated: any = cloneDeep(node)
+
+        mutated.arguments = mutated.arguments.map((arg: any) => {
+          if (arg.name.value === 'files') {
+            arg.value.values = files.map(file => ({
+              kind: 'StringValue',
+              value: file,
+            }))
+          }
+          return arg
+        })
+
+        return mutated
+      }
+    },
+  })
+
+  fs.writeFileSync(output, print(ast))
+}

package/src/utils/strip-empty-queries-and-mutations.ts

@@ -0,0 +1,43 @@
+import {DocumentNode, visit} from 'graphql'
+
+import {cloneDeep} from './graphql-helpers'
+
+export default (ast: DocumentNode): DocumentNode => {
+  // Loop through the AST and nuke `__query` and `__mutation` stubs
+  ast = visit(ast, {
+    ObjectTypeDefinition: {
+      enter(node) {
+        if (node.name.kind === 'Name' && node.name.value === 'Query') {
+          const mutated: any = cloneDeep(node)
+          mutated.fields = mutated.fields.filter((field: any) => {
+            return field.name.value !== '__query'
+          })
+          return mutated
+        }
+        if (node.name.kind === 'Name' && node.name.value === 'Mutation') {
+          const mutated: any = cloneDeep(node)
+          mutated.fields = mutated.fields.filter((field: any) => {
+            return field.name.value !== '__mutated'
+          })
+          return mutated
+        }
+      },
+    },
+  })
+
+  // Strip empty Queries and Mutations definitions
+  ast = visit(ast, {
+    ObjectTypeDefinition: {
+      enter(node) {
+        if (node.name.kind === 'Name' && node.name.value === 'Query') {
+          if (node.fields?.length === 0) return null
+        }
+        if (node.name.kind === 'Name' && node.name.value === 'Mutation') {
+          if (node.fields?.length === 0) return null
+        }
+      },
+    },
+  })
+
+  return ast
+}