@beignet/cli 0.0.50 → 0.0.52

package/src/inspect.ts

@@ -1,6 +1,8 @@
 import { readdir, readFile, stat } from "node:fs/promises";
+import { createRequire } from "node:module";
 import path from "node:path";
 import { parseProviderPackageMetadata } from "@beignet/core/providers";
+import semver from "semver";
 import ts from "typescript";
 import {
   type ContractFactoryBindings,
@@ -10,6 +12,16 @@ import {
 } from "./analysis/contract-factories.js";
 import { canonicalFeatureLayerPath } from "./analysis/layers.js";
 import { analyzePortWiringFiles } from "./analysis/port-wiring.js";
+import {
+  analysisSourceFileExtensions,
+  isAnalysisSourceFile,
+  isAnalysisSourceFileExtension,
+  isJavaScriptSourceFile,
+  javascriptAnalysisSourceFileExtensions,
+  sourceFileScriptKind,
+  stripSourceFileExtension,
+  typescriptAnalysisSourceFileExtensions,
+} from "./analysis/source-files.js";
 import { exportedVariableDeclarations } from "./analysis/source-index.js";
 import { createPainter } from "./ansi.js";
 import type { DatabaseSchemaDialect, DatabaseSchemaTable } from "./choices.js";
@@ -86,6 +98,7 @@ import {
   legacyGeneratedPackageScripts,
 } from "./templates/shared.js";
 import { testSupportTemplateFiles } from "./templates/testing.js";
+import { isAppTestFile } from "./test-discovery.js";
 import { getCliVersion } from "./version.js";
 
 type InspectAppOptions = {
@@ -946,7 +959,7 @@ function parseContracts(source: string, file: string): ParsedContract[] {
     source,
     ts.ScriptTarget.Latest,
     true,
-    ts.ScriptKind.TS,
+    sourceFileScriptKind(file),
   );
   const assignments = variableAssignments(sourceFile);
   const assignmentsByName = new Map(
@@ -1556,6 +1569,7 @@ function normalizeContractPath(routePath: string): string {
 async function readRouteExports(
   targetDir: string,
   routeFiles: string[],
+  files: string[],
   config: ResolvedBeignetConfig,
 ): Promise<Map<string, RouteExport[]>> {
   const routeExports = new Map<string, RouteExport[]>();
@@ -1563,7 +1577,10 @@ async function readRouteExports(
   for (const file of routeFiles) {
     const routePath = nextRoutePath(file, config.paths.routes);
     const source = await readFile(path.join(targetDir, file), "utf8");
-    routeExports.set(file, parseRouteExports(source, file, routePath, config));
+    routeExports.set(
+      file,
+      parseRouteExports(source, file, routePath, files, config),
+    );
   }
 
   return routeExports;
@@ -1573,39 +1590,66 @@ function parseRouteExports(
   source: string,
   handlerFile: string,
   routePath: string,
+  files: string[],
   config: ResolvedBeignetConfig,
 ): RouteExport[] {
   const exports: RouteExport[] = [];
-  const imports = parseNamedImports(source, config);
-  const exportRegex =
-    /export const\s+(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s*=\s*([^;\n]+)/g;
-  const apiRouteExportRegex =
-    /export const\s*\{([^}]+)\}\s*=\s*createApiRoute\s*\(/g;
+  const sourceFile = ts.createSourceFile(
+    handlerFile,
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    sourceFileScriptKind(handlerFile),
+  );
+  const imports = parseRouteNamedImports(
+    sourceFile,
+    config,
+    handlerFile,
+    files,
+  );
 
-  for (const match of source.matchAll(apiRouteExportRegex)) {
-    for (const member of match[1].split(",")) {
-      const parts = member.split(":");
-      const method = (parts[1] ?? parts[0])?.trim();
-      if (!method || !isHttpMethod(method)) continue;
+  for (const statement of sourceFile.statements) {
+    if (
+      !ts.isVariableStatement(statement) ||
+      !statement.modifiers?.some(
+        (modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword,
+      )
+    ) {
+      continue;
+    }
 
-      exports.push({
-        method,
-        handlerFile,
-        contractRef: routePath,
-        catchAllPrefix: catchAllRoutePrefix(routePath),
-        source: "next-route",
-      });
+    for (const declaration of statement.declarationList.declarations) {
+      if (
+        !declaration.initializer ||
+        !ts.isObjectBindingPattern(declaration.name) ||
+        !isNamedRouteFactoryCall(declaration.initializer, "createApiRoute")
+      ) {
+        continue;
+      }
+
+      for (const element of declaration.name.elements) {
+        if (!ts.isIdentifier(element.name)) continue;
+        const method = element.name.text;
+        if (!isHttpMethod(method)) continue;
+        exports.push({
+          method,
+          handlerFile,
+          contractRef: routePath,
+          catchAllPrefix: catchAllRoutePrefix(routePath),
+          source: "next-route",
+        });
+      }
     }
   }
 
-  for (const match of source.matchAll(exportRegex)) {
-    const method = match[1] as HttpMethod;
-    const expression = match[2];
-    const contractMatch =
-      /server\.route\(\s*([A-Za-z_$][\w$]*)\s*\)\.handle/.exec(expression);
+  for (const { exportName, declaration } of exportedVariableDeclarations(
+    sourceFile,
+  )) {
+    if (!isHttpMethod(exportName) || !declaration.initializer) continue;
+    const method = exportName;
+    const localName = routeLocalContractIdentifier(declaration.initializer);
 
-    if (contractMatch) {
-      const localName = contractMatch[1];
+    if (localName) {
       const imported = imports.get(localName);
       exports.push({
         method,
@@ -1617,7 +1661,7 @@ function parseRouteExports(
       continue;
     }
 
-    if (/server\.api\b/.test(expression)) {
+    if (isServerApiExpression(declaration.initializer)) {
       exports.push({
         method,
         handlerFile,
@@ -1631,6 +1675,100 @@ function parseRouteExports(
   return exports;
 }
 
+function parseRouteNamedImports(
+  sourceFile: ts.SourceFile,
+  config: ResolvedBeignetConfig,
+  handlerFile: string,
+  files: string[],
+): Map<string, { importedName: string; contractFile?: string }> {
+  const imports = new Map<
+    string,
+    { importedName: string; contractFile?: string }
+  >();
+
+  for (const statement of sourceFile.statements) {
+    if (
+      !ts.isImportDeclaration(statement) ||
+      !ts.isStringLiteral(statement.moduleSpecifier) ||
+      statement.importClause?.isTypeOnly ||
+      !statement.importClause?.namedBindings ||
+      !ts.isNamedImports(statement.importClause.namedBindings)
+    ) {
+      continue;
+    }
+
+    const contractFile = contractFileFromImport(
+      statement.moduleSpecifier.text,
+      config,
+      handlerFile,
+      files,
+    );
+    for (const element of statement.importClause.namedBindings.elements) {
+      if (element.isTypeOnly) continue;
+      imports.set(element.name.text, {
+        importedName: element.propertyName?.text ?? element.name.text,
+        contractFile,
+      });
+    }
+  }
+
+  return imports;
+}
+
+function isNamedRouteFactoryCall(
+  expression: ts.Expression,
+  name: string,
+): boolean {
+  const unwrapped = unwrapContractExpression(expression);
+  if (!ts.isCallExpression(unwrapped)) return false;
+  const callee = unwrapContractExpression(unwrapped.expression);
+  return ts.isIdentifier(callee) && callee.text === name;
+}
+
+function routeLocalContractIdentifier(
+  expression: ts.Expression,
+): string | undefined {
+  const handleCall = unwrapContractExpression(expression);
+  if (!ts.isCallExpression(handleCall)) return undefined;
+  const handleAccess = unwrapContractExpression(handleCall.expression);
+  if (
+    !ts.isPropertyAccessExpression(handleAccess) ||
+    handleAccess.name.text !== "handle"
+  ) {
+    return undefined;
+  }
+
+  const routeCall = unwrapContractExpression(handleAccess.expression);
+  if (!ts.isCallExpression(routeCall)) return undefined;
+  const routeAccess = unwrapContractExpression(routeCall.expression);
+  if (
+    !ts.isPropertyAccessExpression(routeAccess) ||
+    routeAccess.name.text !== "route" ||
+    !ts.isIdentifier(routeAccess.expression) ||
+    routeAccess.expression.text !== "server"
+  ) {
+    return undefined;
+  }
+
+  const contract = routeCall.arguments[0];
+  const unwrappedContract = contract
+    ? unwrapContractExpression(contract)
+    : undefined;
+  return unwrappedContract && ts.isIdentifier(unwrappedContract)
+    ? unwrappedContract.text
+    : undefined;
+}
+
+function isServerApiExpression(expression: ts.Expression): boolean {
+  const unwrapped = unwrapContractExpression(expression);
+  return (
+    ts.isPropertyAccessExpression(unwrapped) &&
+    ts.isIdentifier(unwrapped.expression) &&
+    unwrapped.expression.text === "server" &&
+    unwrapped.name.text === "api"
+  );
+}
+
 function catchAllRoutePrefix(routePath: string): string | undefined {
   const segments = routePath.split("/").filter(Boolean);
   const catchAllIndex = segments.findIndex((segment) => segment.endsWith("*"));
@@ -1644,6 +1782,7 @@ function parseNamedImports(
   source: string,
   config: ResolvedBeignetConfig,
   importerFile?: string,
+  files?: string[],
 ): Map<
   string,
   {
@@ -1666,6 +1805,7 @@ function parseNamedImports(
       sourcePath,
       config,
       importerFile,
+      files,
     );
     for (const member of match[1].split(",")) {
       const parsed = parseImportMember(member);
@@ -1736,9 +1876,7 @@ function sourceFileFromImport(
   files?: string[],
 ): string | undefined {
   const resolveCandidate = (candidate: string) => {
-    if (path.extname(candidate)) return candidate;
-
-    const candidates = [`${candidate}.ts`, `${candidate}/index.ts`];
+    const candidates = sourceFileSpecifierCandidates(candidate, importerFile);
     return files
       ? candidates.find((file) => files.includes(file))
       : candidates[0];
@@ -1757,11 +1895,77 @@ function sourceFileFromImport(
   return undefined;
 }
 
+function sourceFileCandidates(base: string, importerFile?: string): string[] {
+  const extensions =
+    importerFile && isJavaScriptSourceFile(importerFile)
+      ? [
+          ...javascriptAnalysisSourceFileExtensions,
+          ...typescriptAnalysisSourceFileExtensions,
+        ]
+      : analysisSourceFileExtensions;
+  return [
+    ...extensions.map((extension) => `${base}${extension}`),
+    ...extensions.map((extension) => `${base}/index${extension}`),
+  ];
+}
+
+function sourceFileSpecifierCandidates(
+  candidate: string,
+  importerFile?: string,
+): string[] {
+  const extension = path.posix.extname(candidate).toLowerCase();
+  if (!extension) return sourceFileCandidates(candidate, importerFile);
+  if (!isAnalysisSourceFileExtension(extension)) return [candidate];
+
+  const sourceExtensions =
+    extension === ".js"
+      ? [".ts", ".tsx"]
+      : extension === ".jsx"
+        ? [".tsx"]
+        : extension === ".mjs"
+          ? [".mts"]
+          : extension === ".cjs"
+            ? [".cts"]
+            : [];
+  const sourceCandidates = sourceExtensions.map(
+    (sourceExtension) =>
+      `${candidate.slice(0, -extension.length)}${sourceExtension}`,
+  );
+  const directCandidates =
+    importerFile && isJavaScriptSourceFile(importerFile)
+      ? [candidate, ...sourceCandidates]
+      : [...sourceCandidates, candidate];
+  return [
+    ...new Set([
+      ...directCandidates,
+      ...directCandidates.map(directoryIndexSourceFile),
+    ]),
+  ];
+}
+
+function isSourceFileNamed(file: string, name: string): boolean {
+  return (
+    isAnalysisSourceFile(file) &&
+    path.posix.basename(stripSourceFileExtension(file)) === name
+  );
+}
+
+function directoryIndexSourceFile(file: string): string {
+  const extension = path.posix.extname(file);
+  return `${stripSourceFileExtension(file)}/index${extension}`;
+}
+
 function contractFileFromImport(
   sourcePath: string,
   config: ResolvedBeignetConfig,
   importerFile?: string,
+  files?: string[],
 ): string | undefined {
+  const resolveCandidate = (candidate: string) => {
+    const candidates = sourceFileSpecifierCandidates(candidate, importerFile);
+    if (!files) return candidates[0];
+    return candidates.find((file) => files.includes(file)) ?? candidates[0];
+  };
   const contractsPath = directoryPath(config.paths.contracts);
   const aliasPrefix = `@/${contractsPath}/`;
   const aliasExact = `@/${contractsPath}`;
@@ -1769,21 +1973,21 @@ function contractFileFromImport(
   const relativeExact = contractsPath;
 
   if (sourcePath === aliasExact || sourcePath === relativeExact) {
-    return `${contractsPath}/index.ts`;
+    return resolveCandidate(`${contractsPath}/index`);
   }
   if (sourcePath.startsWith(aliasPrefix)) {
-    return `${sourcePath.slice("@/".length)}.ts`;
+    return resolveCandidate(sourcePath.slice("@/".length));
   }
 
   if (sourcePath.startsWith(relativePrefix)) {
-    return `${sourcePath}.ts`;
+    return resolveCandidate(sourcePath);
   }
 
   if (importerFile && sourcePath.startsWith(".")) {
     const resolved = normalizePath(
       path.join(path.dirname(importerFile), sourcePath),
     );
-    return `${resolved}.ts`;
+    return resolveCandidate(resolved);
   }
 
   return undefined;
@@ -1866,9 +2070,14 @@ async function inspectRouteSurface(
     const routeFiles = files.filter(
       (file) =>
         file.startsWith(`${directoryPath(config.paths.routes)}/`) &&
-        file.endsWith("/route.ts"),
+        isNextRouteFile(file, config),
+    );
+    const routeExports = await readRouteExports(
+      targetDir,
+      routeFiles,
+      files,
+      config,
     );
-    const routeExports = await readRouteExports(targetDir, routeFiles, config);
     return matchRoutes(contracts, routeExports);
   }
 
@@ -1940,8 +2149,7 @@ function findContracts(
         contract.exportName === routeExport.contractRef &&
         (!routeExport.contractFile ||
           contract.file === routeExport.contractFile ||
-          contract.file ===
-            routeExport.contractFile.replace(/\.ts$/, "/index.ts")),
+          contract.file === directoryIndexSourceFile(routeExport.contractFile)),
     );
     return contract ? [contract] : [];
   }
@@ -2385,7 +2593,12 @@ async function inspectCanonicalConformance(
 
   const featureRoutesPath = `${featuresPath}/`;
   for (const file of files) {
-    if (!file.startsWith(featureRoutesPath) || !file.endsWith("/routes.ts")) {
+    if (
+      !file.startsWith(featureRoutesPath) ||
+      !isAnalysisSourceFile(file) ||
+      isAppTestFile(file) ||
+      !stripSourceFileExtension(file).endsWith("/routes")
+    ) {
       continue;
     }
 
@@ -2774,7 +2987,7 @@ async function inspectProductionReadiness(
   let hasSecurityHeadersHook = false;
 
   for (const file of files) {
-    if (!file.endsWith(".ts") || file.endsWith(".test.ts")) continue;
+    if (!isAnalysisSourceFile(file) || isAppTestFile(file)) continue;
 
     const source = await readCachedSource(targetDir, file, sourceCache);
     const routeServerOrInfra = isRouteServerOrInfraFile(file, config);
@@ -2801,7 +3014,7 @@ async function inspectProductionReadiness(
 
     if (
       fileWithinDirectory(file, cronDirectory) &&
-      file.endsWith("/route.ts") &&
+      isNextRouteFile(file, config) &&
       !/\bCRON_SECRET\b/.test(source) &&
       !/\bcreateOutboxDrainRoute\s*\(/.test(source) &&
       !/\bcreateScheduleRoute\s*\(/.test(source)
@@ -3103,6 +3316,25 @@ async function inspectProductionReadiness(
           "@beignet/provider-auth-better-auth is installed, but BETTER_AUTH_TRUSTED_ORIGINS is not mentioned in app env/config files. Add it before deploying across multiple origins or document why the app is single-origin only.",
       });
     }
+
+    if (
+      (await betterAuthRequiresIssuerSchema(targetDir, packageJson)) &&
+      (await anyFileContains(
+        targetDir,
+        configFiles,
+        "drizzleAdapter",
+        sourceCache,
+      )) &&
+      !(await hasBetterAuthIssuerSchema(targetDir, files, sourceCache))
+    ) {
+      diagnostics.push({
+        severity: "warning",
+        code: "BEIGNET_BETTER_AUTH_ISSUER_SCHEMA_MISSING",
+        file: schemaDir,
+        message:
+          "This app uses Better Auth 1.7 or a version range that can install it with the Drizzle adapter, but its account schema does not include the required issuer field and unique (issuer, accountId) index. Complete the provider-specific account identity backfill, run bunx auth generate, and apply the reviewed migration before deploying Better Auth 1.7.",
+      });
+    }
   }
 
   const installedReadinessProviders = [...installedPackages].filter(
@@ -3148,7 +3380,7 @@ async function uploadHasExplicitSizeLimit(
     );
     if (!importedName) continue;
 
-    const importedFile = resolveLocalTypeScriptModule(file, moduleName, files);
+    const importedFile = sourceFileFromImport(moduleName, file, files);
     if (!importedFile) continue;
 
     const importedSource = await readCachedSource(
@@ -3203,20 +3435,6 @@ function exportedObjectHasProperty(
   return new RegExp(`\\b${escapeRegExp(propertyName)}\\s*:`).test(initializer);
 }
 
-function resolveLocalTypeScriptModule(
-  importer: string,
-  moduleName: string,
-  files: string[],
-): string | undefined {
-  const base = normalizePath(
-    path.posix.normalize(
-      path.posix.join(path.posix.dirname(importer), moduleName),
-    ),
-  );
-  const candidates = [base, `${base}.ts`, `${base}.tsx`, `${base}/index.ts`];
-  return candidates.find((candidate) => files.includes(candidate));
-}
-
 async function hasReadinessCheck(
   targetDir: string,
   files: string[],
@@ -3224,10 +3442,18 @@ async function hasReadinessCheck(
   sourceCache: Map<string, string>,
 ): Promise<boolean> {
   const routesDir = directoryPath(config.paths.routes);
-  if (files.includes(`${routesDir}/ready/route.ts`)) return true;
+  if (
+    files.some(
+      (file) =>
+        path.posix.dirname(file) === `${routesDir}/ready` &&
+        isNextRouteFile(file, config),
+    )
+  ) {
+    return true;
+  }
 
   for (const file of files) {
-    if (!file.endsWith(".ts") || file.endsWith(".test.ts")) continue;
+    if (!isAnalysisSourceFile(file) || isAppTestFile(file)) continue;
     if (!isRouteServerOrInfraFile(file, config)) continue;
 
     const source = await readCachedSource(targetDir, file, sourceCache);
@@ -3769,10 +3995,11 @@ function isFeatureUploadDefinition(
   file: string,
   config: ResolvedBeignetConfig,
 ): boolean {
-  const featuresPath = directoryPath(config.paths.features);
-  return new RegExp(
-    `^${escapeRegExp(featuresPath)}/[^/]+/uploads/[^/]+\\.ts$`,
-  ).test(file);
+  return isFeatureArtifactFile(
+    file,
+    directoryPath(config.paths.features),
+    "uploads",
+  );
 }
 
 function operationalConfigFiles(
@@ -3782,17 +4009,263 @@ function operationalConfigFiles(
   return providerOperationalConfigFiles(files, config);
 }
 
-async function readPackageJson(
+type InspectedPackageJson = {
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+};
+
+function declaredBetterAuthMayRequireIssuerSchema(
+  packageJson: InspectedPackageJson | undefined,
+): boolean {
+  const version =
+    packageJson?.dependencies?.["better-auth"] ??
+    packageJson?.devDependencies?.["better-auth"] ??
+    packageJson?.peerDependencies?.["better-auth"];
+  if (!version) return false;
+
+  const normalized = version.trim();
+  const workspaceRange = normalized.startsWith("workspace:")
+    ? normalized.slice("workspace:".length)
+    : normalized;
+  const npmAlias = /^npm:better-auth@(.+)$/.exec(workspaceRange);
+  const candidate = npmAlias?.[1] ?? workspaceRange;
+  const range = semver.validRange(candidate);
+
+  // Tags, catalogs, local paths, and other non-semver declarations can resolve
+  // to 1.7. Prefer a migration warning until an installed version is readable.
+  if (!range) return true;
+
+  return semver.intersects(range, ">=1.7.0");
+}
+
+async function betterAuthRequiresIssuerSchema(
+  targetDir: string,
+  packageJson: InspectedPackageJson | undefined,
+): Promise<boolean> {
+  const installed = await readInstalledBetterAuthPackageJson(targetDir);
+  if (installed?.version) {
+    const version = semver.valid(installed.version.trim());
+    if (version) return semver.gte(version, "1.7.0");
+  }
+
+  return declaredBetterAuthMayRequireIssuerSchema(packageJson);
+}
+
+async function readInstalledBetterAuthPackageJson(
+  targetDir: string,
+): Promise<{ name?: string; version?: string } | undefined> {
+  const nodeModulesPackage =
+    await readBetterAuthPackageFromNodeModules(targetDir);
+  if (nodeModulesPackage) return nodeModulesPackage;
+
+  const requireFromTarget = createRequire(path.join(targetDir, "package.json"));
+  const packageJsonPath = resolveModuleFromTarget(
+    requireFromTarget,
+    "better-auth/package.json",
+  );
+  if (packageJsonPath) {
+    return readJsonIfExists(packageJsonPath);
+  }
+
+  const entryPath = resolveModuleFromTarget(requireFromTarget, "better-auth");
+  if (!entryPath) return undefined;
+
+  let directory = path.dirname(entryPath);
+  while (true) {
+    const candidate = await readJsonIfExists<{
+      name?: string;
+      version?: string;
+    }>(path.join(directory, "package.json"));
+    if (candidate?.name === "better-auth") return candidate;
+
+    const parent = path.dirname(directory);
+    if (parent === directory) return undefined;
+    directory = parent;
+  }
+}
+
+async function readBetterAuthPackageFromNodeModules(
+  targetDir: string,
+): Promise<{ name?: string; version?: string } | undefined> {
+  let directory = targetDir;
+  while (true) {
+    const candidate = await readJsonIfExists<{
+      name?: string;
+      version?: string;
+    }>(path.join(directory, "node_modules", "better-auth", "package.json"));
+    if (candidate?.name === "better-auth") return candidate;
+
+    const parent = path.dirname(directory);
+    if (parent === directory) return undefined;
+    directory = parent;
+  }
+}
+
+function resolveModuleFromTarget(
+  requireFromTarget: ReturnType<typeof createRequire>,
+  request: string,
+): string | undefined {
+  try {
+    return requireFromTarget.resolve(request);
+  } catch {
+    return undefined;
+  }
+}
+
+async function hasBetterAuthIssuerSchema(
   targetDir: string,
   files: string[],
-): Promise<
-  | {
-      dependencies?: Record<string, string>;
-      devDependencies?: Record<string, string>;
-      peerDependencies?: Record<string, string>;
+  sourceCache: Map<string, string>,
+): Promise<boolean> {
+  const schemaFiles = files.filter(
+    (file) =>
+      !isTestSourceFile(file) &&
+      /\.(?:ts|tsx|js|jsx|mts|mjs|cts|cjs)$/.test(file),
+  );
+
+  for (const file of schemaFiles) {
+    const source = await readCachedSource(targetDir, file, sourceCache);
+    if (sourceHasBetterAuthIssuerSchema(file, source)) return true;
+  }
+
+  return false;
+}
+
+function sourceHasBetterAuthIssuerSchema(
+  file: string,
+  source: string,
+): boolean {
+  const sourceFile = ts.createSourceFile(
+    file,
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+  );
+  let found = false;
+  const visit = (node: ts.Node): void => {
+    if (found) return;
+    if (
+      ts.isCallExpression(node) &&
+      isBetterAuthAccountTableCall(node) &&
+      betterAuthAccountTableHasIssuerIdentity(node)
+    ) {
+      found = true;
+      return;
     }
-  | undefined
-> {
+    ts.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return found;
+}
+
+function isBetterAuthAccountTableCall(call: ts.CallExpression): boolean {
+  const callee = unwrapContractExpression(call.expression);
+  const factoryName = ts.isIdentifier(callee)
+    ? callee.text
+    : ts.isPropertyAccessExpression(callee)
+      ? callee.name.text
+      : undefined;
+  return (
+    factoryName !== undefined &&
+    ["mysqlTable", "pgTable", "sqliteTable"].includes(factoryName) &&
+    staticString(call.arguments[0]) === "account"
+  );
+}
+
+function betterAuthAccountTableHasIssuerIdentity(
+  call: ts.CallExpression,
+): boolean {
+  const columns = call.arguments[1];
+  if (!columns || !ts.isObjectLiteralExpression(columns)) return false;
+  const issuer = columns.properties.find(
+    (property) =>
+      ts.isPropertyAssignment(property) &&
+      staticPropertyName(property.name) === "issuer",
+  );
+  if (!issuer || !ts.isPropertyAssignment(issuer)) return false;
+  if (!isBetterAuthIssuerColumn(issuer.initializer)) return false;
+
+  const constraints = call.arguments[2];
+  if (
+    !constraints ||
+    (!ts.isArrowFunction(constraints) &&
+      !ts.isFunctionExpression(constraints)) ||
+    constraints.parameters.length === 0 ||
+    !ts.isIdentifier(constraints.parameters[0]?.name)
+  ) {
+    return false;
+  }
+
+  const tableName = constraints.parameters[0].name.text;
+  let found = false;
+  const visit = (node: ts.Node): void => {
+    if (found) return;
+    if (
+      ts.isCallExpression(node) &&
+      isBetterAuthIssuerAccountUniqueConstraint(node, tableName)
+    ) {
+      found = true;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(constraints.body);
+  return found;
+}
+
+function isBetterAuthIssuerColumn(expression: ts.Expression): boolean {
+  let current = unwrapContractExpression(expression);
+  while (ts.isCallExpression(current)) {
+    const callee = unwrapContractExpression(current.expression);
+    if (
+      ts.isIdentifier(callee) &&
+      ["text", "varchar"].includes(callee.text) &&
+      staticString(current.arguments[0]) === "issuer"
+    ) {
+      return true;
+    }
+    if (!ts.isPropertyAccessExpression(callee)) return false;
+    current = unwrapContractExpression(callee.expression);
+  }
+  return false;
+}
+
+function isBetterAuthIssuerAccountUniqueConstraint(
+  call: ts.CallExpression,
+  tableName: string,
+): boolean {
+  const callee = unwrapContractExpression(call.expression);
+  if (!ts.isPropertyAccessExpression(callee) || callee.name.text !== "on") {
+    return false;
+  }
+
+  const factoryCall = unwrapContractExpression(callee.expression);
+  if (!ts.isCallExpression(factoryCall)) return false;
+  const factory = unwrapContractExpression(factoryCall.expression);
+  if (
+    !ts.isIdentifier(factory) ||
+    !["unique", "uniqueIndex"].includes(factory.text)
+  ) {
+    return false;
+  }
+
+  if (call.arguments.length !== 2) return false;
+  const columnNames = call.arguments.map((argument) => {
+    const column = unwrapContractExpression(argument);
+    return ts.isPropertyAccessExpression(column) &&
+      ts.isIdentifier(column.expression) &&
+      column.expression.text === tableName
+      ? column.name.text
+      : undefined;
+  });
+  return columnNames.includes("issuer") && columnNames.includes("accountId");
+}
+
+async function readPackageJson(
+  targetDir: string,
+  files: string[],
+): Promise<InspectedPackageJson | undefined> {
   if (!files.includes("package.json")) return undefined;
 
   return JSON.parse(
@@ -3953,7 +4426,7 @@ async function hasBillingEntitlementsProviderWiring(
   const serverPath = path.dirname(config.paths.server);
   const candidateFiles = files.filter(
     (file) =>
-      /\.(?:ts|tsx|mts|cts)$/.test(file) &&
+      isAnalysisSourceFile(file) &&
       !isTestSourceFile(file) &&
       (file.startsWith(`${infraPath}/`) || file.startsWith(`${serverPath}/`)),
   );
@@ -3969,10 +4442,7 @@ async function hasBillingEntitlementsProviderWiring(
 }
 
 function isTestSourceFile(file: string): boolean {
-  return (
-    /(?:^|\/)tests\//.test(file) ||
-    /\.(?:test|spec)\.(?:ts|tsx|mts|cts)$/.test(file)
-  );
+  return /(?:^|\/)tests\//.test(file) || isAppTestFile(file);
 }
 
 function exportedConstInitializer(
@@ -3999,8 +4469,8 @@ function featureNameFromContractFile(
 ): string | undefined {
   const featuresPath = directoryPath(config.paths.features);
   const match = new RegExp(
-    `^${escapeRegExp(featuresPath)}/([^/]+)/contracts\\.ts$`,
-  ).exec(file);
+    `^${escapeRegExp(featuresPath)}/([^/]+)/contracts$`,
+  ).exec(stripSourceFileExtension(file));
   return match?.[1];
 }
 
@@ -4017,7 +4487,7 @@ function featureRuntimeFiles(
     "use-cases",
   ];
   return files.filter((file) => {
-    if (!file.endsWith(".ts") || file.endsWith(".test.ts")) return false;
+    if (!isAnalysisSourceFile(file) || isAppTestFile(file)) return false;
     return runtimeFolders.some((folder) =>
       file.startsWith(`${featuresPath}/${feature}/${folder}/`),
     );
@@ -4033,11 +4503,16 @@ function featureTestFiles(
   return files.filter((file) => {
     if (
       !file.startsWith(`${featuresPath}/${feature}/`) ||
-      !file.endsWith(".test.ts")
+      !isAppTestFile(file)
     ) {
       return false;
     }
-    return !options.policyOnly || file.endsWith("/policy.test.ts");
+    return (
+      !options.policyOnly ||
+      ["policy.test", "policy.spec"].includes(
+        path.posix.basename(stripSourceFileExtension(file)),
+      )
+    );
   });
 }
 
@@ -4204,17 +4679,12 @@ async function inspectFeatureArtifactDrift(
       severity: "warning",
       code: "BEIGNET_FEATURE_TEST_PLACEMENT",
       file,
-      message: `${file} places a test directly under ${featuresPath}/${match[1]}/. Move feature behavior tests into ${featuresPath}/${match[1]}/tests/ so feature suites stay in the canonical folder; adjacent *.test.ts files are for infra and server modules.`,
+      message: `${file} places a test directly under ${featuresPath}/${match[1]}/. Move feature behavior tests into ${featuresPath}/${match[1]}/tests/ so feature suites stay in the canonical folder; adjacent test files are for infra and server modules.`,
     });
   }
 
   for (const file of files) {
-    if (
-      !/\.(?:ts|tsx|mts|cts)$/.test(file) ||
-      /\.d\.(?:ts|mts|cts)$/.test(file)
-    ) {
-      continue;
-    }
+    if (!isAnalysisSourceFile(file)) continue;
 
     const misplaced = directFeatureTestMatch(file, featuresPath)
       ? undefined
@@ -4229,7 +4699,6 @@ async function inspectFeatureArtifactDrift(
     }
 
     if (isTestSourceFile(file)) continue;
-    if (!file.endsWith(".ts")) continue;
 
     if (
       isNotificationDefinitionFile(file, featuresPath) ||
@@ -4255,9 +4724,10 @@ function directFeatureTestMatch(
   file: string,
   featuresPath: string,
 ): RegExpExecArray | null {
+  if (!isAppTestFile(file)) return null;
   return new RegExp(
-    `^${escapeRegExp(featuresPath)}/([^/]+)/[^/]+\\.(?:test|spec)\\.(?:ts|tsx|mts|cts)$`,
-  ).exec(file);
+    `^${escapeRegExp(featuresPath)}/([^/]+)/[^/]+\\.(?:test|spec)$`,
+  ).exec(stripSourceFileExtension(file));
 }
 
 function isFeatureArtifactFile(
@@ -4265,9 +4735,10 @@ function isFeatureArtifactFile(
   featuresPath: string,
   folder: "uploads" | "notifications",
 ): boolean {
+  if (!isAnalysisSourceFile(file) || isAppTestFile(file)) return false;
   const match = new RegExp(
-    `^${escapeRegExp(featuresPath)}/[^/]+/${folder}/([^/]+)\\.ts$`,
-  ).exec(file);
+    `^${escapeRegExp(featuresPath)}/[^/]+/${folder}/([^/]+)$`,
+  ).exec(stripSourceFileExtension(file));
   return Boolean(match && match[1] !== "index");
 }
 
@@ -4277,7 +4748,7 @@ async function appHasUploadRoute(
   config: ResolvedBeignetConfig,
 ): Promise<boolean> {
   for (const file of files) {
-    if (!file.endsWith(".ts") || file.endsWith(".test.ts")) continue;
+    if (!isAnalysisSourceFile(file) || isAppTestFile(file)) continue;
     if (!isRouteServerOrInfraFile(file, config)) continue;
 
     const source = await readFile(path.join(targetDir, file), "utf8");
@@ -4831,11 +5302,17 @@ async function readFeatureWorkflowRegistries(
   for (const kind of kinds) {
     const folder = kind === "events" ? "domain/events" : kind;
     const pattern = new RegExp(
-      `^${escapeRegExp(featuresPath)}/[^/]+/${escapeRegExp(folder)}/index\\.ts$`,
+      `^${escapeRegExp(featuresPath)}/[^/]+/${escapeRegExp(folder)}/index$`,
     );
 
     for (const file of files) {
-      if (!pattern.test(file)) continue;
+      if (
+        !isAnalysisSourceFile(file) ||
+        isWorkflowTestFile(file) ||
+        !pattern.test(stripSourceFileExtension(file))
+      ) {
+        continue;
+      }
 
       const source = await readFile(path.join(targetDir, file), "utf8");
       const memberFiles = exportedMemberFiles(source, file, files);
@@ -4895,8 +5372,7 @@ async function readRuntimeManifestIdentifiers(
   const manifests: RuntimeManifestIdentifierSets[] = [];
 
   for (const file of files) {
-    if (!file.endsWith(".ts") && !file.endsWith(".tsx")) continue;
-    if (file.endsWith(".d.ts") || isWorkflowTestFile(file)) continue;
+    if (!isAnalysisSourceFile(file) || isWorkflowTestFile(file)) continue;
 
     const source = await readFile(path.join(targetDir, file), "utf8");
     if (!source.includes("defineRuntimeManifest")) continue;
@@ -5033,12 +5509,18 @@ async function listenedEventNames(
 ): Promise<Set<string>> {
   const featuresPath = directoryPath(config.paths.features);
   const listenerPattern = new RegExp(
-    `^${escapeRegExp(featuresPath)}/[^/]+/listeners/[^/]+\\.ts$`,
+    `^${escapeRegExp(featuresPath)}/[^/]+/listeners/[^/]+$`,
   );
   const listened = new Set<string>();
 
   for (const file of files) {
-    if (!listenerPattern.test(file) || isWorkflowTestFile(file)) continue;
+    if (
+      !isAnalysisSourceFile(file) ||
+      isWorkflowTestFile(file) ||
+      !listenerPattern.test(stripSourceFileExtension(file))
+    ) {
+      continue;
+    }
 
     const source = await readFile(path.join(targetDir, file), "utf8");
     const callPattern = /\bdefineListener\s*\(/g;
@@ -5087,8 +5569,7 @@ async function listenerWiringReferences(
   const listenerRegistryFile = listenersFilePath(config);
 
   for (const file of files) {
-    if (!file.endsWith(".ts") && !file.endsWith(".tsx")) continue;
-    if (file.endsWith(".d.ts") || isWorkflowTestFile(file)) continue;
+    if (!isAnalysisSourceFile(file) || isWorkflowTestFile(file)) continue;
 
     const source = await readFile(path.join(targetDir, file), "utf8");
     const namedImports = parseNamedImportSources(source);
@@ -5097,7 +5578,7 @@ async function listenerWiringReferences(
       source,
       ts.ScriptTarget.Latest,
       true,
-      file.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
+      sourceFileScriptKind(file),
     );
     const registerListenersBindings = importedRegisterListenersBindings(
       source,
@@ -5557,10 +6038,7 @@ function callReferencesCentralListenerRegistry(args: {
 
 function isWorkflowTestFile(file: string): boolean {
   return (
-    file.endsWith(".test.ts") ||
-    file.endsWith(".test.tsx") ||
-    file.startsWith("tests/") ||
-    file.includes("/tests/")
+    isAppTestFile(file) || file.startsWith("tests/") || file.includes("/tests/")
   );
 }
 
@@ -5575,13 +6053,7 @@ async function inspectServerlessFootguns(
   const cronDirectory = path.posix.join(routeDirectory, "cron");
 
   for (const file of files) {
-    if (
-      !file.endsWith(".ts") ||
-      file.endsWith(".test.ts") ||
-      file.endsWith(".d.ts")
-    ) {
-      continue;
-    }
+    if (!isAnalysisSourceFile(file) || isAppTestFile(file)) continue;
 
     const source = await readFile(path.join(targetDir, file), "utf8");
     const isInfraOrServerFile = isRuntimeFile(file, config);
@@ -5727,9 +6199,10 @@ function fileWithinDirectory(file: string, directory: string): boolean {
 }
 
 function isProviderLifecycleFile(file: string, source?: string): boolean {
+  const sourcePath = stripSourceFileExtension(file);
   return (
-    /(^|\/)provider(s)?\.ts$/.test(file) ||
-    /(^|\/)[^/]*provider[^/]*\.ts$/.test(file) ||
+    /(^|\/)provider(s)?$/.test(sourcePath) ||
+    /(^|\/)[^/]*provider[^/]*$/.test(sourcePath) ||
     /(^|\/)providers?\//.test(file) ||
     (source !== undefined && containsCallExpression(source, "createProvider"))
   );
@@ -5740,8 +6213,9 @@ function isNextRouteFile(file: string, config: ResolvedBeignetConfig): boolean {
 
   return (
     file.startsWith(`${routesPath}/`) &&
-    file.endsWith("/route.ts") &&
-    !file.endsWith(".test.ts")
+    isSourceFileNamed(file, "route") &&
+    [".js", ".jsx", ".ts", ".tsx"].includes(path.posix.extname(file)) &&
+    !isAppTestFile(file)
   );
 }
 
@@ -7676,7 +8150,13 @@ async function inspectFeatureRouteRegistration(
     const feature = featureNameFromContractFile(contract.file, config);
     if (!feature) continue;
 
-    const routeFile = `${featuresPath}/${feature}/routes.ts`;
+    const routeStem = `${featuresPath}/${feature}/routes`;
+    const routeFile =
+      files.find(
+        (file) =>
+          isAnalysisSourceFile(file) &&
+          stripSourceFileExtension(file) === routeStem,
+      ) ?? `${routeStem}${path.posix.extname(contract.file) || ".ts"}`;
     const featureRouteGroups = routeGroups.filter(
       (routeGroup) => routeGroup.file === routeFile,
     );
@@ -7766,13 +8246,14 @@ async function readFeatureRouteGroups(
 ): Promise<FeatureRouteGroup[]> {
   const featuresPath = `${directoryPath(config.paths.features)}/`;
   const routeFiles = files.filter(
-    (file) => file.startsWith(featuresPath) && file.endsWith("/routes.ts"),
+    (file) =>
+      file.startsWith(featuresPath) && isSourceFileNamed(file, "routes"),
   );
   const routeGroups: FeatureRouteGroup[] = [];
 
   for (const file of routeFiles) {
     const source = await readFile(path.join(targetDir, file), "utf8");
-    const imports = parseNamedImports(source, config, file);
+    const imports = parseNamedImports(source, config, file, files);
     routeGroups.push(...parseFeatureRouteGroups(source, file, imports));
   }
 
@@ -7935,8 +8416,7 @@ function findRouteGroupContract(
       contract.exportName === routeGroupContract.exportName &&
       (!routeGroupContract.file ||
         contract.file === routeGroupContract.file ||
-        contract.file ===
-          routeGroupContract.file.replace(/\.ts$/, "/index.ts")),
+        contract.file === directoryIndexSourceFile(routeGroupContract.file)),
   );
 }
 
@@ -9313,7 +9793,7 @@ async function readContractLists(
 
   for (const file of contractFiles) {
     const source = await readFile(path.join(targetDir, file), "utf8");
-    const imports = parseNamedImports(source, config, file);
+    const imports = parseNamedImports(source, config, file, files);
     for (const list of parseContractLists(source, file, imports)) {
       lists.set(contractListKey(list.file, list.name), list);
     }
@@ -9330,18 +9810,18 @@ function contractSourceFiles(
   if (usesFeatureOwnedContracts(config)) {
     return files.filter(
       (file) =>
-        new RegExp(
-          `^${escapeRegExp(contractsPath)}/[^/]+/contracts\\.ts$`,
-        ).test(file) && !file.endsWith(".test.ts"),
+        isAnalysisSourceFile(file) &&
+        !isAppTestFile(file) &&
+        new RegExp(`^${escapeRegExp(contractsPath)}/[^/]+/contracts$`).test(
+          stripSourceFileExtension(file),
+        ),
     );
   }
 
-  return files.filter(
-    (file) =>
-      file.startsWith(`${contractsPath}/`) &&
-      file.endsWith(".ts") &&
-      !file.endsWith(".test.ts"),
-  );
+  return files.filter((file) => {
+    if (!isAnalysisSourceFile(file) || isAppTestFile(file)) return false;
+    return stripSourceFileExtension(file).startsWith(`${contractsPath}/`);
+  });
 }
 
 function contractListSourceFiles(
@@ -9351,22 +9831,23 @@ function contractListSourceFiles(
   const contractsPath = directoryPath(config.paths.contracts);
   if (usesFeatureOwnedContracts(config)) {
     return files.filter((file) => {
-      if (!file.endsWith(".ts") || file.endsWith(".test.ts")) return false;
-      if (file === `${contractsPath}/index.ts`) return true;
-      if (file === `${contractsPath}/contracts.ts`) return true;
+      if (!isAnalysisSourceFile(file) || isAppTestFile(file)) return false;
+      const sourcePath = stripSourceFileExtension(file);
+      if (sourcePath === `${contractsPath}/index`) return true;
+      if (sourcePath === `${contractsPath}/contracts`) return true;
       return new RegExp(
-        `^${escapeRegExp(contractsPath)}/[^/]+/contracts\\.ts$`,
-      ).test(file);
+        `^${escapeRegExp(contractsPath)}/[^/]+/contracts$`,
+      ).test(sourcePath);
     });
   }
 
-  return files.filter(
-    (file) =>
-      (file === `${contractsPath}.ts` ||
-        file.startsWith(`${contractsPath}/`)) &&
-      file.endsWith(".ts") &&
-      !file.endsWith(".test.ts"),
-  );
+  return files.filter((file) => {
+    if (!isAnalysisSourceFile(file) || isAppTestFile(file)) return false;
+    const sourcePath = stripSourceFileExtension(file);
+    return (
+      sourcePath === contractsPath || sourcePath.startsWith(`${contractsPath}/`)
+    );
+  });
 }
 
 function parseContractLists(
@@ -9420,7 +9901,7 @@ function resolveContractList(
   if (seen.has(key)) return new Set();
   const list =
     lists.get(key) ??
-    lists.get(contractListKey(file.replace(/\.ts$/, "/index.ts"), name));
+    lists.get(contractListKey(directoryIndexSourceFile(file), name));
   if (!list) return undefined;
 
   seen.add(key);
@@ -10010,7 +10491,7 @@ function nextRoutePath(file: string, routeRoot: string): string {
   const normalizedRouteRoot = directoryPath(routeRoot);
   const routeSegments = file
     .slice(normalizedRouteRoot.length + 1)
-    .replace(/\/route\.ts$/, "")
+    .replace(/\/route\.(?:js|jsx|ts|tsx)$/, "")
     .split("/")
     .filter(Boolean);
   const apiPath = routeSegments.map(nextSegmentToContractSegment).join("/");