@beignet/cli 0.0.50 → 0.0.52

package/dist/inspect.js

@@ -1,10 +1,13 @@
 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 { contractFactoryBindings, isImportedContractFactoryCall, } 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 { clientDirPath, clientFormsPath, clientIndexPath, defaultBeignetConfig, directoryPath, loadBeignetConfig, normalizePath, resolveConfig, } from "./config.js";
@@ -16,6 +19,7 @@ import { detectedProviderVariants, diagnosticPackageJsonFile, formatProviderEnvA
 import { appendToArrayExpression, appendToNamedArray, appendToOutboxRegistryArray, arrayInitializerInfo, codeCharacterIndexes, identifiersFromArrayExpression, insertAfterImports, matchingDelimiterIndex, outboxRegistryEntryState, outboxRegistryIdentifiers, } from "./registry-edits.js";
 import { currentGeneratedPackageScripts, externalVersions, isLegacyGeneratedPackageScript, legacyGeneratedPackageScripts, } from "./templates/shared.js";
 import { testSupportTemplateFiles } from "./templates/testing.js";
+import { isAppTestFile } from "./test-discovery.js";
 import { getCliVersion } from "./version.js";
 export async function inspectApp(options = {}) {
     const targetDir = path.resolve(options.cwd ?? process.cwd());
@@ -485,7 +489,7 @@ function hasRequirement(files, requirement) {
 }
 function parseContracts(source, file) {
     const contracts = [];
-    const sourceFile = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const sourceFile = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true, sourceFileScriptKind(file));
     const assignments = variableAssignments(sourceFile);
     const assignmentsByName = new Map(assignments.map((assignment) => [assignment.name, assignment.expression]));
     const factoryBindings = contractFactoryBindings(sourceFile);
@@ -926,41 +930,52 @@ function normalizeContractPath(routePath) {
     const segments = routePath.split("/").filter(Boolean);
     return segments.length === 0 ? "/" : `/${segments.join("/")}`;
 }
-async function readRouteExports(targetDir, routeFiles, config) {
+async function readRouteExports(targetDir, routeFiles, files, config) {
     const routeExports = new Map();
     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;
 }
-function parseRouteExports(source, handlerFile, routePath, config) {
+function parseRouteExports(source, handlerFile, routePath, files, config) {
     const exports = [];
-    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;
-    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))
+    const sourceFile = ts.createSourceFile(handlerFile, source, ts.ScriptTarget.Latest, true, sourceFileScriptKind(handlerFile));
+    const imports = parseRouteNamedImports(sourceFile, config, handlerFile, files);
+    for (const statement of sourceFile.statements) {
+        if (!ts.isVariableStatement(statement) ||
+            !statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
+            continue;
+        }
+        for (const declaration of statement.declarationList.declarations) {
+            if (!declaration.initializer ||
+                !ts.isObjectBindingPattern(declaration.name) ||
+                !isNamedRouteFactoryCall(declaration.initializer, "createApiRoute")) {
                 continue;
-            exports.push({
-                method,
-                handlerFile,
-                contractRef: routePath,
-                catchAllPrefix: catchAllRoutePrefix(routePath),
-                source: "next-route",
-            });
+            }
+            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];
-        const expression = match[2];
-        const contractMatch = /server\.route\(\s*([A-Za-z_$][\w$]*)\s*\)\.handle/.exec(expression);
-        if (contractMatch) {
-            const localName = contractMatch[1];
+    for (const { exportName, declaration } of exportedVariableDeclarations(sourceFile)) {
+        if (!isHttpMethod(exportName) || !declaration.initializer)
+            continue;
+        const method = exportName;
+        const localName = routeLocalContractIdentifier(declaration.initializer);
+        if (localName) {
             const imported = imports.get(localName);
             exports.push({
                 method,
@@ -971,7 +986,7 @@ function parseRouteExports(source, handlerFile, routePath, config) {
             });
             continue;
         }
-        if (/server\.api\b/.test(expression)) {
+        if (isServerApiExpression(declaration.initializer)) {
             exports.push({
                 method,
                 handlerFile,
@@ -983,6 +998,69 @@ function parseRouteExports(source, handlerFile, routePath, config) {
     }
     return exports;
 }
+function parseRouteNamedImports(sourceFile, config, handlerFile, files) {
+    const imports = new Map();
+    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, name) {
+    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) {
+    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) {
+    const unwrapped = unwrapContractExpression(expression);
+    return (ts.isPropertyAccessExpression(unwrapped) &&
+        ts.isIdentifier(unwrapped.expression) &&
+        unwrapped.expression.text === "server" &&
+        unwrapped.name.text === "api");
+}
 function catchAllRoutePrefix(routePath) {
     const segments = routePath.split("/").filter(Boolean);
     const catchAllIndex = segments.findIndex((segment) => segment.endsWith("*"));
@@ -991,12 +1069,12 @@ function catchAllRoutePrefix(routePath) {
     const prefixSegments = segments.slice(0, catchAllIndex);
     return prefixSegments.length === 0 ? "/" : `/${prefixSegments.join("/")}`;
 }
-function parseNamedImports(source, config, importerFile) {
+function parseNamedImports(source, config, importerFile, files) {
     const imports = new Map();
     const importRegex = /import\s+\{([^}]+)\}\s+from\s+["']([^"']+)["']/g;
     for (const match of source.matchAll(importRegex)) {
         const sourcePath = match[2];
-        const contractFile = contractFileFromImport(sourcePath, config, importerFile);
+        const contractFile = contractFileFromImport(sourcePath, config, importerFile, files);
         for (const member of match[1].split(",")) {
             const parsed = parseImportMember(member);
             if (!parsed)
@@ -1046,9 +1124,7 @@ function parseImportMember(member) {
 }
 function sourceFileFromImport(sourcePath, importerFile = "index.ts", files) {
     const resolveCandidate = (candidate) => {
-        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];
@@ -1061,24 +1137,76 @@ function sourceFileFromImport(sourcePath, importerFile = "index.ts", files) {
     }
     return undefined;
 }
-function contractFileFromImport(sourcePath, config, importerFile) {
+function sourceFileCandidates(base, importerFile) {
+    const extensions = importerFile && isJavaScriptSourceFile(importerFile)
+        ? [
+            ...javascriptAnalysisSourceFileExtensions,
+            ...typescriptAnalysisSourceFileExtensions,
+        ]
+        : analysisSourceFileExtensions;
+    return [
+        ...extensions.map((extension) => `${base}${extension}`),
+        ...extensions.map((extension) => `${base}/index${extension}`),
+    ];
+}
+function sourceFileSpecifierCandidates(candidate, importerFile) {
+    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, name) {
+    return (isAnalysisSourceFile(file) &&
+        path.posix.basename(stripSourceFileExtension(file)) === name);
+}
+function directoryIndexSourceFile(file) {
+    const extension = path.posix.extname(file);
+    return `${stripSourceFileExtension(file)}/index${extension}`;
+}
+function contractFileFromImport(sourcePath, config, importerFile, files) {
+    const resolveCandidate = (candidate) => {
+        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}`;
     const relativePrefix = `${contractsPath}/`;
     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;
 }
@@ -1137,8 +1265,8 @@ function matchRoutes(contracts, routeExports) {
 async function inspectRouteSurface(targetDir, files, config, contracts) {
     if (config.framework === "next") {
         const routeFiles = files.filter((file) => file.startsWith(`${directoryPath(config.paths.routes)}/`) &&
-            file.endsWith("/route.ts"));
-        const routeExports = await readRouteExports(targetDir, routeFiles, config);
+            isNextRouteFile(file, config));
+        const routeExports = await readRouteExports(targetDir, routeFiles, files, config);
         return matchRoutes(contracts, routeExports);
     }
     if (!files.includes(config.paths.server)) {
@@ -1178,8 +1306,7 @@ function findContracts(contracts, routeExport) {
         const contract = contracts.find((contract) => 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] : [];
     }
     if (routeExport.catchAllPrefix) {
@@ -1416,7 +1543,10 @@ async function inspectCanonicalConformance(targetDir, files, config, convention,
     }
     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;
         }
         const source = await readCachedSource(targetDir, file, sourceCache);
@@ -1686,7 +1816,7 @@ async function inspectProductionReadiness(targetDir, files, config, convention)
     const schemaDir = `${infrastructurePath}/db/schema`;
     let hasSecurityHeadersHook = false;
     for (const file of files) {
-        if (!file.endsWith(".ts") || file.endsWith(".test.ts"))
+        if (!isAnalysisSourceFile(file) || isAppTestFile(file))
             continue;
         const source = await readCachedSource(targetDir, file, sourceCache);
         const routeServerOrInfra = isRouteServerOrInfraFile(file, config);
@@ -1705,7 +1835,7 @@ async function inspectProductionReadiness(targetDir, files, config, convention)
             });
         }
         if (fileWithinDirectory(file, cronDirectory) &&
-            file.endsWith("/route.ts") &&
+            isNextRouteFile(file, config) &&
             !/\bCRON_SECRET\b/.test(source) &&
             !/\bcreateOutboxDrainRoute\s*\(/.test(source) &&
             !/\bcreateScheduleRoute\s*\(/.test(source)) {
@@ -1871,6 +2001,16 @@ async function inspectProductionReadiness(targetDir, files, config, convention)
                 message: "@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((packageName) => readinessRelevantProviderPackages.has(packageName));
     if (installedReadinessProviders.length > 0 &&
@@ -1898,7 +2038,7 @@ async function uploadHasExplicitSizeLimit(targetDir, file, source, files, source
         const importedName = importedNameForLocalBinding(match[1] ?? "", fileReference);
         if (!importedName)
             continue;
-        const importedFile = resolveLocalTypeScriptModule(file, moduleName, files);
+        const importedFile = sourceFileFromImport(moduleName, file, files);
         if (!importedFile)
             continue;
         const importedSource = await readCachedSource(targetDir, importedFile, sourceCache);
@@ -1932,17 +2072,14 @@ function exportedObjectHasProperty(source, exportName, propertyName) {
     const initializer = source.slice(openIndex, closeIndex + 1);
     return new RegExp(`\\b${escapeRegExp(propertyName)}\\s*:`).test(initializer);
 }
-function resolveLocalTypeScriptModule(importer, moduleName, files) {
-    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, files, config, sourceCache) {
     const routesDir = directoryPath(config.paths.routes);
-    if (files.includes(`${routesDir}/ready/route.ts`))
+    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"))
+        if (!isAnalysisSourceFile(file) || isAppTestFile(file))
             continue;
         if (!isRouteServerOrInfraFile(file, config))
             continue;
@@ -2297,12 +2434,193 @@ async function inspectInngestProductionPath(targetDir, files, config) {
     return diagnostics;
 }
 function isFeatureUploadDefinition(file, config) {
-    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(files, config) {
     return providerOperationalConfigFiles(files, config);
 }
+function declaredBetterAuthMayRequireIssuerSchema(packageJson) {
+    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, packageJson) {
+    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) {
+    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(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) {
+    let directory = targetDir;
+    while (true) {
+        const candidate = await readJsonIfExists(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, request) {
+    try {
+        return requireFromTarget.resolve(request);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function hasBetterAuthIssuerSchema(targetDir, files, sourceCache) {
+    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, source) {
+    const sourceFile = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true);
+    let found = false;
+    const visit = (node) => {
+        if (found)
+            return;
+        if (ts.isCallExpression(node) &&
+            isBetterAuthAccountTableCall(node) &&
+            betterAuthAccountTableHasIssuerIdentity(node)) {
+            found = true;
+            return;
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return found;
+}
+function isBetterAuthAccountTableCall(call) {
+    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) {
+    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) => {
+        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) {
+    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, tableName) {
+    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, files) {
     if (!files.includes("package.json"))
         return undefined;
@@ -2387,7 +2705,7 @@ async function usesEntitlementChecks(targetDir, files, sourceCache) {
 async function hasBillingEntitlementsProviderWiring(targetDir, files, config, sourceCache) {
     const infraPath = path.dirname(config.paths.portWiring);
     const serverPath = path.dirname(config.paths.server);
-    const candidateFiles = files.filter((file) => /\.(?:ts|tsx|mts|cts)$/.test(file) &&
+    const candidateFiles = files.filter((file) => isAnalysisSourceFile(file) &&
         !isTestSourceFile(file) &&
         (file.startsWith(`${infraPath}/`) || file.startsWith(`${serverPath}/`)));
     for (const file of candidateFiles) {
@@ -2399,8 +2717,7 @@ async function hasBillingEntitlementsProviderWiring(targetDir, files, config, so
     return false;
 }
 function isTestSourceFile(file) {
-    return (/(?:^|\/)tests\//.test(file) ||
-        /\.(?:test|spec)\.(?:ts|tsx|mts|cts)$/.test(file));
+    return /(?:^|\/)tests\//.test(file) || isAppTestFile(file);
 }
 function exportedConstInitializer(source, exportName) {
     const declaration = new RegExp(`\\bexport\\s+const\\s+${escapeRegExp(exportName)}\\s*=`).exec(source);
@@ -2414,7 +2731,7 @@ function exportedConstInitializer(source, exportName) {
 }
 function featureNameFromContractFile(file, config) {
     const featuresPath = directoryPath(config.paths.features);
-    const match = new RegExp(`^${escapeRegExp(featuresPath)}/([^/]+)/contracts\\.ts$`).exec(file);
+    const match = new RegExp(`^${escapeRegExp(featuresPath)}/([^/]+)/contracts$`).exec(stripSourceFileExtension(file));
     return match?.[1];
 }
 function featureRuntimeFiles(files, featuresPath, feature) {
@@ -2426,7 +2743,7 @@ function featureRuntimeFiles(files, featuresPath, feature) {
         "use-cases",
     ];
     return files.filter((file) => {
-        if (!file.endsWith(".ts") || file.endsWith(".test.ts"))
+        if (!isAnalysisSourceFile(file) || isAppTestFile(file))
             return false;
         return runtimeFolders.some((folder) => file.startsWith(`${featuresPath}/${feature}/${folder}/`));
     });
@@ -2434,10 +2751,11 @@ function featureRuntimeFiles(files, featuresPath, feature) {
 function featureTestFiles(files, featuresPath, feature, options = {}) {
     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))));
     });
 }
 function featureNamesFromContracts(contracts, config) {
@@ -2533,14 +2851,12 @@ async function inspectFeatureArtifactDrift(targetDir, files, config, convention)
             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)) {
+        if (!isAnalysisSourceFile(file))
             continue;
-        }
         const misplaced = directFeatureTestMatch(file, featuresPath)
             ? undefined
             : misplacedFeatureLayer(file, config);
@@ -2554,8 +2870,6 @@ async function inspectFeatureArtifactDrift(targetDir, files, config, convention)
         }
         if (isTestSourceFile(file))
             continue;
-        if (!file.endsWith(".ts"))
-            continue;
         if (isNotificationDefinitionFile(file, featuresPath) ||
             isInfraOrServerFile(file, config)) {
             continue;
@@ -2573,15 +2887,19 @@ async function inspectFeatureArtifactDrift(targetDir, files, config, convention)
     return diagnostics;
 }
 function directFeatureTestMatch(file, featuresPath) {
-    return new RegExp(`^${escapeRegExp(featuresPath)}/([^/]+)/[^/]+\\.(?:test|spec)\\.(?:ts|tsx|mts|cts)$`).exec(file);
+    if (!isAppTestFile(file))
+        return null;
+    return new RegExp(`^${escapeRegExp(featuresPath)}/([^/]+)/[^/]+\\.(?:test|spec)$`).exec(stripSourceFileExtension(file));
 }
 function isFeatureArtifactFile(file, featuresPath, folder) {
-    const match = new RegExp(`^${escapeRegExp(featuresPath)}/[^/]+/${folder}/([^/]+)\\.ts$`).exec(file);
+    if (!isAnalysisSourceFile(file) || isAppTestFile(file))
+        return false;
+    const match = new RegExp(`^${escapeRegExp(featuresPath)}/[^/]+/${folder}/([^/]+)$`).exec(stripSourceFileExtension(file));
     return Boolean(match && match[1] !== "index");
 }
 async function appHasUploadRoute(targetDir, files, config) {
     for (const file of files) {
-        if (!file.endsWith(".ts") || file.endsWith(".test.ts"))
+        if (!isAnalysisSourceFile(file) || isAppTestFile(file))
             continue;
         if (!isRouteServerOrInfraFile(file, config))
             continue;
@@ -2910,10 +3228,13 @@ async function readFeatureWorkflowRegistries(targetDir, files, config) {
     ];
     for (const kind of kinds) {
         const folder = kind === "events" ? "domain/events" : kind;
-        const pattern = new RegExp(`^${escapeRegExp(featuresPath)}/[^/]+/${escapeRegExp(folder)}/index\\.ts$`);
+        const pattern = new RegExp(`^${escapeRegExp(featuresPath)}/[^/]+/${escapeRegExp(folder)}/index$`);
         for (const file of files) {
-            if (!pattern.test(file))
+            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);
             const exportRegex = new RegExp(`(?:^|\\n)export const\\s+([A-Za-z_$][\\w$]*${workflowRegistrySuffixes[kind]})\\s*=`, "g");
@@ -2955,9 +3276,7 @@ function exportedMemberFiles(source, indexFile, files) {
 async function readRuntimeManifestIdentifiers(targetDir, files) {
     const manifests = [];
     for (const file of files) {
-        if (!file.endsWith(".ts") && !file.endsWith(".tsx"))
-            continue;
-        if (file.endsWith(".d.ts") || isWorkflowTestFile(file))
+        if (!isAnalysisSourceFile(file) || isWorkflowTestFile(file))
             continue;
         const source = await readFile(path.join(targetDir, file), "utf8");
         if (!source.includes("defineRuntimeManifest"))
@@ -3066,11 +3385,14 @@ function registeredWorkflowIdentifiers(source, kind) {
 }
 async function listenedEventNames(targetDir, files, config) {
     const featuresPath = directoryPath(config.paths.features);
-    const listenerPattern = new RegExp(`^${escapeRegExp(featuresPath)}/[^/]+/listeners/[^/]+\\.ts$`);
+    const listenerPattern = new RegExp(`^${escapeRegExp(featuresPath)}/[^/]+/listeners/[^/]+$`);
     const listened = new Set();
     for (const file of files) {
-        if (!listenerPattern.test(file) || isWorkflowTestFile(file))
+        if (!isAnalysisSourceFile(file) ||
+            isWorkflowTestFile(file) ||
+            !listenerPattern.test(stripSourceFileExtension(file))) {
             continue;
+        }
         const source = await readFile(path.join(targetDir, file), "utf8");
         const callPattern = /\bdefineListener\s*\(/g;
         for (const match of source.matchAll(callPattern)) {
@@ -3100,13 +3422,11 @@ async function listenerWiringReferences(targetDir, files, config, listenerRegist
     let centralListenerRegistryReferenced = false;
     const listenerRegistryFile = listenersFilePath(config);
     for (const file of files) {
-        if (!file.endsWith(".ts") && !file.endsWith(".tsx"))
-            continue;
-        if (file.endsWith(".d.ts") || isWorkflowTestFile(file))
+        if (!isAnalysisSourceFile(file) || isWorkflowTestFile(file))
             continue;
         const source = await readFile(path.join(targetDir, file), "utf8");
         const namedImports = parseNamedImportSources(source);
-        const sourceFile = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true, file.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+        const sourceFile = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true, sourceFileScriptKind(file));
         const registerListenersBindings = importedRegisterListenersBindings(source, namedImports);
         const calls = registerListenersCalls(sourceFile, registerListenersBindings);
         let foundRelevantCall = false;
@@ -3426,21 +3746,15 @@ function callReferencesCentralListenerRegistry(args) {
     return false;
 }
 function isWorkflowTestFile(file) {
-    return (file.endsWith(".test.ts") ||
-        file.endsWith(".test.tsx") ||
-        file.startsWith("tests/") ||
-        file.includes("/tests/"));
+    return (isAppTestFile(file) || file.startsWith("tests/") || file.includes("/tests/"));
 }
 async function inspectServerlessFootguns(targetDir, files, config, convention) {
     const diagnostics = [];
     const routeDirectory = directoryPath(config.paths.routes);
     const cronDirectory = path.posix.join(routeDirectory, "cron");
     for (const file of files) {
-        if (!file.endsWith(".ts") ||
-            file.endsWith(".test.ts") ||
-            file.endsWith(".d.ts")) {
+        if (!isAnalysisSourceFile(file) || isAppTestFile(file))
             continue;
-        }
         const source = await readFile(path.join(targetDir, file), "utf8");
         const isInfraOrServerFile = isRuntimeFile(file, config);
         const isProviderFile = isProviderLifecycleFile(file, source);
@@ -3545,16 +3859,18 @@ function fileWithinDirectory(file, directory) {
     return directory === "." || file.startsWith(`${directory}/`);
 }
 function isProviderLifecycleFile(file, source) {
-    return (/(^|\/)provider(s)?\.ts$/.test(file) ||
-        /(^|\/)[^/]*provider[^/]*\.ts$/.test(file) ||
+    const sourcePath = stripSourceFileExtension(file);
+    return (/(^|\/)provider(s)?$/.test(sourcePath) ||
+        /(^|\/)[^/]*provider[^/]*$/.test(sourcePath) ||
         /(^|\/)providers?\//.test(file) ||
         (source !== undefined && containsCallExpression(source, "createProvider")));
 }
 function isNextRouteFile(file, config) {
     const routesPath = directoryPath(config.paths.routes);
     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));
 }
 function importsEagerServer(source, importerFile, files, config) {
     const importRegex = /import\s+\{([^}]+)\}\s+from\s+["']([^"']+)["']/g;
@@ -4785,7 +5101,9 @@ async function inspectFeatureRouteRegistration(targetDir, files, config, convent
         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);
         if (featureRouteGroups.length === 0) {
             diagnostics.push({
@@ -4851,11 +5169,11 @@ function contractsForRegisteredRouteGroups(contracts, routeGroups, registeredGro
 }
 async function readFeatureRouteGroups(targetDir, files, config) {
     const featuresPath = `${directoryPath(config.paths.features)}/`;
-    const routeFiles = files.filter((file) => file.startsWith(featuresPath) && file.endsWith("/routes.ts"));
+    const routeFiles = files.filter((file) => file.startsWith(featuresPath) && isSourceFileNamed(file, "routes"));
     const routeGroups = [];
     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));
     }
     return routeGroups;
@@ -4966,8 +5284,7 @@ function findRouteGroupContract(contracts, routeGroupContract) {
     return contracts.find((contract) => contract.exportName === routeGroupContract.exportName &&
         (!routeGroupContract.file ||
             contract.file === routeGroupContract.file ||
-            contract.file ===
-                routeGroupContract.file.replace(/\.ts$/, "/index.ts")));
+            contract.file === directoryIndexSourceFile(routeGroupContract.file)));
 }
 const managedDatabaseSchemaMarker = "// Managed by beignet db schema sync.";
 const databaseSchemaExports = {
@@ -5899,7 +6216,7 @@ async function readContractLists(targetDir, files, config) {
     const contractFiles = contractListSourceFiles(files, config);
     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);
         }
@@ -5909,29 +6226,36 @@ async function readContractLists(targetDir, files, config) {
 function contractSourceFiles(files, config) {
     const contractsPath = directoryPath(config.paths.contracts);
     if (usesFeatureOwnedContracts(config)) {
-        return files.filter((file) => new RegExp(`^${escapeRegExp(contractsPath)}/[^/]+/contracts\\.ts$`).test(file) && !file.endsWith(".test.ts"));
+        return files.filter((file) => 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(files, config) {
     const contractsPath = directoryPath(config.paths.contracts);
     if (usesFeatureOwnedContracts(config)) {
         return files.filter((file) => {
-            if (!file.endsWith(".ts") || file.endsWith(".test.ts"))
+            if (!isAnalysisSourceFile(file) || isAppTestFile(file))
                 return false;
-            if (file === `${contractsPath}/index.ts`)
+            const sourcePath = stripSourceFileExtension(file);
+            if (sourcePath === `${contractsPath}/index`)
                 return true;
-            if (file === `${contractsPath}/contracts.ts`)
+            if (sourcePath === `${contractsPath}/contracts`)
                 return true;
-            return new RegExp(`^${escapeRegExp(contractsPath)}/[^/]+/contracts\\.ts$`).test(file);
+            return new RegExp(`^${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(source, file, imports) {
     const lists = [];
@@ -5970,7 +6294,7 @@ function resolveContractList(lists, file, name, seen = new Set()) {
     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);
@@ -6342,7 +6666,7 @@ function nextRoutePath(file, routeRoot) {
     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("/");