text: #!/usr/bin/env node
  
  // [start-readme]
  //
  // This script creates the static GraphQL files for a new version.
  //
  // [end-readme]
  
  import fs from 'fs/promises'
  import path from 'path'
  import program from 'commander'
  import mkdirp from 'mkdirp'
  import { allVersions } from '../../lib/all-versions.js'
  
  const graphqlStaticDir = path.join(process.cwd(), 'lib/graphql/static')
  const graphqlDataDir = path.join(process.cwd(), 'data/graphql')
  
  program
    .description('Create GraphQL files in lib/graphql/static based on an existing version.')
    .option(
      '-n, --newVersion <version>',
      'The version to copy the files to. Must be in <plan@release> format.'
    )
    .option(
      '-o, --oldVersion <version>',
      'The version to copy the files from. Must be in <plan@release> format.'
    )
    .parse(process.argv)
  
  const newVersion = program.opts().newVersion
  const oldVersion = program.opts().oldVersion
  
  if (!(newVersion && oldVersion)) {
    console.log('Error! You must provide --newVersion and --oldVersion.')
    process.exit(1)
  }
  
  if (
    !(Object.keys(allVersions).includes(newVersion) && Object.keys(allVersions).includes(oldVersion))
  ) {
    console.log(
      'Error! You must provide the full name of a currently supported version, e.g., enterprise-server@2.22.'
    )
    process.exit(1)
  }
  
  const newVersionId = allVersions[newVersion].miscVersionName
  const oldVersionId = allVersions[oldVersion].miscVersionName
  
  // copy the schema file wholesale (there are separate schema files per version)
  const newSchemaFile = path.join(graphqlStaticDir, `schema-${newVersionId}.json`)
  const oldSchemaFile = path.join(graphqlStaticDir, `schema-${oldVersionId}.json`)
  await fs.copyFile(oldSchemaFile, newSchemaFile)
  
  // check that it worked
  try {
    await fs.readFile(newSchemaFile)
  } catch (e) {
    console.log(`Error! Can't find ${newSchemaFile}.`)
    process.exit(1)
  }
  
  // the other files are objects with versions as keys, so we need to require them
  const previewsFile = path.join(graphqlStaticDir, 'previews.json')
  const changesFile = path.join(graphqlStaticDir, 'upcoming-changes.json')
  const objectsFile = path.join(graphqlStaticDir, 'prerendered-objects.json')
  const inputObjectsFile = path.join(graphqlStaticDir, 'prerendered-input-objects.json')
  
  const previews = JSON.parse(await fs.readFile(previewsFile))
  const changes = JSON.parse(await fs.readFile(changesFile))
  const objects = JSON.parse(await fs.readFile(objectsFile))
  const inputObjects = JSON.parse(await fs.readFile(inputObjectsFile))
  // The prerendered objects file for the "old version" contains hardcoded links with the old version number.
  // We need to update those links to include the new version to prevent a test from failing.
  const regexOldVersion = new RegExp(oldVersion, 'gi')
  const stringifiedObject = JSON.stringify(objects[oldVersionId]).replace(regexOldVersion, newVersion)
  const stringifiedInputObject = JSON.stringify(inputObjects[oldVersionId]).replace(
    regexOldVersion,
    newVersion
  )
  
  previews[newVersionId] = previews[oldVersionId]
  changes[newVersionId] = changes[oldVersionId]
  objects[newVersionId] = JSON.parse(stringifiedObject)
  inputObjects[newVersionId] = JSON.parse(stringifiedInputObject)
  
  // check that it worked
  if (!Object.keys(previews).includes(newVersionId)) {
    console.log(`Error! Can't find ${newVersionId} in ${previewsFile}.`)
    process.exit(1)
  }
  
  if (!Object.keys(changes).includes(newVersionId)) {
    console.log(`Error! Can't find ${newVersionId} in ${changesFile}.`)
    process.exit(1)
  }
  
  if (!Object.keys(objects).includes(newVersionId)) {
    console.log(`Error! Can't find ${newVersionId} in ${objectsFile}.`)
    process.exit(1)
  }
  
  if (!Object.keys(inputObjects).includes(newVersionId)) {
    console.log(`Error! Can't find ${newVersionId} in ${inputObjectsFile}.`)
    process.exit(1)
  }
  
  // write the new files
  await fs.writeFile(previewsFile, JSON.stringify(previews, null, 2))
  await fs.writeFile(changesFile, JSON.stringify(changes, null, 2))
  await fs.writeFile(objectsFile, JSON.stringify(objects, null, 2))
  await fs.writeFile(inputObjectsFile, JSON.stringify(inputObjects, null, 2))
  
  // now create the new version directory in data/graphql
  const srcDir = path.join(graphqlDataDir, oldVersionId)
  const destDir = path.join(graphqlDataDir, newVersionId)
  await mkdirp(destDir)
  
  // copy the files
  const files = await fs.readdir(srcDir)
  for (const file of files) {
    const srcFile = path.join(srcDir, file)
    const destFile = path.join(destDir, file)
    await fs.copyFile(srcFile, destFile)
  }
  
  // check that it worked
  try {
    const destDirResult = await fs.readdir(destDir)
    if (!destDirResult.length) {
      console.log(`Error! The directory created at ${destDir} is empty.`)
      process.exit(1)
    }
  } catch (e) {
    console.log(`Error! A new directory was not successfully created at ${destDir}.`)
    process.exit(1)
  }
  
  // print success message
  console.log(`Done! Copied ${oldVersion} GraphQL files to ${newVersion} files.`)
  