@lobehub/lobehub 2.0.0-next.355 → 2.0.0-next.357

package/scripts/nextauth-to-betterauth/_internal/config.ts

@@ -0,0 +1,41 @@
+import './env';
+
+export type MigrationMode = 'test' | 'prod';
+export type DatabaseDriver = 'neon' | 'node';
+
+const DEFAULT_MODE: MigrationMode = 'test';
+const DEFAULT_DATABASE_DRIVER: DatabaseDriver = 'neon';
+
+export function getMigrationMode(): MigrationMode {
+  const mode = process.env.NEXTAUTH_TO_BETTERAUTH_MODE;
+  if (mode === 'test' || mode === 'prod') return mode;
+  return DEFAULT_MODE;
+}
+
+export function getDatabaseUrl(mode = getMigrationMode()): string {
+  const key =
+    mode === 'test'
+      ? 'TEST_NEXTAUTH_TO_BETTERAUTH_DATABASE_URL'
+      : 'PROD_NEXTAUTH_TO_BETTERAUTH_DATABASE_URL';
+  const value = process.env[key];
+
+  if (!value) {
+    throw new Error(`${key} is not set`);
+  }
+
+  return value;
+}
+
+export function getDatabaseDriver(): DatabaseDriver {
+  const driver = process.env.NEXTAUTH_TO_BETTERAUTH_DATABASE_DRIVER;
+  if (driver === 'neon' || driver === 'node') return driver;
+  return DEFAULT_DATABASE_DRIVER;
+}
+
+export function getBatchSize(): number {
+  return Number(process.env.NEXTAUTH_TO_BETTERAUTH_BATCH_SIZE) || 300;
+}
+
+export function isDryRun(): boolean {
+  return process.argv.includes('--dry-run') || process.env.NEXTAUTH_TO_BETTERAUTH_DRY_RUN === '1';
+}

package/scripts/nextauth-to-betterauth/_internal/db.ts

@@ -0,0 +1,32 @@
+import { Pool as NeonPool, neonConfig } from '@neondatabase/serverless';
+import { drizzle as neonDrizzle } from 'drizzle-orm/neon-serverless';
+import { drizzle as nodeDrizzle } from 'drizzle-orm/node-postgres';
+import { Pool as NodePool } from 'pg';
+import ws from 'ws';
+
+// schema is the only dependency on project code, required for type-safe migrations
+import * as schemaModule from '../../../packages/database/src/schemas';
+import { getDatabaseDriver, getDatabaseUrl } from './config';
+
+function createDatabase() {
+  const databaseUrl = getDatabaseUrl();
+  const driver = getDatabaseDriver();
+
+  if (driver === 'node') {
+    const pool = new NodePool({ connectionString: databaseUrl });
+    const db = nodeDrizzle(pool, { schema: schemaModule });
+    return { db, pool };
+  }
+
+  // neon driver (default)
+  // https://github.com/neondatabase/serverless/blob/main/CONFIG.md#websocketconstructor-typeof-websocket--undefined
+  neonConfig.webSocketConstructor = ws;
+  const pool = new NeonPool({ connectionString: databaseUrl });
+  const db = neonDrizzle(pool, { schema: schemaModule });
+  return { db, pool };
+}
+
+const { db, pool } = createDatabase();
+
+export { db, pool };
+export * as schema from '../../../packages/database/src/schemas';

package/scripts/nextauth-to-betterauth/_internal/env.ts

@@ -0,0 +1,6 @@
+import { existsSync } from 'node:fs';
+import { loadEnvFile } from 'node:process';
+
+if (existsSync('.env')) {
+  loadEnvFile();
+}

package/scripts/nextauth-to-betterauth/index.ts

@@ -0,0 +1,226 @@
+/* eslint-disable unicorn/prefer-top-level-await */
+import { sql } from 'drizzle-orm';
+
+import { getBatchSize, getMigrationMode, isDryRun } from './_internal/config';
+import { db, pool, schema } from './_internal/db';
+
+const BATCH_SIZE = getBatchSize();
+const PROGRESS_TABLE = sql.identifier('nextauth_migration_progress');
+const IS_DRY_RUN = isDryRun();
+const formatDuration = (ms: number) => `${(ms / 1000).toFixed(1)}s`;
+
+// ANSI color codes
+const GREEN_BOLD = '\u001B[1;32m';
+const RED_BOLD = '\u001B[1;31m';
+const RESET = '\u001B[0m';
+
+function chunk<T>(items: T[], size: number): T[][] {
+  if (!Number.isFinite(size) || size <= 0) return [items];
+  const result: T[][] = [];
+  for (let i = 0; i < items.length; i += size) {
+    result.push(items.slice(i, i + size));
+  }
+  return result;
+}
+
+/**
+ * Convert expires_at (seconds since epoch) to Date
+ */
+function convertExpiresAt(expiresAt: number | null): Date | undefined {
+  if (expiresAt === null || expiresAt === undefined) return undefined;
+  return new Date(expiresAt * 1000);
+}
+
+/**
+ * Convert scope format from NextAuth (space-separated) to Better Auth (comma-separated)
+ * e.g., "openid profile email" -> "openid,profile,email"
+ */
+function convertScope(scope: string | null): string | undefined {
+  if (!scope) return undefined;
+  return scope.trim().split(/\s+/).join(',');
+}
+
+/**
+ * Create a composite key for nextauth_accounts (provider + providerAccountId)
+ */
+function createAccountKey(provider: string, providerAccountId: string): string {
+  return `${provider}__${providerAccountId}`;
+}
+
+async function loadNextAuthAccounts() {
+  const rows = await db.select().from(schema.nextauthAccounts);
+  return rows;
+}
+
+async function migrateFromNextAuth() {
+  const mode = getMigrationMode();
+  const nextauthAccounts = await loadNextAuthAccounts();
+
+  if (!IS_DRY_RUN) {
+    await db.execute(sql`
+      CREATE TABLE IF NOT EXISTS ${PROGRESS_TABLE} (
+        account_key TEXT PRIMARY KEY,
+        processed_at TIMESTAMPTZ DEFAULT NOW()
+      );
+    `);
+  }
+
+  const processedAccounts = new Set<string>();
+
+  if (!IS_DRY_RUN) {
+    try {
+      const processedResult = await db.execute<{ account_key: string }>(
+        sql`SELECT account_key FROM ${PROGRESS_TABLE};`,
+      );
+      const rows = (processedResult as { rows?: { account_key: string }[] }).rows ?? [];
+
+      for (const row of rows) {
+        const accountKey = row?.account_key;
+        if (typeof accountKey === 'string') {
+          processedAccounts.add(accountKey);
+        }
+      }
+    } catch (error) {
+      console.warn(
+        '[nextauth-to-betterauth] failed to read progress table, treating as empty',
+        error,
+      );
+    }
+  }
+
+  console.log(`[nextauth-to-betterauth] mode: ${mode} (dryRun=${IS_DRY_RUN})`);
+  console.log(`[nextauth-to-betterauth] nextauth accounts: ${nextauthAccounts.length}`);
+  console.log(`[nextauth-to-betterauth] already processed: ${processedAccounts.size}`);
+
+  const unprocessedAccounts = nextauthAccounts.filter(
+    (acc) => !processedAccounts.has(createAccountKey(acc.provider, acc.providerAccountId)),
+  );
+  const batches = chunk(unprocessedAccounts, BATCH_SIZE);
+  console.log(
+    `[nextauth-to-betterauth] batches: ${batches.length} (batchSize=${BATCH_SIZE}, toProcess=${unprocessedAccounts.length})`,
+  );
+
+  let processed = 0;
+  const skipped = nextauthAccounts.length - unprocessedAccounts.length;
+  const startedAt = Date.now();
+  const providerCounts: Record<string, number> = {};
+
+  const bumpProviderCount = (providerId: string) => {
+    providerCounts[providerId] = (providerCounts[providerId] ?? 0) + 1;
+  };
+
+  for (let batchIndex = 0; batchIndex < batches.length; batchIndex += 1) {
+    const batch = batches[batchIndex];
+    const accountRows: (typeof schema.account.$inferInsert)[] = [];
+    const accountKeys: string[] = [];
+
+    for (const nextauthAccount of batch) {
+      const accountKey = createAccountKey(
+        nextauthAccount.provider,
+        nextauthAccount.providerAccountId,
+      );
+
+      const accountRow: typeof schema.account.$inferInsert = {
+        accessToken: nextauthAccount.access_token ?? undefined,
+        accessTokenExpiresAt: convertExpiresAt(nextauthAccount.expires_at),
+        accountId: nextauthAccount.providerAccountId,
+        // id and createdAt/updatedAt use database defaults
+        id: accountKey, // deterministic id based on provider + providerAccountId
+        idToken: nextauthAccount.id_token ?? undefined,
+        providerId: nextauthAccount.provider,
+        refreshToken: nextauthAccount.refresh_token ?? undefined,
+        scope: convertScope(nextauthAccount.scope),
+        userId: nextauthAccount.userId,
+      };
+
+      accountRows.push(accountRow);
+      accountKeys.push(accountKey);
+      bumpProviderCount(nextauthAccount.provider);
+    }
+
+    if (!IS_DRY_RUN) {
+      await db.transaction(async (tx) => {
+        if (accountRows.length > 0) {
+          await tx.insert(schema.account).values(accountRows).onConflictDoNothing();
+        }
+
+        const accountKeyValues = accountKeys.map((key) => sql`(${key})`);
+        if (accountKeyValues.length > 0) {
+          await tx.execute(sql`
+            INSERT INTO ${PROGRESS_TABLE} (account_key)
+            VALUES ${sql.join(accountKeyValues, sql`, `)}
+            ON CONFLICT (account_key) DO NOTHING;
+          `);
+        }
+      });
+    }
+
+    processed += batch.length;
+    console.log(
+      `[nextauth-to-betterauth] batch ${batchIndex + 1}/${batches.length} done, accounts ${processed}/${unprocessedAccounts.length}, dryRun=${IS_DRY_RUN}`,
+    );
+  }
+
+  console.log(
+    `[nextauth-to-betterauth] completed accounts=${GREEN_BOLD}${processed}${RESET}, skipped=${skipped}, dryRun=${IS_DRY_RUN}, elapsed=${formatDuration(Date.now() - startedAt)}`,
+  );
+
+  const providerCountsText = Object.entries(providerCounts)
+    .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+    .map(([providerId, count]) => `${providerId}=${count}`)
+    .join(', ');
+
+  console.log(`[nextauth-to-betterauth] provider counts: ${providerCountsText || 'none recorded'}`);
+}
+
+async function main() {
+  const startedAt = Date.now();
+  const mode = getMigrationMode();
+
+  console.log('');
+  console.log('╔════════════════════════════════════════════════════════════╗');
+  console.log('║        NextAuth to Better Auth Migration Script            ║');
+  console.log('╠════════════════════════════════════════════════════════════╣');
+  console.log(`║  Mode:     ${mode.padEnd(48)}║`);
+  console.log(`║  Dry Run:  ${(IS_DRY_RUN ? 'YES (no changes will be made)' : 'NO').padEnd(48)}║`);
+  console.log(`║  Batch:    ${String(BATCH_SIZE).padEnd(48)}║`);
+  console.log('╚════════════════════════════════════════════════════════════╝');
+  console.log('');
+
+  if (mode === 'prod' && !IS_DRY_RUN) {
+    console.log('⚠️  WARNING: Running in PRODUCTION mode. Data will be modified!');
+    console.log('   Type "yes" to continue or press Ctrl+C to abort.');
+    console.log('');
+
+    const readline = await import('node:readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise<string>((resolve) => {
+      rl.question('   Confirm (yes/no): ', (ans) => {
+        resolve(ans);
+      });
+    });
+    rl.close();
+
+    if (answer.toLowerCase() !== 'yes') {
+      console.log('❌ Aborted by user.');
+      process.exitCode = 0;
+      await pool.end();
+      return;
+    }
+    console.log('');
+  }
+
+  try {
+    await migrateFromNextAuth();
+    console.log('');
+    console.log(`${GREEN_BOLD}✅ Migration success!${RESET} (${formatDuration(Date.now() - startedAt)})`);
+  } catch (error) {
+    console.log('');
+    console.error(`${RED_BOLD}❌ Migration failed${RESET} (${formatDuration(Date.now() - startedAt)}):`, error);
+    process.exitCode = 1;
+  } finally {
+    await pool.end();
+  }
+}
+
+void main();

package/scripts/nextauth-to-betterauth/verify.ts

@@ -0,0 +1,188 @@
+/* eslint-disable unicorn/prefer-top-level-await */
+import { getMigrationMode } from './_internal/config';
+import { db, pool, schema } from './_internal/db';
+
+type ExpectedAccount = {
+  accountId: string;
+  providerId: string;
+  scope?: string;
+  userId: string;
+};
+
+type ActualAccount = {
+  accountId: string;
+  providerId: string;
+  scope: string | null;
+  userId: string;
+};
+
+const MAX_SAMPLES = 5;
+
+const formatDuration = (ms: number) => `${(ms / 1000).toFixed(1)}s`;
+
+function buildAccountKey(account: { accountId: string; providerId: string; userId: string }) {
+  return `${account.userId}__${account.providerId}__${account.accountId}`;
+}
+
+async function loadNextAuthAccounts() {
+  const rows = await db.select().from(schema.nextauthAccounts);
+  return rows;
+}
+
+async function loadActualAccounts() {
+  const rows = await db
+    .select({
+      accountId: schema.account.accountId,
+      providerId: schema.account.providerId,
+      scope: schema.account.scope,
+      userId: schema.account.userId,
+    })
+    .from(schema.account);
+
+  return rows as ActualAccount[];
+}
+
+function buildExpectedAccounts(nextauthAccounts: Awaited<ReturnType<typeof loadNextAuthAccounts>>) {
+  const expectedAccounts: ExpectedAccount[] = [];
+
+  for (const nextauthAccount of nextauthAccounts) {
+    expectedAccounts.push({
+      accountId: nextauthAccount.providerAccountId,
+      providerId: nextauthAccount.provider,
+      scope: nextauthAccount.scope ?? undefined,
+      userId: nextauthAccount.userId,
+    });
+  }
+
+  return { expectedAccounts };
+}
+
+async function main() {
+  const startedAt = Date.now();
+  const mode = getMigrationMode();
+
+  console.log('');
+  console.log('╔════════════════════════════════════════════════════════════╗');
+  console.log('║     NextAuth to Better Auth Verification Script            ║');
+  console.log('╠════════════════════════════════════════════════════════════╣');
+  console.log(`║  Mode:     ${mode.padEnd(48)}║`);
+  console.log('╚════════════════════════════════════════════════════════════╝');
+  console.log('');
+
+  const [nextauthAccounts, actualAccounts] = await Promise.all([
+    loadNextAuthAccounts(),
+    loadActualAccounts(),
+  ]);
+
+  console.log(`📦 [verify] Loaded nextauth_accounts=${nextauthAccounts.length}`);
+
+  const { expectedAccounts } = buildExpectedAccounts(nextauthAccounts);
+
+  console.log(`🧮 [verify] Expected accounts=${expectedAccounts.length}`);
+  console.log(`🗄️ [verify] DB snapshot: accounts=${actualAccounts.length}`);
+
+  const expectedAccountSet = new Set(expectedAccounts.map(buildAccountKey));
+  const actualAccountSet = new Set(actualAccounts.map(buildAccountKey));
+
+  let missingAccounts = 0;
+  const missingAccountSamples: string[] = [];
+  for (const account of expectedAccounts) {
+    const key = buildAccountKey(account);
+    if (!actualAccountSet.has(key)) {
+      missingAccounts += 1;
+      if (missingAccountSamples.length < MAX_SAMPLES) {
+        missingAccountSamples.push(`${account.providerId}/${account.accountId}`);
+      }
+    }
+  }
+
+  let unexpectedAccounts = 0;
+  const unexpectedAccountSamples: string[] = [];
+  for (const account of actualAccounts) {
+    const key = buildAccountKey(account);
+    if (!expectedAccountSet.has(key)) {
+      unexpectedAccounts += 1;
+      if (unexpectedAccountSamples.length < MAX_SAMPLES) {
+        unexpectedAccountSamples.push(`${account.providerId}/${account.accountId}`);
+      }
+    }
+  }
+
+  // Provider counts
+  const expectedProviderCounts: Record<string, number> = {};
+  const actualProviderCounts: Record<string, number> = {};
+
+  for (const account of expectedAccounts) {
+    expectedProviderCounts[account.providerId] =
+      (expectedProviderCounts[account.providerId] ?? 0) + 1;
+  }
+
+  for (const account of actualAccounts) {
+    actualProviderCounts[account.providerId] = (actualProviderCounts[account.providerId] ?? 0) + 1;
+  }
+
+  const formatCounts = (counts: Record<string, number>) =>
+    Object.entries(counts)
+      .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+      .map(([providerId, count]) => `${providerId}=${count}`)
+      .join(', ');
+
+  console.log(
+    `📊 [verify] Expected provider counts: ${formatCounts(expectedProviderCounts) || 'n/a'}`,
+  );
+  console.log(
+    `📊 [verify] Actual provider counts:   ${formatCounts(actualProviderCounts) || 'n/a'}`,
+  );
+
+  // Check for missing scope in actual accounts
+  let missingScopeNonCredential = 0;
+  const sampleMissingScope: string[] = [];
+
+  for (const account of actualAccounts) {
+    if (account.providerId !== 'credential' && !account.scope) {
+      // Find corresponding nextauth account to check if it had scope
+      const nextauthAccount = nextauthAccounts.find(
+        (na) => na.provider === account.providerId && na.providerAccountId === account.accountId,
+      );
+      if (nextauthAccount?.scope) {
+        missingScopeNonCredential += 1;
+        if (sampleMissingScope.length < MAX_SAMPLES) {
+          sampleMissingScope.push(`${account.providerId}/${account.accountId}`);
+        }
+      }
+    }
+  }
+
+  console.log('');
+  console.log('📋 [verify] Summary:');
+  console.log(
+    `   - Missing accounts: ${missingAccounts} ${missingAccountSamples.length > 0 ? `(samples: ${missingAccountSamples.join(', ')})` : ''}`,
+  );
+  console.log(
+    `   - Unexpected accounts: ${unexpectedAccounts} ${unexpectedAccountSamples.length > 0 ? `(samples: ${unexpectedAccountSamples.join(', ')})` : '(accounts not from nextauth)'}`,
+  );
+  console.log(
+    `   - Missing scope (had in nextauth): ${missingScopeNonCredential} ${sampleMissingScope.length > 0 ? `(samples: ${sampleMissingScope.join(', ')})` : ''}`,
+  );
+
+  console.log('');
+  if (missingAccounts === 0) {
+    console.log(
+      `✅ Verification success! All nextauth accounts migrated. (${formatDuration(Date.now() - startedAt)})`,
+    );
+  } else {
+    console.log(
+      `⚠️ Verification completed with ${missingAccounts} missing accounts. (${formatDuration(Date.now() - startedAt)})`,
+    );
+  }
+}
+
+void main()
+  .catch((error) => {
+    console.log('');
+    console.error('❌ Verification failed:', error);
+    process.exitCode = 1;
+  })
+  .finally(async () => {
+    await pool.end();
+  });

package/scripts/prebuild.mts

@@ -9,10 +9,11 @@ import { fileURLToPath } from 'node:url';
 
 // Use createRequire for CommonJS module compatibility
 const require = createRequire(import.meta.url);
-const { checkDeprecatedClerkEnv } = require('./_shared/checkDeprecatedClerkEnv.js');
+const { checkDeprecatedAuth } = require('./_shared/checkDeprecatedAuth.js');
 
 const isDesktop = process.env.NEXT_PUBLIC_IS_DESKTOP_APP === '1';
 const isBundleAnalyzer = process.env.ANALYZE === 'true' && process.env.CI === 'true';
+const isServerDB = !!process.env.DATABASE_URL;
 
 if (isDesktop) {
   dotenvExpand.expand(dotenv.config({ path: '.env.desktop' }));
@@ -21,10 +22,40 @@ if (isDesktop) {
   dotenvExpand.expand(dotenv.config());
 }
 
-// Auth flags - use process.env directly for build-time dead code elimination
-// Better Auth is the default auth solution when NextAuth is not explicitly enabled
-const enableNextAuth = process.env.NEXT_PUBLIC_ENABLE_NEXT_AUTH === '1';
-const enableBetterAuth = !enableNextAuth;
+const AUTH_SECRET_DOC_URL = 'https://lobehub.com/docs/self-hosting/environment-variables/auth#auth-secret';
+const KEY_VAULTS_SECRET_DOC_URL = 'https://lobehub.com/docs/self-hosting/environment-variables/basic#key-vaults-secret';
+
+/**
+ * Check for required environment variables in server database mode
+ */
+const checkRequiredEnvVars = () => {
+  if (isDesktop || !isServerDB) return;
+
+  const missingVars: { docUrl: string; name: string }[] = [];
+
+  if (!process.env.AUTH_SECRET) {
+    missingVars.push({ docUrl: AUTH_SECRET_DOC_URL, name: 'AUTH_SECRET' });
+  }
+
+  if (!process.env.KEY_VAULTS_SECRET) {
+    missingVars.push({ docUrl: KEY_VAULTS_SECRET_DOC_URL, name: 'KEY_VAULTS_SECRET' });
+  }
+
+  if (missingVars.length > 0) {
+    console.error('\n' + '═'.repeat(70));
+    console.error('❌ ERROR: Missing required environment variables!');
+    console.error('═'.repeat(70));
+    console.error('\nThe following environment variables are required for server database mode:\n');
+    for (const { name, docUrl } of missingVars) {
+      console.error(`  • ${name}`);
+      console.error(`    📖 Documentation: ${docUrl}\n`);
+    }
+    console.error('Please configure these environment variables and redeploy.');
+    console.error('═'.repeat(70) + '\n');
+    process.exit(1);
+  }
+};
+
 
 const getCommandVersion = (command: string): string | null => {
   try {
@@ -58,13 +89,32 @@ const printEnvInfo = () => {
   console.log(`    VERCEL_PROJECT_PRODUCTION_URL: ${process.env.VERCEL_PROJECT_PRODUCTION_URL ?? '(not set)'}`);
   console.log(`    AUTH_EMAIL_VERIFICATION: ${process.env.AUTH_EMAIL_VERIFICATION ?? '(not set)'}`);
   console.log(`    ENABLE_MAGIC_LINK: ${process.env.ENABLE_MAGIC_LINK ?? '(not set)'}`);
-  console.log(`    AUTH_SECRET: ${process.env.AUTH_SECRET ? '✓ set' : '✗ not set'}`);
-  console.log(`    KEY_VAULTS_SECRET: ${process.env.KEY_VAULTS_SECRET ? '✓ set' : '✗ not set'}`);
 
-  // Auth flags
-  console.log('\n  Auth Flags:');
-  console.log(`    enableBetterAuth: ${enableBetterAuth}`);
-  console.log(`    enableNextAuth: ${enableNextAuth}`);
+  // Check SSO providers configuration
+  const ssoProviders = process.env.AUTH_SSO_PROVIDERS;
+  console.log(`    AUTH_SSO_PROVIDERS: ${ssoProviders ?? '(not set)'}`);
+
+  if (ssoProviders) {
+    const getEnvPrefix = (provider: string) => `AUTH_${provider.toUpperCase().replaceAll('-', '_')}`;
+
+    const providers = ssoProviders.split(/[,，]/).map(p => p.trim()).filter(Boolean);
+    const missingProviders: string[] = [];
+
+    for (const provider of providers) {
+      const envPrefix = getEnvPrefix(provider);
+      const hasEnvVar = Object.keys(process.env).some(key => key.startsWith(envPrefix));
+      if (!hasEnvVar) {
+        missingProviders.push(provider);
+      }
+    }
+
+    if (missingProviders.length > 0) {
+      console.log('\n  ⚠️  SSO Provider Configuration Warning:');
+      for (const provider of missingProviders) {
+        console.log(`    - "${provider}" is configured but no ${getEnvPrefix(provider)}_* env vars found`);
+      }
+    }
+  }
 
   console.log('─'.repeat(50));
 };
@@ -160,8 +210,11 @@ export const runPrebuild = async (targetDir: string = 'src') => {
 const isMainModule = process.argv[1] === fileURLToPath(import.meta.url);
 
 if (isMainModule) {
-  // Check for deprecated Clerk env vars first - fail fast if found
-  checkDeprecatedClerkEnv();
+  // Check for deprecated auth env vars first - fail fast if found
+  checkDeprecatedAuth();
+
+  // Check for required env vars in server database mode
+  checkRequiredEnvVars();
 
   printEnvInfo();
   // 执行删除操作

package/scripts/serverLauncher/startServer.js

@@ -7,11 +7,11 @@ const { existsSync } = require('node:fs');
 // Resolve shared module path for both local dev and Docker environments
 // Local: scripts/serverLauncher/startServer.js -> scripts/_shared/...
 // Docker: /app/startServer.js -> /app/scripts/_shared/...
-const localPath = path.join(__dirname, '..', '_shared', 'checkDeprecatedClerkEnv.js');
-const dockerPath = '/app/scripts/_shared/checkDeprecatedClerkEnv.js';
+const localPath = path.join(__dirname, '..', '_shared', 'checkDeprecatedAuth.js');
+const dockerPath = '/app/scripts/_shared/checkDeprecatedAuth.js';
 const sharedModulePath = existsSync(localPath) ? localPath : dockerPath;
 
-const { checkDeprecatedClerkEnv } = require(sharedModulePath);
+const { checkDeprecatedAuth } = require(sharedModulePath);
 
 // Set file paths
 const DB_MIGRATION_SCRIPT_PATH = '/app/docker.cjs';
@@ -139,8 +139,8 @@ const runServer = async () => {
 
 // Main execution block
 (async () => {
-  // Check for deprecated Clerk env vars first - fail fast if found
-  checkDeprecatedClerkEnv({ action: 'restart' });
+  // Check for deprecated auth env vars first - fail fast if found
+  checkDeprecatedAuth({ action: 'restart' });
 
   console.log('🌐 DNS Server:', dns.getServers());
   console.log('-------------------------------------');

package/src/app/(backend)/api/auth/[...all]/route.ts

@@ -1,32 +1,14 @@
+import { toNextJsHandler } from 'better-auth/next-js';
 import type { NextRequest } from 'next/server';
 
-import { enableBetterAuth, enableNextAuth } from '@/envs/auth';
+import { auth } from '@/auth';
 
-const createHandler = async () => {
-  if (enableBetterAuth) {
-    const [{ toNextJsHandler }, { auth }] = await Promise.all([
-      import('better-auth/next-js'),
-      import('@/auth'),
-    ]);
-    return toNextJsHandler(auth);
-  }
-
-  if (enableNextAuth) {
-    const NextAuthNode = await import('@/libs/next-auth');
-    return NextAuthNode.default.handlers;
-  }
-
-  return { GET: undefined, POST: undefined };
-};
-
-const handler = createHandler();
+const handler = toNextJsHandler(auth);
 
 export const GET = async (req: NextRequest) => {
-  const { GET } = await handler;
-  return GET?.(req);
+  return handler.GET(req);
 };
 
 export const POST = async (req: NextRequest) => {
-  const { POST } = await handler;
-  return POST?.(req);
+  return handler.POST(req);
 };