Upgrade and Codemods

Copyfunction getInstalledNextVersion(): string {
  try {
    return require(
      require.resolve('next/package.json', {
        paths: [cwd],
      })
    ).version
  } catch (error) {
    throw new BadInput(
      `Failed to get the installed Next.js version at "${cwd}".\nIf you're using a monorepo, please run this command from the Next.js app directory.`,
      {
        cause: error,
      }
    )
  }
}
 
function getInstalledReactVersion(): string {
  try {
    return require(
      require.resolve('react/package.json', {
        paths: [cwd],
      })
    ).version
  } catch (error) {
    throw new BadInput(
      `Failed to detect the installed React version in "${cwd}".\nIf you're working in a monorepo, please run this command from the Next.js app directory.`,
      {
        cause: error,
      }
    )
  }
}

Copyfunction resolveSemanticRevision(
  revision: string,
  installedVersion: string
): string {
  const installedMajor = major(installedVersion)
  const installedMinor = minor(installedVersion)
 
  switch (revision) {
    case 'patch':
      // ~15.0.0 matches >=15.0.0 <15.1.0
      return `~${installedMajor}.${installedMinor}.0`
    case 'minor':
      // ^15.0.0 matches >=15.0.0 <16.0.0
      return `^${installedMajor}.0.0`
    case 'major':
      return 'latest'
    default:
      return revision
  }
}

Copyasync function loadHighestNPMVersionMatching(query: string) {
  const versionsJSON = execSync(
    `npm --silent view "${query}" --json --field version`,
    { encoding: 'utf-8' }
  )
  const versionOrVersions = JSON.parse(versionsJSON)
  if (versionOrVersions.length < 1) {
    throw new Error(
      `Found no React versions matching "${query}". This is a bug in the upgrade tool.`
    )
  }
  // npm-view returns an array if there are multiple versions matching the query.
  if (Array.isArray(versionOrVersions)) {
    // The last entry will be the latest version published.
    // But we want the highest version.
    versionOrVersions.sort(compareVersions)
    return versionOrVersions[versionOrVersions.length - 1]
  }
  return versionOrVersions
}

Copyfunction isUsingPagesDir(projectPath: string): boolean {
  return (
    fs.existsSync(path.resolve(projectPath, 'pages')) ||
    fs.existsSync(path.resolve(projectPath, 'src/pages'))
  )
}
function isUsingAppDir(projectPath: string): boolean {
  return (
    fs.existsSync(path.resolve(projectPath, 'app')) ||
    fs.existsSync(path.resolve(projectPath, 'src/app'))
  )
}

Copyasync function suggestTurbopack(
  packageJson: any,
  targetNextVersion: string,
  nonInteractive: boolean
): Promise<void> {
  const devScript: string | undefined = packageJson.scripts?.['dev']
  // Turbopack flag was changed from `--turbo` to `--turbopack` in v15.0.1-canary.3
  // PR: https://github.com/vercel/next.js/pull/71657
  // Release: https://github.com/vercel/next.js/releases/tag/v15.0.1-canary.3
  const isAfterTurbopackFlagChange =
    compareVersions(targetNextVersion, '15.0.1-canary.3') >= 0
  const turboPackFlag = isAfterTurbopackFlagChange ? '--turbopack' : '--turbo'

Copy// Turbopack flag was changed from `--turbo` to `--turbopack` in v15.0.1-canary.3
// PR: https://github.com/vercel/next.js/pull/71657
// Release: https://github.com/vercel/next.js/releases/tag/v15.0.1-canary.3
const isAfterTurbopackFlagChange =
  compareVersions(targetNextVersion, '15.0.1-canary.3') >= 0
const turboPackFlag = isAfterTurbopackFlagChange ? '--turbopack' : '--turbo'

Copyexport const TRANSFORMER_INQUIRER_CHOICES = [
  {
    title:
      'Transform the deprecated automatically injected url property on top level pages to using withRouter',
    value: 'url-to-withrouter',
    version: '6.0.0',
  },
  {
    title:
      'Transforms anonymous components into named components to make sure they work with Fast Refresh',
    value: 'name-default-component',
    version: '9.0.0',
  },
  {
    title:
      'Transforms files that do not import `React` to include the import in order for the new React JSX transform',
    value: 'add-missing-react-import',
    version: '10.0.0',
  },
  {
    title:
      'Automatically migrates a Create React App project to Next.js (experimental)',
    value: 'cra-to-next',
    version: '11.0.0',
  },
  {
    title: 'Ensures your <Link> usage is backwards compatible',
    value: 'new-link',
    version: '13.0.0',
  },
  {
    title:
      'Dangerously migrates from `next/legacy/image` to the new `next/image` by adding inline styles and removing unused props (experimental)',
    value: 'next-image-experimental',
    version: '13.0.0',
  },
  {
    title:
      'Safely migrate Next.js 10, 11, 12 applications importing `next/image` to the renamed `next/legacy/image` import in Next.js 13',
    value: 'next-image-to-legacy-image',
    version: '13.0.0',
  },
  {
    title: 'Uninstall `@next/font` and transform imports to `next/font`',
    value: 'built-in-next-font',
    version: '13.2.0',
  },
  {
    title:
      'Migrates certain viewport related metadata from the `metadata` export to a new `viewport` export',
    value: 'metadata-to-viewport-export',
    version: '14.0.0',
  },
  {
    title:
      'Transforms imports from `next/server` to `next/og` for usage of Dynamic OG Image Generation',
    value: 'next-og-import',
    version: '14.0.0',
  },
  {
    title:
      'Install `@vercel/functions` to replace `geo` and `ip` properties on `NextRequest`',
    value: 'next-request-geo-ip',
    version: '15.0.0-canary.153',
  },
  {
    title: 'Transforms usage of Next.js async Request APIs',
    value: 'next-async-request-api',
    version: '15.0.0-canary.171',
  },
  {
    title:
      'Transform App Router Route Segment Config `runtime` value from `experimental-edge` to `edge`',
    value: 'app-dir-runtime-config-experimental-edge',
    version: '15.0.0-canary.179',
  },
  {
    title: 'Updates `next.config.js` to use the new `turbopack` configuration',
    value: 'next-experimental-turbo-to-turbopack',
    version: '15.4.2-canary.21',

Copyif (!options.dry) {
  checkGitStatus(options.force)
}

Copyexport function checkGitStatus(force) {
  let clean = false
  let errorMessage = 'Unable to determine if git directory is clean'
  try {
    clean = isGitClean.sync(process.cwd())
    errorMessage = 'Git directory is not clean'
  } catch (err) {
    if (err && err.stderr && err.stderr.includes('Not a git repository')) {
      clean = true
    }
  }
 
  if (!clean) {
    if (force) {
      console.log(`WARNING: ${errorMessage}. Forcibly continuing.`)
    } else {
      console.log('Thank you for using @next/codemod!')
      console.log(
        yellow(
          '\nBut before we continue, please stash or commit your git changes.'
        )
      )
      console.log(
        '\nYou may use the --force flag to override this safety check.'
      )
      process.exit(1)
    }
  }
}

Copy} catch (err) {
  if (err && err.stderr && err.stderr.includes('Not a git repository')) {
    clean = true
  }
}

Copyfunction expandFilePathsIfNeeded(filesBeforeExpansion) {
  const shouldExpandFiles = filesBeforeExpansion.some((file) =>
    file.includes('*')
  )
  return shouldExpandFiles
    ? globby.sync(filesBeforeExpansion)
    : filesBeforeExpansion
}

Copyconst { dry, print, runInBand, jscodeshift, verbose } = options
 
if (dry) {
  args.push('--dry')
}
if (print) {
  args.push('--print')
}
if (runInBand) {
  args.push('--run-in-band')
}
if (verbose) {
  args.push('--verbose=2')
}
args.push('--parser=tsx')
 
args.push('--ignore-pattern=**/node_modules/**')
args.push('--ignore-pattern=**/.next/**')
 
args.push('--extensions=tsx,ts,jsx,js,mjs')
 

CopyexecaChildProcess.stdout.on('data', (chunk) => {
  lastThreeLineBreaks += chunk.toString('utf-8')
 
  let cutoff = lastThreeLineBreaks.length
 
  // Note: the stdout ends with "\n".
  // "foo\n" + "bar\n" + "baz\n" -> "\nbar\nbaz\n"
  // "\n" + "foo\n" + "bar\n" -> "\nfoo\nbar\n"
 
  for (let i = 0; i < 3; i++) {
    cutoff = lastThreeLineBreaks.lastIndexOf('\n', cutoff) - 1
  }
 
  if (cutoff > 0 && cutoff < lastThreeLineBreaks.length) {
    lastThreeLineBreaks = lastThreeLineBreaks.slice(cutoff + 1)
  }
})

Copyconst targetOkLine = lastThreeLineBreaks.split('\n').at(-3)
 
if (!targetOkLine.endsWith('ok')) {
  throw new Error(
    `Failed to parse the successful transformation count "${targetOkLine}". This is a bug in the codemod tool.`
  )
}
 
const stripped = stripAnsi(targetOkLine)
// "N ok" -> "N"
const parsedNum = parseInt(stripped.split(' ')[0], 10)
const hasChanges = parsedNum > 0

Copyexport default function transform(file: FileInfo, api: API) {
  const transforms = [transformDynamicProps, transformDynamicAPI]
 
  return transforms.reduce<string>((source, transformFn) => {
    const result = transformFn(source, api, file.path)
    if (!result) {
      return source
    }
    return result
  }, file.source)
}

Copyexport { default } from './lib/async-request-api/index'

Copyfunction awaitMemberAccessOfProp(
  propIdName: string,
  path: ASTPath<FunctionScope>,
  j: API['jscodeshift']
) {
  // search the member access of the prop
  const functionBody = findFunctionBody(path)
  const memberAccess = j(functionBody).find(j.MemberExpression, {
    object: {
      type: 'Identifier',
      name: propIdName,
    },
  })
 
  let hasAwaited = false
  // await each member access
  memberAccess.forEach((memberAccessPath) => {
    const member = memberAccessPath.value
 
    const memberProperty = member.property
    const isAccessingMatchedProperty =
      j.Identifier.check(memberProperty) &&
      TARGET_PROP_NAMES.has(memberProperty.name)
 
    if (!isAccessingMatchedProperty) {
      return
    }
 
    if (isParentPromiseAllCallExpression(memberAccessPath, j)) {
      return
    }
 
    // check if it's already awaited
    if (memberAccessPath.parentPath?.value.type === 'AwaitExpression') {
      return
    }
 
    const parentScopeOfMemberAccess = findClosetParentFunctionScope(
      memberAccessPath,
      j
    )
 
    // When the parent scope is sync, and it's also not the function itself, which means it's not able to convert to async.
    if (
      parentScopeOfMemberAccess &&
      !parentScopeOfMemberAccess.value?.async &&
      parentScopeOfMemberAccess.node !== path.node
    ) {
      // If it's not able to convert, add a comment to the prop access to warn the user
      // e.g. the parent scope is sync, await keyword can't be applied
      const comment = ` ${NEXT_CODEMOD_ERROR_PREFIX} '${propIdName}.${memberProperty.name}' is accessed without awaiting.`
      insertCommentOnce(member, j, comment)
      return
    }
 
    const awaitedExpr = j.awaitExpression(member)
 
    const awaitMemberAccess = wrapParentheseIfNeeded(true, j, awaitedExpr)
    memberAccessPath.replace(awaitMemberAccess)
    hasAwaited = true
  })

Copyconst parentScopeOfMemberAccess = findClosetParentFunctionScope(
  memberAccessPath,
  j
)
 
// When the parent scope is sync, and it's also not the function itself, which means it's not able to convert to async.
if (
  parentScopeOfMemberAccess &&
  !parentScopeOfMemberAccess.value?.async &&
  parentScopeOfMemberAccess.node !== path.node
) {
  // If it's not able to convert, add a comment to the prop access to warn the user
  // e.g. the parent scope is sync, await keyword can't be applied
  const comment = ` ${NEXT_CODEMOD_ERROR_PREFIX} '${propIdName}.${memberProperty.name}' is accessed without awaiting.`
  insertCommentOnce(member, j, comment)
  return
}

Copyfunction applyUseAndRenameAccessedProp(
  propIdName: string,
  path: ASTPath<FunctionScope>,
  j: API['jscodeshift']
) {
  // search the member access of the prop, and rename the member access to the member value
  // e.g.
  // props.params => params
  // props.params.foo => params.foo
  // props.searchParams.search => searchParams.search
  let modified = false
  const functionBody = findFunctionBody(path)
  const memberAccess = j(functionBody).find(j.MemberExpression, {
    object: {
      type: 'Identifier',
      name: propIdName,
    },
  })
 
  const accessedNames: string[] = []
  // rename each member access
  memberAccess.forEach((memberAccessPath) => {
    // If the member access expression is first argument of `use()`, we skip
    if (isParentUseCallExpression(memberAccessPath, j)) {
      return
    }
 
    const member = memberAccessPath.value
    const memberProperty = member.property
    if (j.Identifier.check(memberProperty)) {
      accessedNames.push(memberProperty.name)
    } else if (j.MemberExpression.check(memberProperty)) {
      let currentMember = memberProperty
      if (j.Identifier.check(currentMember.object)) {
        accessedNames.push(currentMember.object.name)
      }
    }
    memberAccessPath.replace(memberProperty)
  })
 
  // If there's any renamed member access, need to call `use()` onto member access
  // e.g. ['params'] => insert `const params = use(props.params)`
  if (accessedNames.length > 0) {
    const accessedPropId = j.identifier(propIdName)
    const accessedProp = j.memberExpression(
      accessedPropId,
      j.identifier(accessedNames[0])
    )
 
    const useCall = j.callExpression(j.identifier('use'), [accessedProp])
    const useDeclaration = j.variableDeclaration('const', [
      j.variableDeclarator(j.identifier(accessedNames[0]), useCall),
    ])
 
    if (functionBody) {
      functionBody.unshift(useDeclaration)
    }
 
    modified = true
  }
  return modified
}