@clerk/upgrade 2.0.0-snapshot.v20251204143242 → 2.0.0-snapshot.v20251208202852

package/dist/codemods/transform-themes-to-ui-themes.cjs

@@ -0,0 +1,65 @@
+const LEGACY_PACKAGE = '@clerk/themes';
+const TARGET_PACKAGE = '@clerk/ui/themes';
+const isStringLiteral = (j, node) => j.Literal.check(node) && typeof node.value === 'string' || j.StringLiteral && j.StringLiteral.check(node);
+const getReplacement = value => {
+  if (typeof value !== 'string' || !value.startsWith(LEGACY_PACKAGE)) {
+    return null;
+  }
+  return `${TARGET_PACKAGE}${value.slice(LEGACY_PACKAGE.length)}`;
+};
+module.exports = function transformThemesToUiThemes({
+  source
+}, {
+  jscodeshift: j
+}) {
+  const root = j(source);
+  let dirty = false;
+  const replaceSourceLiteral = literal => {
+    if (!isStringLiteral(j, literal)) {
+      return;
+    }
+    const nextValue = getReplacement(literal.value);
+    if (nextValue && nextValue !== literal.value) {
+      literal.value = nextValue;
+      dirty = true;
+    }
+  };
+  root.find(j.ImportDeclaration).forEach(path => {
+    replaceSourceLiteral(path.node.source);
+  });
+  root.find(j.ExportNamedDeclaration).forEach(path => {
+    if (path.node.source) {
+      replaceSourceLiteral(path.node.source);
+    }
+  });
+  root.find(j.ExportAllDeclaration).forEach(path => {
+    replaceSourceLiteral(path.node.source);
+  });
+  root.find(j.CallExpression, {
+    callee: {
+      name: 'require'
+    }
+  }).forEach(path => {
+    const [arg] = path.node.arguments || [];
+    if (arg) {
+      replaceSourceLiteral(arg);
+    }
+  });
+  if (j.ImportExpression) {
+    root.find(j.ImportExpression).forEach(path => {
+      replaceSourceLiteral(path.node.source);
+    });
+  }
+  root.find(j.CallExpression, {
+    callee: {
+      type: 'Import'
+    }
+  }).forEach(path => {
+    const [arg] = path.node.arguments || [];
+    if (arg) {
+      replaceSourceLiteral(arg);
+    }
+  });
+  return dirty ? root.toSource() : undefined;
+};
+module.exports.parser = 'tsx';

package/dist/config.js

@@ -0,0 +1,122 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import matter from 'gray-matter';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const VERSIONS_DIR = path.join(__dirname, 'versions');
+export async function loadConfig(sdk, currentVersion) {
+  const versionDirs = fs.readdirSync(VERSIONS_DIR, {
+    withFileTypes: true
+  }).filter(d => d.isDirectory()).map(d => d.name);
+  let applicableConfig = null;
+  for (const versionDir of versionDirs) {
+    const configPath = path.join(VERSIONS_DIR, versionDir, 'index.js');
+    if (!fs.existsSync(configPath)) {
+      continue;
+    }
+    const moduleUrl = pathToFileURL(configPath).href;
+    const mod = await import(moduleUrl);
+    const config = mod.default ?? mod;
+    if (!config.sdkVersions) {
+      continue;
+    }
+    const versionStatus = getVersionStatus(config, sdk, currentVersion);
+    if (versionStatus === 'unsupported' || versionStatus === 'unknown') {
+      continue;
+    }
+    if (versionStatus === 'needs-upgrade') {
+      const changes = loadChanges(versionDir, sdk);
+      return {
+        ...config,
+        changes,
+        versionStatus,
+        needsUpgrade: true,
+        alreadyUpgraded: false
+      };
+    }
+    if (versionStatus === 'already-upgraded' && !applicableConfig) {
+      applicableConfig = {
+        config,
+        versionDir
+      };
+    }
+  }
+  if (applicableConfig) {
+    const changes = loadChanges(applicableConfig.versionDir, sdk);
+    return {
+      ...applicableConfig.config,
+      changes,
+      versionStatus: 'already-upgraded',
+      needsUpgrade: false,
+      alreadyUpgraded: true
+    };
+  }
+  return null;
+}
+function getVersionStatus(config, sdk, currentVersion) {
+  if (!config?.sdkVersions) {
+    return 'unknown';
+  }
+  const range = config.sdkVersions[sdk];
+  if (!range) {
+    return 'unknown';
+  }
+  if (typeof currentVersion !== 'number') {
+    return 'unknown';
+  }
+  if (typeof range.from === 'number' && currentVersion < range.from) {
+    return 'unsupported';
+  }
+  if (typeof range.to === 'number' && currentVersion >= range.to) {
+    return 'already-upgraded';
+  }
+  return 'needs-upgrade';
+}
+export function getTargetPackageName(sdk) {
+  if (sdk === 'clerk-react' || sdk === 'react') {
+    return '@clerk/react';
+  }
+  if (sdk === 'clerk-expo' || sdk === 'expo') {
+    return '@clerk/expo';
+  }
+  return `@clerk/${sdk}`;
+}
+export function getOldPackageName(sdk) {
+  if (sdk === 'clerk-react' || sdk === 'react') {
+    return '@clerk/clerk-react';
+  }
+  if (sdk === 'clerk-expo' || sdk === 'expo') {
+    return '@clerk/clerk-expo';
+  }
+  return null;
+}
+function loadChanges(versionDir, sdk) {
+  const changesDir = path.join(VERSIONS_DIR, versionDir, 'changes');
+  if (!fs.existsSync(changesDir)) {
+    return [];
+  }
+  const files = fs.readdirSync(changesDir).filter(f => f.endsWith('.md'));
+  const changes = [];
+  for (const file of files) {
+    const filePath = path.join(changesDir, file);
+    const content = fs.readFileSync(filePath, 'utf8');
+    const parsed = matter(content);
+    const fm = parsed.data;
+    const packages = fm.packages || ['*'];
+    const appliesToSdk = packages.includes('*') || packages.includes(sdk);
+    if (!appliesToSdk) {
+      continue;
+    }
+    const matcher = fm.matcher ? Array.isArray(fm.matcher) ? fm.matcher.map(m => new RegExp(m, `g${fm.matcherFlags || ''}`)) : new RegExp(fm.matcher, `g${fm.matcherFlags || ''}`) : null;
+    changes.push({
+      title: fm.title,
+      matcher,
+      packages,
+      category: fm.category || 'breaking',
+      warning: fm.warning || fm.category === 'warning',
+      docsAnchor: fm.docsAnchor || file.replace('.md', ''),
+      content: parsed.content
+    });
+  }
+  return changes;
+}

package/dist/render.js

@@ -0,0 +1,164 @@
+import * as readline from 'node:readline';
+import chalk from 'chalk';
+export function renderHeader() {
+  console.log('');
+  console.log(chalk.magenta.bold('>> Clerk Upgrade CLI <<'));
+  console.log('');
+}
+export function renderText(message, color) {
+  const colorFn = chalk[color] || (s => s);
+  console.log(colorFn(message));
+}
+export function renderSuccess(message) {
+  console.log(chalk.green(`✅ ${message}`));
+}
+export function renderError(message) {
+  console.error(chalk.red(`⛔ ${message}`));
+}
+export function renderWarning(message) {
+  console.log(chalk.yellow(`⚠️ ${message}`));
+}
+export function renderNewline() {
+  console.log('');
+}
+export function renderConfig({
+  sdk,
+  currentVersion,
+  fromVersion,
+  toVersion,
+  versionName,
+  dir,
+  packageManager
+}) {
+  console.log(`🔧 ${chalk.bold('Upgrade config')}`);
+  const versionSuffix = currentVersion ? ` ${chalk.gray(`(v${currentVersion})`)}` : '';
+  console.log(`Clerk SDK: ${chalk.green(`@clerk/${sdk}`)}${versionSuffix}`);
+  if (fromVersion && toVersion) {
+    const versionLabel = versionName ? ` ${chalk.gray(`(${versionName})`)}` : '';
+    console.log(`Upgrade: ${chalk.green(`v${fromVersion}`)} → ${chalk.green(`v${toVersion}`)}${versionLabel}`);
+  }
+  console.log(`Directory: ${chalk.green(dir)}`);
+  if (packageManager) {
+    console.log(`Package manager: ${chalk.green(packageManager)}`);
+  }
+  console.log('');
+}
+export async function promptConfirm(message) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise(resolve => {
+    rl.question(`${message} (y/n): `, answer => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+}
+export async function promptSelect(message, options) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  console.log(message);
+  options.forEach((opt, i) => {
+    console.log(`  ${i + 1}) ${opt.label}`);
+  });
+  return new Promise(resolve => {
+    rl.question('Enter number: ', answer => {
+      rl.close();
+      const index = parseInt(answer, 10) - 1;
+      if (index >= 0 && index < options.length) {
+        resolve(options[index].value);
+      } else {
+        resolve(null);
+      }
+    });
+  });
+}
+export async function promptText(message, defaultValue = '') {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const prompt = defaultValue ? `${message} [${defaultValue}]: ` : `${message}: `;
+  return new Promise(resolve => {
+    rl.question(prompt, answer => {
+      rl.close();
+      resolve(answer || defaultValue);
+    });
+  });
+}
+const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+export function createSpinner(label) {
+  let frameIndex = 0;
+  let interval = null;
+  let currentLabel = label;
+  const start = () => {
+    interval = setInterval(() => {
+      process.stdout.write(`\r${spinnerFrames[frameIndex]} ${currentLabel}`);
+      frameIndex = (frameIndex + 1) % spinnerFrames.length;
+    }, 80);
+  };
+  start();
+  return {
+    update(newLabel) {
+      currentLabel = newLabel;
+    },
+    stop() {
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+        process.stdout.write('\r\x1b[K');
+      }
+    },
+    success(message) {
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+      }
+      process.stdout.write(`\r\x1b[K${chalk.green('✓')} ${message}\n`);
+    },
+    error(message) {
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+      }
+      process.stdout.write(`\r\x1b[K${chalk.red('✗')} ${message}\n`);
+    }
+  };
+}
+export function renderCodemodResults(transform, result) {
+  console.log(`  ${result.ok ?? 0} file(s) modified, ${chalk.red(`  ${result.error ?? 0} errors`)}`);
+  console.log('');
+}
+export function renderScanResults(results, docsUrl) {
+  if (results.length === 0) {
+    console.log(chalk.green('✓ No breaking changes detected!'));
+    console.log('');
+    return;
+  }
+  console.log(chalk.yellow.bold(`Found ${results.length} potential issue(s) to review:`));
+  console.log('');
+  for (const item of results) {
+    console.log(chalk.bold(item.title));
+    if (item.warning) {
+      console.log(chalk.yellow('(warning - may not require action)'));
+    }
+    console.log(chalk.gray(`Found ${item.instances.length} instance(s):`));
+    for (const inst of item.instances) {
+      console.log(chalk.gray(`  ${inst.file}:${inst.position.line}:${inst.position.column}`));
+    }
+    const link = docsUrl && item.docsAnchor ? `${docsUrl}#${item.docsAnchor}` : null;
+    if (link) {
+      console.log(chalk.blue(`→ View in migration guide: ${link}`));
+    }
+    console.log('');
+  }
+}
+export function renderComplete(sdk, docsUrl) {
+  console.log(chalk.green.bold(`✅ Upgrade complete for @clerk/${sdk}`));
+  console.log('');
+  console.log(`Review the changes above and test your application before deployment.`);
+  console.log(chalk.gray(`For more information, see the migration guide: ${docsUrl}`));
+}

package/dist/runner.js

@@ -0,0 +1,98 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import chalk from 'chalk';
+import { convertPathToPattern, globby } from 'globby';
+import indexToPosition from 'index-to-position';
+import { getCodemodConfig, runCodemod } from './codemods/index.js';
+import { createSpinner, renderCodemodResults } from './render.js';
+const GLOBBY_IGNORE = ['node_modules/**', '**/node_modules/**', '.git/**', 'dist/**', '**/dist/**', 'build/**', '**/build/**', '.next/**', '**/.next/**', 'package.json', '**/package.json', 'package-lock.json', '**/package-lock.json', 'yarn.lock', '**/yarn.lock', 'pnpm-lock.yaml', '**/pnpm-lock.yaml', '**/*.(png|webp|svg|gif|jpg|jpeg)+', '**/*.(mp4|mkv|wmv|m4v|mov|avi|flv|webm|flac|mka|m4a|aac|ogg)+'];
+export async function runCodemods(config, sdk, options) {
+  const codemods = config.codemods || [];
+  if (codemods.length === 0) {
+    return;
+  }
+  const glob = typeof options.glob === 'string' ? options.glob.split(/[ ,]/).filter(Boolean) : options.glob;
+  for (const transform of codemods) {
+    const spinner = createSpinner(`Running codemod: ${transform}`);
+    try {
+      const result = await runCodemod(transform, glob, options);
+      spinner.success(`Codemod applied: ${chalk.dim(transform)}`);
+      renderCodemodResults(transform, result);
+      const codemodConfig = getCodemodConfig(transform);
+      if (codemodConfig?.renderSummary && result.stats) {
+        codemodConfig.renderSummary(result.stats);
+      }
+    } catch (error) {
+      spinner.error(`Codemod failed: ${transform}`);
+      throw error;
+    }
+  }
+}
+export async function runScans(config, sdk, options) {
+  const matchers = loadMatchers(config, sdk);
+  if (matchers.length === 0) {
+    return [];
+  }
+  const spinner = createSpinner('Scanning files for breaking changes...');
+  try {
+    const pattern = convertPathToPattern(path.resolve(options.dir));
+    const files = await globby(pattern, {
+      ignore: [...GLOBBY_IGNORE, ...(options.ignore || [])]
+    });
+    const results = {};
+    for (let idx = 0; idx < files.length; idx++) {
+      const file = files[idx];
+      spinner.update(`Scanning ${path.basename(file)} (${idx + 1}/${files.length})`);
+      const content = await fs.readFile(file, 'utf8');
+      for (const matcher of matchers) {
+        const matches = findMatches(content, matcher.matcher);
+        if (matches.length === 0) {
+          continue;
+        }
+        if (!results[matcher.title]) {
+          results[matcher.title] = {
+            instances: [],
+            ...matcher
+          };
+        }
+        for (const match of matches) {
+          const position = indexToPosition(content, match.index, {
+            oneBased: true
+          });
+          const fileRelative = path.relative(process.cwd(), file);
+          const isDuplicate = results[matcher.title].instances.some(i => i.position.line === position.line && i.position.column === position.column && i.file === fileRelative);
+          if (!isDuplicate) {
+            results[matcher.title].instances.push({
+              sdk,
+              position,
+              file: fileRelative
+            });
+          }
+        }
+      }
+    }
+    spinner.success(`Scanned ${files.length} files`);
+    return Object.values(results);
+  } catch (error) {
+    spinner.error('Scan failed');
+    throw error;
+  }
+}
+function loadMatchers(config, sdk) {
+  if (!config.changes) {
+    return [];
+  }
+  return config.changes.filter(change => {
+    if (!change.matcher) {
+      return false;
+    }
+    const packages = change.packages || ['*'];
+    return packages.includes('*') || packages.includes(sdk);
+  });
+}
+function findMatches(content, matcher) {
+  if (Array.isArray(matcher)) {
+    return matcher.flatMap(m => Array.from(content.matchAll(m)));
+  }
+  return Array.from(content.matchAll(matcher));
+}

package/dist/util/detect-sdk.js

@@ -0,0 +1,125 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { readPackageSync } from 'read-pkg';
+import semverRegex from 'semver-regex';
+import { getOldPackageName } from '../config.js';
+const SUPPORTED_SDKS = [{
+  label: '@clerk/nextjs',
+  value: 'nextjs'
+}, {
+  label: '@clerk/react',
+  value: 'react'
+}, {
+  label: '@clerk/clerk-react',
+  value: 'react'
+}, {
+  label: '@clerk/expo',
+  value: 'expo'
+}, {
+  label: '@clerk/clerk-expo',
+  value: 'expo'
+}, {
+  label: '@clerk/react-router',
+  value: 'react-router'
+}, {
+  label: '@clerk/tanstack-react-start',
+  value: 'tanstack-react-start'
+}, {
+  label: '@clerk/astro',
+  value: 'astro'
+}, {
+  label: '@clerk/nuxt',
+  value: 'nuxt'
+}, {
+  label: '@clerk/vue',
+  value: 'vue'
+}, {
+  label: '@clerk/express',
+  value: 'express'
+}, {
+  label: '@clerk/fastify',
+  value: 'fastify'
+}, {
+  label: '@clerk/clerk-js',
+  value: 'js'
+}, {
+  label: '@clerk/backend',
+  value: 'backend'
+}];
+export function getSupportedSdks() {
+  return SUPPORTED_SDKS;
+}
+export function detectSdk(dir) {
+  let pkg;
+  try {
+    const pkgPath = path.join(dir, 'package.json');
+    pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+  } catch {
+    return null;
+  }
+  const deps = pkg.dependencies ? Object.keys(pkg.dependencies) : [];
+  const devDeps = pkg.devDependencies ? Object.keys(pkg.devDependencies) : [];
+  const allDeps = [...deps, ...devDeps];
+  for (const {
+    label,
+    value
+  } of SUPPORTED_SDKS) {
+    if (allDeps.includes(label)) {
+      return value;
+    }
+  }
+  return null;
+}
+export function getSdkVersion(sdk, dir) {
+  let pkg;
+  try {
+    pkg = readPackageSync({
+      cwd: dir
+    });
+  } catch {
+    return null;
+  }
+  const pkgName = sdk.startsWith('@clerk/') ? sdk : `@clerk/${sdk}`;
+  const oldPkgName = getOldPackageName(sdk);
+  const version = pkg.dependencies?.[pkgName] || pkg.devDependencies?.[pkgName] || oldPkgName && pkg.dependencies?.[oldPkgName] || oldPkgName && pkg.devDependencies?.[oldPkgName];
+  if (!version) {
+    return null;
+  }
+  return getMajorVersion(version);
+}
+export function getMajorVersion(semver) {
+  const cleaned = semver.replace(/^[\^~]/, '');
+  const match = cleaned.match(semverRegex());
+  if (match) {
+    const [major] = match[0].split('.');
+    return parseInt(major, 10);
+  }
+  return null;
+}
+export function getInstalledClerkPackages(dir) {
+  let pkg;
+  try {
+    const pkgPath = path.join(dir, 'package.json');
+    pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+  } catch {
+    return {};
+  }
+  const deps = pkg.dependencies ? Object.entries(pkg.dependencies) : [];
+  const devDeps = pkg.devDependencies ? Object.entries(pkg.devDependencies) : [];
+  return Object.fromEntries([...deps, ...devDeps].filter(([name]) => name.startsWith('@clerk/')).map(([name, version]) => [name, getMajorVersion(version)]));
+}
+export function normalizeSdkName(sdk) {
+  if (!sdk) {
+    return null;
+  }
+  if (sdk.startsWith('@clerk/')) {
+    return sdk.replace('@clerk/', '');
+  }
+  if (sdk === 'clerk-react') {
+    return 'react';
+  }
+  if (sdk === 'clerk-expo') {
+    return 'expo';
+  }
+  return sdk;
+}

package/dist/util/package-manager.js

@@ -0,0 +1,94 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+export function detectPackageManager(dir) {
+  if (fs.existsSync(path.join(dir, 'pnpm-lock.yaml'))) {
+    return 'pnpm';
+  }
+  if (fs.existsSync(path.join(dir, 'yarn.lock'))) {
+    return 'yarn';
+  }
+  if (fs.existsSync(path.join(dir, 'bun.lockb')) || fs.existsSync(path.join(dir, 'bun.lock'))) {
+    return 'bun';
+  }
+  if (fs.existsSync(path.join(dir, 'package-lock.json'))) {
+    return 'npm';
+  }
+  return 'npm';
+}
+export function getInstallCommand(packageManager, packageName, version = 'latest') {
+  const pkg = version === 'latest' ? packageName : `${packageName}@${version}`;
+  switch (packageManager) {
+    case 'pnpm':
+      return ['pnpm', ['add', pkg]];
+    case 'yarn':
+      return ['yarn', ['add', pkg]];
+    case 'bun':
+      return ['bun', ['add', pkg]];
+    case 'npm':
+    default:
+      return ['npm', ['install', pkg]];
+  }
+}
+export function getUninstallCommand(packageManager, packageName) {
+  switch (packageManager) {
+    case 'pnpm':
+      return ['pnpm', ['remove', packageName]];
+    case 'yarn':
+      return ['yarn', ['remove', packageName]];
+    case 'bun':
+      return ['bun', ['remove', packageName]];
+    case 'npm':
+    default:
+      return ['npm', ['uninstall', packageName]];
+  }
+}
+export async function runPackageManagerCommand(command, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio: 'pipe',
+      shell: process.platform === 'win32'
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout?.on('data', data => {
+      stdout += data.toString();
+    });
+    child.stderr?.on('data', data => {
+      stderr += data.toString();
+    });
+    child.on('close', code => {
+      if (code === 0) {
+        resolve({
+          stdout,
+          stderr
+        });
+      } else {
+        reject(new Error(`Command failed with code ${code}: ${stderr || stdout}`));
+      }
+    });
+    child.on('error', reject);
+  });
+}
+export async function upgradePackage(packageManager, packageName, version, cwd) {
+  const [cmd, args] = getInstallCommand(packageManager, packageName, version);
+  return runPackageManagerCommand(cmd, args, cwd);
+}
+export async function removePackage(packageManager, packageName, cwd) {
+  const [cmd, args] = getUninstallCommand(packageManager, packageName);
+  return runPackageManagerCommand(cmd, args, cwd);
+}
+export function getPackageManagerDisplayName(packageManager) {
+  switch (packageManager) {
+    case 'pnpm':
+      return 'pnpm';
+    case 'yarn':
+      return 'Yarn';
+    case 'bun':
+      return 'Bun';
+    case 'npm':
+    default:
+      return 'npm';
+  }
+}

package/dist/versions/core-3/changes/clerk-expo-package-rename.md

@@ -0,0 +1,23 @@
+---
+title: '`@clerk/clerk-expo` renamed to `@clerk/expo`'
+packages: ['expo']
+matcher: '@clerk/clerk-expo'
+category: 'breaking'
+docsAnchor: 'clerk-expo-rename'
+---
+
+The `@clerk/clerk-expo` package has been renamed to `@clerk/expo`.
+
+Update your imports:
+
+```diff
+- import { ClerkProvider, useUser } from '@clerk/clerk-expo';
++ import { ClerkProvider, useUser } from '@clerk/expo';
+```
+
+And update your package.json:
+
+```diff
+- "@clerk/clerk-expo": "^2.0.0",
++ "@clerk/expo": "^3.0.0",
+```