Upload folder using huggingface_hub

1e92f2d verified about 1 year ago

15 kB

import type {
  API,
  ASTPath,
  FileInfo,
  FunctionDeclaration,
  Collection,
  Node,
  ImportSpecifier,
  Identifier,
} from 'jscodeshift'
import { createParserFromPath } from '../lib/parser'

const GEO = 'geo'
const IP = 'ip'
const GEOLOCATION = 'geolocation'
const IP_ADDRESS = 'ipAddress'
const GEO_TYPE = 'Geo'

export default function (file: FileInfo, _api: API) {
  const j = createParserFromPath(file.path)
  const root = j(file.source)

  if (!root.length) {
    return file.source
  }

  const nextReqType = root
    .find(j.FunctionDeclaration)
    .find(j.Identifier, (id) => {
      if (id.typeAnnotation?.type !== 'TSTypeAnnotation') {
        return false
      }

      const typeAnn = id.typeAnnotation.typeAnnotation
      return (
        typeAnn.type === 'TSTypeReference' &&
        typeAnn.typeName.type === 'Identifier' &&
        typeAnn.typeName.name === 'NextRequest'
      )
    })

  const vercelFuncImports = root.find(j.ImportDeclaration, {
    source: {
      value: '@vercel/functions',
    },
  })

  const vercelFuncImportSpecifiers = vercelFuncImports
    .find(j.ImportSpecifier)
    .nodes()

  const vercelFuncImportNames = new Set(
    vercelFuncImportSpecifiers.map((node) => node.imported.name)
  )

  const hasGeolocation = vercelFuncImportNames.has(GEOLOCATION)
  const hasIpAddress = vercelFuncImportNames.has(IP_ADDRESS)
  const hasGeoType = vercelFuncImportNames.has(GEO_TYPE)

  let identifierNames = new Set<string>()

  // if all identifiers are already imported, we don't need to create
  // a unique identifier for them, therefore we don't look for all
  // identifier names in the file
  if (!hasGeolocation || !hasIpAddress || !hasGeoType) {
    const allIdentifiers = root.find(j.Identifier).nodes()
    identifierNames = new Set(allIdentifiers.map((node) => node.name))
  }

  let geoIdentifier = hasGeolocation
    ? getExistingIdentifier(vercelFuncImportSpecifiers, GEOLOCATION)
    : getUniqueIdentifier(identifierNames, GEOLOCATION)

  let ipIdentifier = hasIpAddress
    ? getExistingIdentifier(vercelFuncImportSpecifiers, IP_ADDRESS)
    : getUniqueIdentifier(identifierNames, IP_ADDRESS)

  let geoTypeIdentifier = hasGeoType
    ? getExistingIdentifier(vercelFuncImportSpecifiers, GEO_TYPE)
    : getUniqueIdentifier(identifierNames, GEO_TYPE)

  let { needImportGeolocation, needImportIpAddress } = replaceGeoIpValues(
    j,
    nextReqType,
    geoIdentifier,
    ipIdentifier
  )
  let { needImportGeoType, hasChangedIpType } = replaceGeoIpTypes(
    j,
    root,
    geoTypeIdentifier
  )

  let needChanges =
    needImportGeolocation ||
    needImportIpAddress ||
    needImportGeoType ||
    hasChangedIpType

  if (!needChanges) {
    return file.source
  }

  // Even if there was a change above, if there's an existing import,
  // we don't need to import them again.
  needImportGeolocation = !hasGeolocation && needImportGeolocation
  needImportIpAddress = !hasIpAddress && needImportIpAddress
  needImportGeoType = !hasGeoType && needImportGeoType

  insertImportDeclarations(
    j,
    root,
    vercelFuncImports,
    needImportGeolocation,
    needImportIpAddress,
    needImportGeoType,
    geoIdentifier,
    ipIdentifier,
    geoTypeIdentifier
  )
  return root.toSource()
}

/**
 * Returns an existing identifier from the Vercel functions import declaration.
 */
function getExistingIdentifier(
  vercelFuncImportSpecifiers: ImportSpecifier[],
  identifier: string
) {
  const existingIdentifier = vercelFuncImportSpecifiers.find(
    (node) => node.imported.name === identifier
  )

  return (
    existingIdentifier?.local?.name ||
    existingIdentifier.imported.name ||
    identifier
  )
}

/**
 * Returns a unique identifier by adding a suffix to the original identifier
 * if it already exists in the set.
 */
function getUniqueIdentifier(identifierNames: Set<string>, identifier: string) {
  let suffix = 1
  let uniqueIdentifier = identifier
  while (identifierNames.has(uniqueIdentifier)) {
    uniqueIdentifier = `${identifier}${suffix}`
    suffix++
  }
  return uniqueIdentifier
}

/**
 * Replaces accessors `geo` and `ip` of NextRequest with corresponding
 * function calls from `@vercel/functions`.
 *
 * Creates new variable declarations for destructuring assignments.
 */
function replaceGeoIpValues(
  j: API['jscodeshift'],
  nextReqType: Collection<Identifier>,
  geoIdentifier: string,
  ipIdentifier: string
): {
  needImportGeolocation: boolean
  needImportIpAddress: boolean
} {
  let needImportGeolocation = false
  let needImportIpAddress = false

  for (const nextReqPath of nextReqType.paths()) {
    const fnPath: ASTPath<FunctionDeclaration> =
      nextReqPath.parentPath.parentPath
    const fn = j(fnPath)
    const blockStatement = fn.find(j.BlockStatement)
    const varDeclarators = fn.find(j.VariableDeclarator)

    // req.geo, req.ip
    const geoAccesses = blockStatement.find(
      j.MemberExpression,
      (me) =>
        me.object.type === 'Identifier' &&
        me.object.name === nextReqPath.node.name &&
        me.property.type === 'Identifier' &&
        me.property.name === GEO
    )
    const ipAccesses = blockStatement.find(
      j.MemberExpression,
      (me) =>
        me.object.type === 'Identifier' &&
        me.object.name === nextReqPath.node.name &&
        me.property.type === 'Identifier' &&
        me.property.name === IP
    )

    // var { geo, ip } = req
    const geoDestructuring = varDeclarators.filter(
      (path) =>
        path.node.id.type === 'ObjectPattern' &&
        path.node.id.properties.some(
          (prop) =>
            prop.type === 'ObjectProperty' &&
            prop.key.type === 'Identifier' &&
            prop.key.name === GEO
        )
    )
    const ipDestructuring = varDeclarators.filter(
      (path) =>
        path.node.id.type === 'ObjectPattern' &&
        path.node.id.properties.some(
          (prop) =>
            prop.type === 'ObjectProperty' &&
            prop.key.type === 'Identifier' &&
            prop.key.name === IP
        )
    )

    // geolocation(req), ipAddress(req)
    const geoCall = j.callExpression(j.identifier(geoIdentifier), [
      {
        ...nextReqPath.node,
        typeAnnotation: null,
      },
    ])
    const ipCall = j.callExpression(j.identifier(ipIdentifier), [
      {
        ...nextReqPath.node,
        typeAnnotation: null,
      },
    ])

    geoAccesses.replaceWith(geoCall)
    ipAccesses.replaceWith(ipCall)

    /**
     * For each destructuring assignment, we create a new variable
     * declaration and insert it after the current block statement.
     *
     * Before:
     *
     * ```
     * const { buildId, geo, ip } = req;
     * ```
     *
     * After:
     *
     * ```
     * const { buildId } = req;
     * const geo = geolocation(req);
     * const ip = ipAddress(req);
     * ```
     */
    geoDestructuring.forEach((path) => {
      if (path.node.id.type === 'ObjectPattern') {
        const properties = path.node.id.properties
        const geoProperty = properties.find(
          (prop) =>
            prop.type === 'ObjectProperty' &&
            prop.key.type === 'Identifier' &&
            prop.key.name === GEO
        )

        const otherProperties = properties.filter(
          (prop) => prop !== geoProperty
        )

        const geoDeclaration = j.variableDeclaration('const', [
          j.variableDeclarator(
            j.identifier(
              // Use alias from destructuring (if present) to retain references:
              // const { geo: geoAlias } = req; -> const geoAlias = geolocation(req);
              // This prevents errors from undeclared variables.
              geoProperty.type === 'ObjectProperty' &&
                geoProperty.value.type === 'Identifier'
                ? geoProperty.value.name
                : GEO
            ),
            geoCall
          ),
        ])

        path.node.id.properties = otherProperties
        path.parent.insertAfter(geoDeclaration)
      }
    })
    ipDestructuring.forEach((path) => {
      if (path.node.id.type === 'ObjectPattern') {
        const properties = path.node.id.properties
        const ipProperty = properties.find(
          (prop) =>
            prop.type === 'ObjectProperty' &&
            prop.key.type === 'Identifier' &&
            prop.key.name === IP
        )
        const otherProperties = properties.filter((prop) => prop !== ipProperty)

        const ipDeclaration = j.variableDeclaration('const', [
          j.variableDeclarator(
            j.identifier(
              // Use alias from destructuring (if present) to retain references:
              // const { ip: ipAlias } = req; -> const ipAlias = ipAddress(req);
              // This prevents errors from undeclared variables.
              ipProperty.type === 'ObjectProperty' &&
                ipProperty.value.type === 'Identifier'
                ? ipProperty.value.name
                : IP
            ),
            ipCall
          ),
        ])

        path.node.id.properties = otherProperties
        path.parent.insertAfter(ipDeclaration)
      }
    })

    needImportGeolocation =
      needImportGeolocation ||
      geoAccesses.length > 0 ||
      geoDestructuring.length > 0
    needImportIpAddress =
      needImportIpAddress || ipAccesses.length > 0 || ipDestructuring.length > 0
  }

  return {
    needImportGeolocation,
    needImportIpAddress,
  }
}

/**
 * Replaces the types of `NextRequest["geo"]` and `NextRequest["ip"]` with
 * corresponding types from `@vercel/functions`.
 */
function replaceGeoIpTypes(
  j: API['jscodeshift'],
  root: Collection<Node>,
  geoTypeIdentifier: string
): {
  needImportGeoType: boolean
  hasChangedIpType: boolean
} {
  let needImportGeoType = false
  let hasChangedIpType = false

  // get the type of NextRequest that has accessed for ip and geo
  // NextRequest['geo'], NextRequest['ip']
  const nextReqGeoType = root.find(
    j.TSIndexedAccessType,
    (tsIndexedAccessType) => {
      return (
        tsIndexedAccessType.objectType.type === 'TSTypeReference' &&
        tsIndexedAccessType.objectType.typeName.type === 'Identifier' &&
        tsIndexedAccessType.objectType.typeName.name === 'NextRequest' &&
        tsIndexedAccessType.indexType.type === 'TSLiteralType' &&
        tsIndexedAccessType.indexType.literal.type === 'StringLiteral' &&
        tsIndexedAccessType.indexType.literal.value === GEO
      )
    }
  )
  const nextReqIpType = root.find(
    j.TSIndexedAccessType,
    (tsIndexedAccessType) => {
      return (
        tsIndexedAccessType.objectType.type === 'TSTypeReference' &&
        tsIndexedAccessType.objectType.typeName.type === 'Identifier' &&
        tsIndexedAccessType.objectType.typeName.name === 'NextRequest' &&
        tsIndexedAccessType.indexType.type === 'TSLiteralType' &&
        tsIndexedAccessType.indexType.literal.type === 'StringLiteral' &&
        tsIndexedAccessType.indexType.literal.value === IP
      )
    }
  )

  if (nextReqGeoType.length > 0) {
    needImportGeoType = true

    // replace with type Geo
    nextReqGeoType.replaceWith(j.identifier(geoTypeIdentifier))
  }

  if (nextReqIpType.length > 0) {
    hasChangedIpType = true

    // replace with type string | undefined
    nextReqIpType.replaceWith(
      j.tsUnionType([j.tsStringKeyword(), j.tsUndefinedKeyword()])
    )
  }

  return {
    needImportGeoType,
    hasChangedIpType,
  }
}

/**
 * Inserts import declarations from `"@vercel/functions"`.
 *
 * For the `Geo` type that needs to be imported to replace `NextRequest["geo"]`,
 * if it is the only import needed, we import it as a type.
 *
 * ```ts
 * import type { Geo } from "@vercel/functions";
 * ```
 *
 * Otherwise, we import it as an inline type import.
 *
 * ```ts
 * import { type Geo, ... } from "@vercel/functions";
 * ```
 */
function insertImportDeclarations(
  j: API['jscodeshift'],
  root: Collection<Node>,
  vercelFuncImports: Collection<Node>,
  needImportGeolocation: boolean,
  needImportIpAddress: boolean,
  needImportGeoType: boolean,
  geoIdentifier: string,
  ipIdentifier: string,
  geoTypeIdentifier: string
): void {
  // No need inserting import.
  if (!needImportGeolocation && !needImportIpAddress && !needImportGeoType) {
    return
  }

  // As we run this only when `NextRequest` is imported, there should be
  // a "next/server" import.
  const firstNextServerImport = root
    .find(j.ImportDeclaration, { source: { value: 'next/server' } })
    .at(0)
  const firstVercelFuncImport = vercelFuncImports.at(0)

  const hasVercelFuncImport = firstVercelFuncImport.length > 0

  // If there's no "@vercel/functions" import, and we only need to import
  // `Geo` type, we create a type import to avoid side effect with
  // `verbatimModuleSyntax`.
  // x-ref: https://typescript-eslint.io/rules/no-import-type-side-effects
  if (
    !hasVercelFuncImport &&
    !needImportGeolocation &&
    !needImportIpAddress &&
    needImportGeoType
  ) {
    const geoTypeImportDeclaration = j.importDeclaration(
      [
        needImportGeoType
          ? j.importSpecifier(
              j.identifier(GEO_TYPE),
              j.identifier(geoTypeIdentifier)
            )
          : null,
      ].filter(Boolean),
      j.literal('@vercel/functions'),
      // import type { Geo } ...
      'type'
    )
    firstNextServerImport.insertAfter(geoTypeImportDeclaration)
    return
  }

  const importDeclaration = j.importDeclaration(
    [
      // If there was a duplicate identifier, we add an
      // incremental number suffix to it and we use alias:
      // `import { geolocation as geolocation1 } from ...`
      needImportGeolocation
        ? j.importSpecifier(
            j.identifier(GEOLOCATION),
            j.identifier(geoIdentifier)
          )
        : null,
      needImportIpAddress
        ? j.importSpecifier(
            j.identifier(IP_ADDRESS),
            j.identifier(ipIdentifier)
          )
        : null,
      needImportGeoType
        ? j.importSpecifier(
            j.identifier(GEO_TYPE),
            j.identifier(geoTypeIdentifier)
          )
        : null,
    ].filter(Boolean),
    j.literal('@vercel/functions')
  )

  if (hasVercelFuncImport) {
    firstVercelFuncImport
      .get()
      .node.specifiers.push(...importDeclaration.specifiers)

    if (needImportGeoType) {
      const targetGeo = firstVercelFuncImport
        .get()
        .node.specifiers.find(
          (specifier) => specifier.imported.name === GEO_TYPE
        )
      if (targetGeo) {
        targetGeo.importKind = 'type'
      }
    }
  } else {
    if (needImportGeoType) {
      const targetGeo = importDeclaration.specifiers.find(
        (specifier) =>
          specifier.type === 'ImportSpecifier' &&
          specifier.imported.name === GEO_TYPE
      )
      if (targetGeo) {
        // @ts-expect-error -- Missing types in jscodeshift.
        targetGeo.importKind = 'type'
      }
    }
    firstNextServerImport.insertAfter(importDeclaration)
  }
}

	import type {
	API,
	ASTPath,
	FileInfo,
	FunctionDeclaration,
	Collection,
	Node,
	ImportSpecifier,
	Identifier,
	} from 'jscodeshift'
	import { createParserFromPath } from '../lib/parser'

	const GEO = 'geo'
	const IP = 'ip'
	const GEOLOCATION = 'geolocation'
	const IP_ADDRESS = 'ipAddress'
	const GEO_TYPE = 'Geo'

	export default function (file: FileInfo, _api: API) {
	const j = createParserFromPath(file.path)
	const root = j(file.source)

	if (!root.length) {
	return file.source
	}

	const nextReqType = root
	.find(j.FunctionDeclaration)
	.find(j.Identifier, (id) => {
	if (id.typeAnnotation?.type !== 'TSTypeAnnotation') {
	return false
	}

	const typeAnn = id.typeAnnotation.typeAnnotation
	return (
	typeAnn.type === 'TSTypeReference' &&
	typeAnn.typeName.type === 'Identifier' &&
	typeAnn.typeName.name === 'NextRequest'
	)
	})

	const vercelFuncImports = root.find(j.ImportDeclaration, {
	source: {
	value: '@vercel/functions',
	},
	})

	const vercelFuncImportSpecifiers = vercelFuncImports
	.find(j.ImportSpecifier)
	.nodes()

	const vercelFuncImportNames = new Set(
	vercelFuncImportSpecifiers.map((node) => node.imported.name)
	)

	const hasGeolocation = vercelFuncImportNames.has(GEOLOCATION)
	const hasIpAddress = vercelFuncImportNames.has(IP_ADDRESS)
	const hasGeoType = vercelFuncImportNames.has(GEO_TYPE)

	let identifierNames = new Set<string>()

	// if all identifiers are already imported, we don't need to create
	// a unique identifier for them, therefore we don't look for all
	// identifier names in the file
	if (!hasGeolocation \|\| !hasIpAddress \|\| !hasGeoType) {
	const allIdentifiers = root.find(j.Identifier).nodes()
	identifierNames = new Set(allIdentifiers.map((node) => node.name))
	}

	let geoIdentifier = hasGeolocation
	? getExistingIdentifier(vercelFuncImportSpecifiers, GEOLOCATION)
	: getUniqueIdentifier(identifierNames, GEOLOCATION)

	let ipIdentifier = hasIpAddress
	? getExistingIdentifier(vercelFuncImportSpecifiers, IP_ADDRESS)
	: getUniqueIdentifier(identifierNames, IP_ADDRESS)

	let geoTypeIdentifier = hasGeoType
	? getExistingIdentifier(vercelFuncImportSpecifiers, GEO_TYPE)
	: getUniqueIdentifier(identifierNames, GEO_TYPE)

	let { needImportGeolocation, needImportIpAddress } = replaceGeoIpValues(
	j,
	nextReqType,
	geoIdentifier,
	ipIdentifier
	)
	let { needImportGeoType, hasChangedIpType } = replaceGeoIpTypes(
	j,
	root,
	geoTypeIdentifier
	)

	let needChanges =
	needImportGeolocation \|\|
	needImportIpAddress \|\|
	needImportGeoType \|\|
	hasChangedIpType

	if (!needChanges) {
	return file.source
	}

	// Even if there was a change above, if there's an existing import,
	// we don't need to import them again.
	needImportGeolocation = !hasGeolocation && needImportGeolocation
	needImportIpAddress = !hasIpAddress && needImportIpAddress
	needImportGeoType = !hasGeoType && needImportGeoType

	insertImportDeclarations(
	j,
	root,
	vercelFuncImports,
	needImportGeolocation,
	needImportIpAddress,
	needImportGeoType,
	geoIdentifier,
	ipIdentifier,
	geoTypeIdentifier
	)
	return root.toSource()
	}

	/**
	* Returns an existing identifier from the Vercel functions import declaration.
	*/
	function getExistingIdentifier(
	vercelFuncImportSpecifiers: ImportSpecifier[],
	identifier: string
	) {
	const existingIdentifier = vercelFuncImportSpecifiers.find(
	(node) => node.imported.name === identifier
	)

	return (
	existingIdentifier?.local?.name \|\|
	existingIdentifier.imported.name \|\|
	identifier
	)
	}

	/**
	* Returns a unique identifier by adding a suffix to the original identifier
	* if it already exists in the set.
	*/
	function getUniqueIdentifier(identifierNames: Set<string>, identifier: string) {
	let suffix = 1
	let uniqueIdentifier = identifier
	while (identifierNames.has(uniqueIdentifier)) {
	uniqueIdentifier = `${identifier}${suffix}`
	suffix++
	}
	return uniqueIdentifier
	}

	/**
	* Replaces accessors `geo` and `ip` of NextRequest with corresponding
	* function calls from `@vercel/functions`.
	*
	* Creates new variable declarations for destructuring assignments.
	*/
	function replaceGeoIpValues(
	j: API['jscodeshift'],
	nextReqType: Collection<Identifier>,
	geoIdentifier: string,
	ipIdentifier: string
	): {
	needImportGeolocation: boolean
	needImportIpAddress: boolean
	} {
	let needImportGeolocation = false
	let needImportIpAddress = false

	for (const nextReqPath of nextReqType.paths()) {
	const fnPath: ASTPath<FunctionDeclaration> =
	nextReqPath.parentPath.parentPath
	const fn = j(fnPath)
	const blockStatement = fn.find(j.BlockStatement)
	const varDeclarators = fn.find(j.VariableDeclarator)

	// req.geo, req.ip
	const geoAccesses = blockStatement.find(
	j.MemberExpression,
	(me) =>
	me.object.type === 'Identifier' &&
	me.object.name === nextReqPath.node.name &&
	me.property.type === 'Identifier' &&
	me.property.name === GEO
	)
	const ipAccesses = blockStatement.find(
	j.MemberExpression,
	(me) =>
	me.object.type === 'Identifier' &&
	me.object.name === nextReqPath.node.name &&
	me.property.type === 'Identifier' &&
	me.property.name === IP
	)

	// var { geo, ip } = req
	const geoDestructuring = varDeclarators.filter(
	(path) =>
	path.node.id.type === 'ObjectPattern' &&
	path.node.id.properties.some(
	(prop) =>
	prop.type === 'ObjectProperty' &&
	prop.key.type === 'Identifier' &&
	prop.key.name === GEO
	)
	)
	const ipDestructuring = varDeclarators.filter(
	(path) =>
	path.node.id.type === 'ObjectPattern' &&
	path.node.id.properties.some(
	(prop) =>
	prop.type === 'ObjectProperty' &&
	prop.key.type === 'Identifier' &&
	prop.key.name === IP
	)
	)

	// geolocation(req), ipAddress(req)
	const geoCall = j.callExpression(j.identifier(geoIdentifier), [
	{
	...nextReqPath.node,
	typeAnnotation: null,
	},
	])
	const ipCall = j.callExpression(j.identifier(ipIdentifier), [
	{
	...nextReqPath.node,
	typeAnnotation: null,
	},
	])

	geoAccesses.replaceWith(geoCall)
	ipAccesses.replaceWith(ipCall)

	/**
	* For each destructuring assignment, we create a new variable
	* declaration and insert it after the current block statement.
	*
	* Before:
	*
	* ```
	* const { buildId, geo, ip } = req;
	* ```
	*
	* After:
	*
	* ```
	* const { buildId } = req;
	* const geo = geolocation(req);
	* const ip = ipAddress(req);
	* ```
	*/
	geoDestructuring.forEach((path) => {
	if (path.node.id.type === 'ObjectPattern') {
	const properties = path.node.id.properties
	const geoProperty = properties.find(
	(prop) =>
	prop.type === 'ObjectProperty' &&
	prop.key.type === 'Identifier' &&
	prop.key.name === GEO
	)

	const otherProperties = properties.filter(
	(prop) => prop !== geoProperty
	)

	const geoDeclaration = j.variableDeclaration('const', [
	j.variableDeclarator(
	j.identifier(
	// Use alias from destructuring (if present) to retain references:
	// const { geo: geoAlias } = req; -> const geoAlias = geolocation(req);
	// This prevents errors from undeclared variables.
	geoProperty.type === 'ObjectProperty' &&
	geoProperty.value.type === 'Identifier'
	? geoProperty.value.name
	: GEO
	),
	geoCall
	),
	])

	path.node.id.properties = otherProperties
	path.parent.insertAfter(geoDeclaration)
	}
	})
	ipDestructuring.forEach((path) => {
	if (path.node.id.type === 'ObjectPattern') {
	const properties = path.node.id.properties
	const ipProperty = properties.find(
	(prop) =>
	prop.type === 'ObjectProperty' &&
	prop.key.type === 'Identifier' &&
	prop.key.name === IP
	)
	const otherProperties = properties.filter((prop) => prop !== ipProperty)

	const ipDeclaration = j.variableDeclaration('const', [
	j.variableDeclarator(
	j.identifier(
	// Use alias from destructuring (if present) to retain references:
	// const { ip: ipAlias } = req; -> const ipAlias = ipAddress(req);
	// This prevents errors from undeclared variables.
	ipProperty.type === 'ObjectProperty' &&
	ipProperty.value.type === 'Identifier'
	? ipProperty.value.name
	: IP
	),
	ipCall
	),
	])

	path.node.id.properties = otherProperties
	path.parent.insertAfter(ipDeclaration)
	}
	})

	needImportGeolocation =
	needImportGeolocation \|\|
	geoAccesses.length > 0 \|\|
	geoDestructuring.length > 0
	needImportIpAddress =
	needImportIpAddress \|\| ipAccesses.length > 0 \|\| ipDestructuring.length > 0
	}

	return {
	needImportGeolocation,
	needImportIpAddress,
	}
	}

	/**
	* Replaces the types of `NextRequest["geo"]` and `NextRequest["ip"]` with
	* corresponding types from `@vercel/functions`.
	*/
	function replaceGeoIpTypes(
	j: API['jscodeshift'],
	root: Collection<Node>,
	geoTypeIdentifier: string
	): {
	needImportGeoType: boolean
	hasChangedIpType: boolean
	} {
	let needImportGeoType = false
	let hasChangedIpType = false

	// get the type of NextRequest that has accessed for ip and geo
	// NextRequest['geo'], NextRequest['ip']
	const nextReqGeoType = root.find(
	j.TSIndexedAccessType,
	(tsIndexedAccessType) => {
	return (
	tsIndexedAccessType.objectType.type === 'TSTypeReference' &&
	tsIndexedAccessType.objectType.typeName.type === 'Identifier' &&
	tsIndexedAccessType.objectType.typeName.name === 'NextRequest' &&
	tsIndexedAccessType.indexType.type === 'TSLiteralType' &&
	tsIndexedAccessType.indexType.literal.type === 'StringLiteral' &&
	tsIndexedAccessType.indexType.literal.value === GEO
	)
	}
	)
	const nextReqIpType = root.find(
	j.TSIndexedAccessType,
	(tsIndexedAccessType) => {
	return (
	tsIndexedAccessType.objectType.type === 'TSTypeReference' &&
	tsIndexedAccessType.objectType.typeName.type === 'Identifier' &&
	tsIndexedAccessType.objectType.typeName.name === 'NextRequest' &&
	tsIndexedAccessType.indexType.type === 'TSLiteralType' &&
	tsIndexedAccessType.indexType.literal.type === 'StringLiteral' &&
	tsIndexedAccessType.indexType.literal.value === IP
	)
	}
	)

	if (nextReqGeoType.length > 0) {
	needImportGeoType = true

	// replace with type Geo
	nextReqGeoType.replaceWith(j.identifier(geoTypeIdentifier))
	}

	if (nextReqIpType.length > 0) {
	hasChangedIpType = true

	// replace with type string \| undefined
	nextReqIpType.replaceWith(
	j.tsUnionType([j.tsStringKeyword(), j.tsUndefinedKeyword()])
	)
	}

	return {
	needImportGeoType,
	hasChangedIpType,
	}
	}

	/**
	* Inserts import declarations from `"@vercel/functions"`.
	*
	* For the `Geo` type that needs to be imported to replace `NextRequest["geo"]`,
	* if it is the only import needed, we import it as a type.
	*
	* ```ts
	* import type { Geo } from "@vercel/functions";
	* ```
	*
	* Otherwise, we import it as an inline type import.
	*
	* ```ts
	* import { type Geo, ... } from "@vercel/functions";
	* ```
	*/
	function insertImportDeclarations(
	j: API['jscodeshift'],
	root: Collection<Node>,
	vercelFuncImports: Collection<Node>,
	needImportGeolocation: boolean,
	needImportIpAddress: boolean,
	needImportGeoType: boolean,
	geoIdentifier: string,
	ipIdentifier: string,
	geoTypeIdentifier: string
	): void {
	// No need inserting import.
	if (!needImportGeolocation && !needImportIpAddress && !needImportGeoType) {
	return
	}

	// As we run this only when `NextRequest` is imported, there should be
	// a "next/server" import.
	const firstNextServerImport = root
	.find(j.ImportDeclaration, { source: { value: 'next/server' } })
	.at(0)
	const firstVercelFuncImport = vercelFuncImports.at(0)

	const hasVercelFuncImport = firstVercelFuncImport.length > 0

	// If there's no "@vercel/functions" import, and we only need to import
	// `Geo` type, we create a type import to avoid side effect with
	// `verbatimModuleSyntax`.
	// x-ref: https://typescript-eslint.io/rules/no-import-type-side-effects
	if (
	!hasVercelFuncImport &&
	!needImportGeolocation &&
	!needImportIpAddress &&
	needImportGeoType
	) {
	const geoTypeImportDeclaration = j.importDeclaration(
	[
	needImportGeoType
	? j.importSpecifier(
	j.identifier(GEO_TYPE),
	j.identifier(geoTypeIdentifier)
	)
	: null,
	].filter(Boolean),
	j.literal('@vercel/functions'),
	// import type { Geo } ...
	'type'
	)
	firstNextServerImport.insertAfter(geoTypeImportDeclaration)
	return
	}

	const importDeclaration = j.importDeclaration(
	[
	// If there was a duplicate identifier, we add an
	// incremental number suffix to it and we use alias:
	// `import { geolocation as geolocation1 } from ...`
	needImportGeolocation
	? j.importSpecifier(
	j.identifier(GEOLOCATION),
	j.identifier(geoIdentifier)
	)
	: null,
	needImportIpAddress
	? j.importSpecifier(
	j.identifier(IP_ADDRESS),
	j.identifier(ipIdentifier)
	)
	: null,
	needImportGeoType
	? j.importSpecifier(
	j.identifier(GEO_TYPE),
	j.identifier(geoTypeIdentifier)
	)
	: null,
	].filter(Boolean),
	j.literal('@vercel/functions')
	)

	if (hasVercelFuncImport) {
	firstVercelFuncImport
	.get()
	.node.specifiers.push(...importDeclaration.specifiers)

	if (needImportGeoType) {
	const targetGeo = firstVercelFuncImport
	.get()
	.node.specifiers.find(
	(specifier) => specifier.imported.name === GEO_TYPE
	)
	if (targetGeo) {
	targetGeo.importKind = 'type'
	}
	}
	} else {
	if (needImportGeoType) {
	const targetGeo = importDeclaration.specifiers.find(
	(specifier) =>
	specifier.type === 'ImportSpecifier' &&
	specifier.imported.name === GEO_TYPE
	)
	if (targetGeo) {
	// @ts-expect-error -- Missing types in jscodeshift.
	targetGeo.importKind = 'type'
	}
	}
	firstNextServerImport.insertAfter(importDeclaration)
	}
	}