@beignet/cli 0.0.24 → 0.0.26

package/dist/provider-audit.js

@@ -0,0 +1,1013 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseProviderPackageMetadata, } from "@beignet/core/providers";
+import { defaultBeignetConfig, directoryPath, loadBeignetConfig, normalizePath, } from "./config.js";
+export async function auditProviders(options = {}) {
+    const targetDir = path.resolve(options.cwd ?? process.cwd());
+    await assertDirectory(targetDir);
+    const files = await listFiles(targetDir);
+    const config = await loadBeignetConfig(targetDir, files);
+    const packageJson = await readPackageJson(targetDir, files);
+    const packageNames = await providerAuditPackageNames(targetDir, packageJson);
+    const sourceCache = new Map();
+    const providerEntries = await readProviderListEntries(targetDir, files, config, sourceCache);
+    const configFiles = providerOperationalConfigFiles(files, config);
+    const portsSource = files.includes(config.paths.ports)
+        ? await readCachedSource(targetDir, config.paths.ports, sourceCache)
+        : "";
+    const infrastructurePath = directoryPath(path.dirname(config.paths.infrastructurePorts));
+    const schemaDir = `${infrastructurePath}/db/schema`;
+    const providers = [];
+    for (const packageName of packageNames) {
+        const source = await readProviderPackageMetadataSource(targetDir, packageName);
+        if (!source) {
+            providers.push(providerAuditEntryForMissingMetadata(packageName, packageJson));
+            continue;
+        }
+        const parsed = parseProviderPackageMetadata(source.metadata);
+        if (!parsed.success) {
+            providers.push(providerAuditEntryForInvalidMetadata(packageName, packageJson, metadataSourcePath(targetDir, source.file), parsed.issues));
+            continue;
+        }
+        providers.push(await providerAuditEntryForRule({
+            targetDir,
+            files,
+            config,
+            configFiles,
+            infrastructurePath,
+            schemaDir,
+            sourceCache,
+            portsSource,
+            providerEntries,
+            sourceFile: source.file,
+            packageJson,
+            rule: providerDoctorRuleFromMetadata(packageName, parsed.metadata),
+        }));
+    }
+    providers.sort((left, right) => left.packageName.localeCompare(right.packageName));
+    return {
+        schemaVersion: 1,
+        targetDir,
+        providers,
+        summary: summarizeProviderAudit(providers),
+    };
+}
+export function formatProviderAudit(result) {
+    if (result.providers.length === 0) {
+        return `No Beignet provider packages found in ${result.targetDir}.`;
+    }
+    const rows = result.providers.map((provider) => ({
+        packageName: provider.packageName,
+        metadata: provider.metadata.status,
+        registration: provider.registration,
+        env: requirementSummary(provider.requiredEnv),
+        tables: requirementSummary(provider.requiredTables),
+        appPorts: appPortsSummary(provider.appPorts),
+        notes: provider.notes.length === 0 ? "-" : provider.notes.join("; "),
+    }));
+    return [
+        `Provider audit for ${result.targetDir}`,
+        "",
+        table([
+            ["PACKAGE", "METADATA", "REGISTRATION", "ENV", "TABLES", "APP PORTS"],
+            ...rows.map((row) => [
+                row.packageName,
+                row.metadata,
+                row.registration,
+                row.env,
+                row.tables,
+                row.appPorts,
+            ]),
+        ]),
+        "",
+        ...rows
+            .filter((row) => row.notes !== "-")
+            .map((row) => `${row.packageName}: ${row.notes}`),
+        "",
+        `Summary: ${result.summary.total} provider(s), ${result.summary.missingRegistration} missing registration, ${result.summary.missingEnv} missing env, ${result.summary.missingTables} missing tables, ${result.summary.missingAppPorts} missing app ports.`,
+    ]
+        .filter((line, index, lines) => line !== "" || lines[index - 1] !== "")
+        .join("\n");
+}
+export async function providerDoctorRulesForInstalledPackages(targetDir, packageJson) {
+    const packageNames = [...installedPackageNames(packageJson)];
+    const rules = await Promise.all(packageNames.map(async (packageName) => {
+        const source = await readProviderPackageMetadataSource(targetDir, packageName);
+        if (!source)
+            return undefined;
+        const result = parseProviderPackageMetadata(source.metadata);
+        if (!result.success)
+            return undefined;
+        return providerDoctorRuleFromMetadata(packageName, result.metadata);
+    }));
+    return rules.filter((rule) => Boolean(rule));
+}
+export async function readProviderPackageMetadataSource(targetDir, packageName) {
+    for (const candidate of providerPackageJsonCandidates(targetDir, packageName)) {
+        const packageJson = await readJsonIfExists(candidate);
+        const metadata = packageJson?.beignet?.provider;
+        if (metadata !== undefined) {
+            return { packageName, file: candidate, metadata };
+        }
+    }
+    return undefined;
+}
+export function providerDoctorRuleFromMetadata(packageName, metadata) {
+    const registration = metadata.registration;
+    return {
+        packageName,
+        displayName: metadata.displayName ?? packageName,
+        tokens: registration?.tokens ?? [],
+        appPorts: metadata.appPorts ?? [],
+        requiredEnv: metadata.requiredEnv ?? [],
+        requiredTables: metadata.requiredTables ?? [],
+        watchers: metadata.watchers ?? [],
+        registrationSeverity: registrationSeverityFromMetadata(registration),
+        variants: metadata.variants?.map((variant) => ({
+            name: variant.name,
+            displayName: variant.displayName ?? variant.name,
+            tokens: variant.registration?.tokens ?? [],
+            requiredEnv: variant.requiredEnv ?? [],
+            requiredTables: variant.requiredTables ?? [],
+            registrationSeverity: registrationSeverityFromMetadata(variant.registration),
+        })),
+    };
+}
+export function registrationSeverityFromMetadata(registration) {
+    return (registration?.severity ??
+        (registration?.required === true ? "warning" : undefined));
+}
+export function detectedProviderVariants(variants, providerEntries) {
+    return variants.filter((variant) => variant.tokens.some((token) => providerEntries.some((entry) => entry.includes(token))));
+}
+export function providerVariantRegistrationSeverity(variants) {
+    const severities = variants.map((variant) => variant.registrationSeverity);
+    if (severities.includes("warning"))
+        return "warning";
+    if (severities.includes("hint"))
+        return "hint";
+    return undefined;
+}
+export async function readProviderListEntries(targetDir, files, config, sourceCache) {
+    const providerFiles = serverProviderFiles(files, config);
+    const providerSource = (await Promise.all(providerFiles.map((file) => readCachedSource(targetDir, file, sourceCache)))).join("\n");
+    const providerListSource = extractProviderListSource(providerSource);
+    return providerListSource === undefined
+        ? []
+        : providerListEntries(providerListSource);
+}
+export function registrationTokenHint(tokens) {
+    const token = tokens[0];
+    if (!token)
+        return "the provider";
+    return token.startsWith("create") ? `${token}()` : token;
+}
+export function diagnosticPackageJsonFile(targetDir, file) {
+    const relative = normalizePath(path.relative(targetDir, file));
+    if (relative.startsWith("../"))
+        return "package.json";
+    return relative;
+}
+export function formatProviderMetadataIssues(issues) {
+    return issues.map((issue) => `${issue.path} ${issue.message}`).join("; ");
+}
+export function installedPackageNames(packageJson) {
+    return new Set([
+        ...Object.keys(packageJson?.dependencies ?? {}),
+        ...Object.keys(packageJson?.devDependencies ?? {}),
+        ...Object.keys(packageJson?.peerDependencies ?? {}),
+    ]);
+}
+export function providerOperationalConfigFiles(files, config) {
+    return files.filter((file) => {
+        if (file === ".env.example")
+            return true;
+        if (file === "drizzle.config.ts")
+            return true;
+        if (file === "lib/env.ts" || file === "lib/better-auth.ts")
+            return true;
+        if (isInfraOrServerFile(file, config) && file.endsWith(".ts"))
+            return true;
+        return false;
+    });
+}
+export async function providerRequiredEnvExists(targetDir, configFiles, envVar, sourceCache) {
+    for (const file of configFiles) {
+        const source = await readCachedSource(targetDir, file, sourceCache);
+        if (source.includes(envVar))
+            return true;
+    }
+    return false;
+}
+export async function providerRequiredTableExists(targetDir, files, config, infrastructurePath, schemaDir, tableName, sourceCache) {
+    return databaseTableExists({
+        targetDir,
+        files,
+        config,
+        infrastructurePath,
+        schemaDir,
+        tableName,
+        sourceCache,
+    });
+}
+const databaseSourceFilePattern = /\.(?:ts|tsx|js|jsx|mts|mjs|cts|cjs|sql)$/;
+async function databaseTableExists(options) {
+    const sourceFiles = await databaseTableSourceFiles(options);
+    const seen = new Set();
+    for (const file of sourceFiles) {
+        if (seen.has(file.absolutePath))
+            continue;
+        seen.add(file.absolutePath);
+        const source = await readDatabaseSourceFile(options.targetDir, file, options.sourceCache);
+        if (sourceCreatesTable(source, options.tableName) ||
+            (file.kind === "schema" &&
+                sourceDeclaresSchemaTable(source, options.tableName))) {
+            return true;
+        }
+    }
+    return false;
+}
+async function databaseTableSourceFiles(options) {
+    return [
+        ...defaultDatabaseTableSourceFiles(options.targetDir, options.files, options.infrastructurePath, options.schemaDir),
+        ...(await configuredDatabaseSchemaSourceFiles(options.targetDir, options.config)),
+        ...(await discoveredDatabaseSchemaImportFiles(options)),
+    ];
+}
+function defaultDatabaseTableSourceFiles(targetDir, files, infrastructurePath, schemaDir) {
+    const schemaPrefix = `${schemaDir}/`;
+    return files
+        .filter((file) => !isTestSourceFile(file) &&
+        databaseSourceFilePattern.test(file) &&
+        (file.startsWith(schemaPrefix) ||
+            file.startsWith("drizzle/") ||
+            file.startsWith(`${infrastructurePath}/db/`)))
+        .map((file) => ({
+        absolutePath: path.join(targetDir, file),
+        kind: file.startsWith(schemaPrefix) ? "schema" : "setup",
+        relativePath: file,
+    }));
+}
+async function configuredDatabaseSchemaSourceFiles(targetDir, config) {
+    const sourceFiles = [];
+    for (const source of config.database.schemaSources) {
+        sourceFiles.push(...(await resolveDatabaseSchemaSource(targetDir, source)));
+    }
+    return sourceFiles;
+}
+async function discoveredDatabaseSchemaImportFiles(options) {
+    const sourceFiles = [];
+    for (const file of databaseSchemaImportDiscoveryFiles(options.files, options.config, options.infrastructurePath, options.schemaDir)) {
+        const source = await readCachedSource(options.targetDir, file, options.sourceCache);
+        for (const specifier of moduleSpecifiers(source)) {
+            if (!looksLikeDatabaseSchemaSource(specifier))
+                continue;
+            sourceFiles.push(...(await resolveDatabaseSchemaSource(options.targetDir, specifier, file)));
+        }
+    }
+    return sourceFiles;
+}
+function databaseSchemaImportDiscoveryFiles(files, config, infrastructurePath, schemaDir) {
+    const candidates = new Set([
+        "drizzle.config.ts",
+        "drizzle.config.mts",
+        "drizzle.config.js",
+        "drizzle.config.mjs",
+        ...serverProviderFiles(files, config),
+    ]);
+    for (const file of files) {
+        if (!isTestSourceFile(file) &&
+            databaseSourceFilePattern.test(file) &&
+            (file.startsWith(`${infrastructurePath}/db/`) ||
+                file.startsWith(`${schemaDir}/`))) {
+            candidates.add(file);
+        }
+    }
+    return [...candidates].filter((file) => files.includes(file));
+}
+async function resolveDatabaseSchemaSource(targetDir, source, importerFile) {
+    if (source.startsWith("@/")) {
+        return collectSourceFilesFromAppPath(targetDir, source.slice(2));
+    }
+    if (source.startsWith(".")) {
+        if (!importerFile)
+            return [];
+        return collectSourceFilesFromAppPath(targetDir, path.posix.join(path.posix.dirname(importerFile), source));
+    }
+    if (path.isAbsolute(source))
+        return [];
+    if (!source.startsWith("@") && !importerFile) {
+        const appFiles = await collectSourceFilesFromAppPath(targetDir, source);
+        if (appFiles.length > 0)
+            return appFiles;
+    }
+    return collectSourceFilesFromPackageSpecifier(targetDir, source);
+}
+async function collectSourceFilesFromAppPath(targetDir, input) {
+    const normalized = normalizePath(path.posix.normalize(input)).replace(/^\/+/, "");
+    if (normalized === ".." || normalized.startsWith("../"))
+        return [];
+    return collectSourceFilesFromAbsolutePath(path.join(targetDir, normalized), targetDir);
+}
+async function collectSourceFilesFromPackageSpecifier(targetDir, specifier) {
+    const parsed = packageSpecifierParts(specifier);
+    if (!parsed)
+        return [];
+    const packageDir = path.join(targetDir, "node_modules", ...parsed.packageName.split("/"));
+    const directPath = path.join(packageDir, parsed.subpath);
+    const directFiles = await collectSourceFilesFromAbsolutePath(directPath, targetDir);
+    if (directFiles.length > 0)
+        return directFiles;
+    const packageJson = await readJsonIfExists(path.join(packageDir, "package.json"));
+    if (!packageJson)
+        return [];
+    const exported = packageExportTarget(packageJson.exports, parsed.subpath);
+    if (exported) {
+        const exportedFiles = await collectSourceFilesFromAbsolutePath(path.join(packageDir, exported.replace(/^\.\//, "")), targetDir);
+        if (exportedFiles.length > 0)
+            return exportedFiles;
+    }
+    if (!parsed.subpath) {
+        for (const entrypoint of [
+            packageJson.types,
+            packageJson.module,
+            packageJson.main,
+        ]) {
+            if (!entrypoint)
+                continue;
+            const entrypointFiles = await collectSourceFilesFromAbsolutePath(path.join(packageDir, entrypoint), targetDir);
+            if (entrypointFiles.length > 0)
+                return entrypointFiles;
+        }
+    }
+    return [];
+}
+async function collectSourceFilesFromAbsolutePath(absolutePath, targetDir) {
+    const filePath = await resolveSourceFilePath(absolutePath);
+    if (filePath) {
+        return [
+            {
+                absolutePath: filePath,
+                kind: "schema",
+                relativePath: relativePathInsideTarget(targetDir, filePath),
+            },
+        ];
+    }
+    const stats = await statIfExists(absolutePath);
+    if (!stats?.isDirectory())
+        return [];
+    const files = [];
+    async function visit(dir) {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name === "node_modules" ||
+                entry.name === ".git" ||
+                entry.name === ".next" ||
+                entry.name === ".turbo" ||
+                entry.name === "coverage") {
+                continue;
+            }
+            const entryPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await visit(entryPath);
+            }
+            else if (entry.isFile() &&
+                databaseSourceFilePattern.test(entry.name) &&
+                !isTestSourceFile(normalizePath(entryPath))) {
+                files.push({
+                    absolutePath: entryPath,
+                    kind: "schema",
+                    relativePath: relativePathInsideTarget(targetDir, entryPath),
+                });
+            }
+        }
+    }
+    await visit(absolutePath);
+    return files;
+}
+async function resolveSourceFilePath(absolutePath) {
+    const candidates = [
+        absolutePath,
+        `${absolutePath}.ts`,
+        `${absolutePath}.tsx`,
+        `${absolutePath}.mts`,
+        `${absolutePath}.cts`,
+        `${absolutePath}.js`,
+        `${absolutePath}.jsx`,
+        `${absolutePath}.mjs`,
+        `${absolutePath}.cjs`,
+        `${absolutePath}.sql`,
+        path.join(absolutePath, "index.ts"),
+        path.join(absolutePath, "index.tsx"),
+        path.join(absolutePath, "index.mts"),
+        path.join(absolutePath, "index.cts"),
+        path.join(absolutePath, "index.js"),
+        path.join(absolutePath, "index.jsx"),
+        path.join(absolutePath, "index.mjs"),
+        path.join(absolutePath, "index.cjs"),
+    ];
+    for (const candidate of candidates) {
+        const stats = await statIfExists(candidate);
+        if (stats?.isFile() && databaseSourceFilePattern.test(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+async function readDatabaseSourceFile(targetDir, file, sourceCache) {
+    if (file.relativePath) {
+        return readCachedSource(targetDir, file.relativePath, sourceCache);
+    }
+    const cacheKey = `absolute:${file.absolutePath}`;
+    const cached = sourceCache.get(cacheKey);
+    if (cached !== undefined)
+        return cached;
+    const source = await readFile(file.absolutePath, "utf8");
+    sourceCache.set(cacheKey, source);
+    return source;
+}
+function relativePathInsideTarget(targetDir, absolutePath) {
+    const relativePath = normalizePath(path.relative(targetDir, absolutePath));
+    if (relativePath === "" || relativePath.startsWith("../"))
+        return undefined;
+    return relativePath;
+}
+async function statIfExists(filePath) {
+    try {
+        return await stat(filePath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+function packageSpecifierParts(specifier) {
+    const parts = specifier.split("/").filter(Boolean);
+    if (parts.length === 0)
+        return undefined;
+    if (specifier.startsWith("@")) {
+        if (parts.length < 2)
+            return undefined;
+        return {
+            packageName: `${parts[0]}/${parts[1]}`,
+            subpath: parts.slice(2).join("/"),
+        };
+    }
+    return {
+        packageName: parts[0],
+        subpath: parts.slice(1).join("/"),
+    };
+}
+function packageExportTarget(exportsValue, subpath) {
+    if (exportsValue === undefined)
+        return undefined;
+    const key = subpath ? `./${subpath}` : ".";
+    if (typeof exportsValue === "string") {
+        return key === "." ? exportsValue : undefined;
+    }
+    if (Array.isArray(exportsValue)) {
+        for (const value of exportsValue) {
+            const target = packageExportTarget(value, subpath);
+            if (target)
+                return target;
+        }
+        return undefined;
+    }
+    if (!isRecord(exportsValue))
+        return undefined;
+    const exact = exportsValue[key];
+    const target = exportTargetValue(exact);
+    if (target)
+        return target;
+    for (const [pattern, value] of Object.entries(exportsValue)) {
+        if (!pattern.includes("*"))
+            continue;
+        const [prefix, suffix] = pattern.split("*");
+        if (!key.startsWith(prefix) || !key.endsWith(suffix))
+            continue;
+        const replacement = key.slice(prefix.length, key.length - suffix.length);
+        const patternTarget = exportTargetValue(value);
+        if (patternTarget)
+            return patternTarget.replace("*", replacement);
+    }
+    return undefined;
+}
+function exportTargetValue(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const target = exportTargetValue(item);
+            if (target)
+                return target;
+        }
+        return undefined;
+    }
+    if (!isRecord(value))
+        return undefined;
+    for (const key of ["source", "types", "import", "default", "require"]) {
+        const target = exportTargetValue(value[key]);
+        if (target)
+            return target;
+    }
+    return undefined;
+}
+function moduleSpecifiers(source) {
+    const specifiers = new Set();
+    for (const match of source.matchAll(/\b(?:import|export)\b[\s\S]{0,300}?\bfrom\s*["']([^"']+)["']/g)) {
+        specifiers.add(match[1]);
+    }
+    for (const match of source.matchAll(/\bimport\s*["']([^"']+)["']/g)) {
+        specifiers.add(match[1]);
+    }
+    return [...specifiers];
+}
+function looksLikeDatabaseSchemaSource(specifier) {
+    return /(?:^|\/)(?:db|database|schema|schemas)(?:\/|$)/i.test(specifier);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function configuredProviderRequiredTables(tableNames, config) {
+    return tableNames.map((tableName) => configuredProviderRequiredTable(tableName, config));
+}
+function configuredProviderRequiredTable(tableName, config) {
+    for (const [key, defaultTableName] of Object.entries(defaultBeignetConfig.database.tables)) {
+        if (tableName === defaultTableName)
+            return config.database.tables[key];
+    }
+    return tableName;
+}
+async function providerAuditPackageNames(targetDir, packageJson) {
+    const names = [...installedPackageNames(packageJson)].sort();
+    const candidates = await Promise.all(names.map(async (packageName) => ({
+        packageName,
+        hasMetadata: (await readProviderPackageMetadataSource(targetDir, packageName)) !==
+            undefined,
+    })));
+    return candidates
+        .filter(({ packageName, hasMetadata }) => hasMetadata || isLikelyProviderPackageName(packageName))
+        .map(({ packageName }) => packageName);
+}
+function isLikelyProviderPackageName(packageName) {
+    return (packageName === "@beignet/devtools" ||
+        packageName.startsWith("@beignet/provider-") ||
+        packageName.includes("beignet-provider"));
+}
+function providerPackageJsonCandidates(targetDir, packageName) {
+    const candidates = [
+        path.join(targetDir, "node_modules", ...packageName.split("/"), "package.json"),
+    ];
+    if (packageName.startsWith("@beignet/")) {
+        candidates.push(path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../..", "packages", packageName.slice("@beignet/".length), "package.json"));
+    }
+    return candidates;
+}
+async function readJsonIfExists(file) {
+    try {
+        return JSON.parse(await readFile(file, "utf8"));
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+async function providerAuditEntryForRule(options) {
+    const detectedVariants = options.rule.variants
+        ? detectedProviderVariants(options.rule.variants, options.providerEntries)
+        : [];
+    const variants = await Promise.all((options.rule.variants ?? []).map(async (variant) => providerVariantAudit({
+        ...options,
+        variant,
+        registered: detectedVariants.includes(variant),
+    })));
+    const requiredEnv = options.rule.variants !== undefined
+        ? aggregateVariantRequirement(variants, "requiredEnv")
+        : await requirementAudit(options.rule.requiredEnv ?? [], (envVar) => providerRequiredEnvExists(options.targetDir, options.configFiles, envVar, options.sourceCache));
+    const requiredTables = options.rule.variants !== undefined
+        ? aggregateVariantRequirement(variants, "requiredTables")
+        : await requirementAudit(configuredProviderRequiredTables(options.rule.requiredTables ?? [], options.config), (tableName) => providerRequiredTableExists(options.targetDir, options.files, options.config, options.infrastructurePath, options.schemaDir, tableName, options.sourceCache));
+    const registration = options.rule.variants !== undefined
+        ? variantRegistrationAudit(options.rule.variants, detectedVariants)
+        : registrationAudit(options.rule.tokens, options.rule.registrationSeverity, options.providerEntries);
+    const appPorts = appPortsAudit(options.rule.appPorts ?? [], options.portsSource);
+    const notes = providerAuditNotes({
+        metadataStatus: "valid",
+        registration,
+        requiredEnv,
+        requiredTables,
+        appPorts,
+    });
+    return {
+        packageName: options.rule.packageName,
+        displayName: options.rule.displayName,
+        declared: installedPackageNames(options.packageJson).has(options.rule.packageName),
+        metadata: {
+            status: "valid",
+            source: metadataSourcePath(options.targetDir, options.sourceFile),
+            issues: [],
+        },
+        registration,
+        requiredEnv,
+        requiredTables,
+        appPorts,
+        watchers: [...(options.rule.watchers ?? [])],
+        variants,
+        notes,
+    };
+}
+async function providerVariantAudit(options) {
+    if (!options.registered) {
+        return {
+            name: options.variant.name,
+            displayName: options.variant.displayName,
+            registration: "inactive",
+            requiredEnv: inactiveRequirement(options.variant.requiredEnv),
+            requiredTables: inactiveRequirement(options.variant.requiredTables),
+        };
+    }
+    return {
+        name: options.variant.name,
+        displayName: options.variant.displayName,
+        registration: registrationAudit(options.variant.tokens, options.variant.registrationSeverity, options.providerEntries),
+        requiredEnv: await requirementAudit(options.variant.requiredEnv, (envVar) => providerRequiredEnvExists(options.targetDir, options.configFiles, envVar, options.sourceCache)),
+        requiredTables: await requirementAudit(configuredProviderRequiredTables(options.variant.requiredTables, options.config), (tableName) => providerRequiredTableExists(options.targetDir, options.files, options.config, options.infrastructurePath, options.schemaDir, tableName, options.sourceCache)),
+    };
+}
+function providerAuditEntryForMissingMetadata(packageName, packageJson) {
+    return {
+        packageName,
+        displayName: packageName,
+        declared: installedPackageNames(packageJson).has(packageName),
+        metadata: { status: "missing", issues: [] },
+        registration: "not-required",
+        requiredEnv: emptyRequirement(),
+        requiredTables: emptyRequirement(),
+        appPorts: emptyAppPorts(),
+        watchers: [],
+        variants: [],
+        notes: ["provider metadata missing"],
+    };
+}
+function providerAuditEntryForInvalidMetadata(packageName, packageJson, source, issues) {
+    return {
+        packageName,
+        displayName: packageName,
+        declared: installedPackageNames(packageJson).has(packageName),
+        metadata: {
+            status: "invalid",
+            source,
+            issues: [...issues],
+        },
+        registration: "not-required",
+        requiredEnv: emptyRequirement(),
+        requiredTables: emptyRequirement(),
+        appPorts: emptyAppPorts(),
+        watchers: [],
+        variants: [],
+        notes: [`invalid metadata: ${formatProviderMetadataIssues(issues)}`],
+    };
+}
+function registrationAudit(tokens, severity, providerEntries) {
+    if (tokens.some((token) => providerEntries.some((entry) => entry.includes(token)))) {
+        return "registered";
+    }
+    if (severity === "warning")
+        return "missing";
+    if (severity === "hint")
+        return "optional-missing";
+    return "not-required";
+}
+function variantRegistrationAudit(variants, detectedVariants) {
+    if (detectedVariants.length > 0)
+        return "registered";
+    const severity = providerVariantRegistrationSeverity(variants);
+    if (severity === "warning")
+        return "missing";
+    if (severity === "hint")
+        return "optional-missing";
+    return "not-required";
+}
+async function requirementAudit(required, exists) {
+    if (required.length === 0)
+        return emptyRequirement();
+    const missing = [];
+    for (const requirement of required) {
+        if (await exists(requirement))
+            continue;
+        missing.push(requirement);
+    }
+    return {
+        status: missing.length === 0 ? "present" : "missing",
+        required: [...required],
+        missing,
+    };
+}
+function inactiveRequirement(required) {
+    return {
+        status: "inactive",
+        required: [...required],
+        missing: [],
+    };
+}
+function emptyRequirement() {
+    return { status: "none", required: [], missing: [] };
+}
+function aggregateVariantRequirement(variants, key) {
+    const active = variants
+        .map((variant) => variant[key])
+        .filter((requirement) => requirement.status !== "inactive");
+    if (active.length === 0)
+        return { status: "inactive", required: [], missing: [] };
+    const required = unique(active.flatMap((requirement) => requirement.required));
+    const missing = unique(active.flatMap((requirement) => requirement.missing));
+    if (required.length === 0)
+        return emptyRequirement();
+    return {
+        status: missing.length === 0 ? "present" : "missing",
+        required,
+        missing,
+    };
+}
+function appPortsAudit(required, portsSource) {
+    if (required.length === 0)
+        return emptyAppPorts();
+    const missing = required.filter((port) => !portsSource.includes(`${port.name}:`));
+    return {
+        status: missing.length === 0 ? "present" : "missing",
+        required: [...required],
+        missing,
+    };
+}
+function emptyAppPorts() {
+    return { status: "none", required: [], missing: [] };
+}
+function providerAuditNotes(input) {
+    const notes = [];
+    if (input.metadataStatus === "invalid")
+        notes.push("metadata invalid");
+    if (input.metadataStatus === "missing")
+        notes.push("metadata missing");
+    if (input.registration === "missing")
+        notes.push("registration missing");
+    if (input.registration === "optional-missing") {
+        notes.push("optional provider not registered");
+    }
+    if (input.requiredEnv.missing.length > 0) {
+        notes.push(`missing env: ${input.requiredEnv.missing.join(", ")}`);
+    }
+    if (input.requiredTables.missing.length > 0) {
+        notes.push(`missing tables: ${input.requiredTables.missing.join(", ")}`);
+    }
+    if (input.appPorts.missing.length > 0) {
+        notes.push(`missing app ports: ${input.appPorts.missing
+            .map((port) => port.name)
+            .join(", ")}`);
+    }
+    return notes;
+}
+function summarizeProviderAudit(providers) {
+    return {
+        total: providers.length,
+        validMetadata: providers.filter((provider) => provider.metadata.status === "valid").length,
+        invalidMetadata: providers.filter((provider) => provider.metadata.status === "invalid").length,
+        missingMetadata: providers.filter((provider) => provider.metadata.status === "missing").length,
+        registered: providers.filter((provider) => provider.registration === "registered").length,
+        missingRegistration: providers.filter((provider) => provider.registration === "missing").length,
+        missingEnv: providers.filter((provider) => provider.requiredEnv.status === "missing").length,
+        missingTables: providers.filter((provider) => provider.requiredTables.status === "missing").length,
+        missingAppPorts: providers.filter((provider) => provider.appPorts.status === "missing").length,
+    };
+}
+async function readPackageJson(targetDir, files) {
+    if (!files.includes("package.json"))
+        return undefined;
+    return JSON.parse(await readFile(path.join(targetDir, "package.json"), "utf8"));
+}
+async function assertDirectory(targetDir) {
+    try {
+        const stats = await stat(targetDir);
+        if (!stats.isDirectory()) {
+            throw new Error(`${targetDir} is not a directory.`);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes("not a directory")) {
+            throw error;
+        }
+        throw new Error(`Directory ${targetDir} does not exist.`);
+    }
+}
+async function listFiles(targetDir) {
+    const files = [];
+    async function visit(relativeDir) {
+        const absoluteDir = path.join(targetDir, relativeDir);
+        const entries = await readdir(absoluteDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name === "node_modules" ||
+                entry.name === ".next" ||
+                entry.name === ".git" ||
+                entry.name === ".turbo" ||
+                entry.name === "coverage" ||
+                entry.name === "dist") {
+                continue;
+            }
+            const relativePath = normalizePath(path.join(relativeDir, entry.name));
+            if (entry.isDirectory()) {
+                await visit(relativePath);
+            }
+            else if (entry.isFile()) {
+                files.push(relativePath);
+            }
+        }
+    }
+    await visit("");
+    return files.sort();
+}
+async function readCachedSource(targetDir, file, sourceCache) {
+    const cached = sourceCache.get(file);
+    if (cached !== undefined)
+        return cached;
+    const source = await readFile(path.join(targetDir, file), "utf8");
+    sourceCache.set(file, source);
+    return source;
+}
+export function serverProviderFiles(files, config) {
+    const serverDir = directoryPath(path.dirname(config.paths.server));
+    const candidates = [`${serverDir}/providers.ts`, config.paths.server];
+    return candidates.filter((file) => files.includes(file));
+}
+function extractProviderListSource(source) {
+    const listMatches = [
+        ...source.matchAll(/\bproviders\s*=\s*\[([\s\S]*?)\]\s*(?:;|as const)/g),
+        ...source.matchAll(/\bproviders\s*:\s*\[([\s\S]*?)\]/g),
+    ];
+    if (listMatches.length === 0)
+        return undefined;
+    return listMatches.map((match) => match[1]).join("\n");
+}
+function providerListEntries(source) {
+    const entries = [];
+    let current = "";
+    let depth = 0;
+    let quote;
+    let escaped = false;
+    let lineComment = false;
+    let blockComment = false;
+    for (let index = 0; index < source.length; index += 1) {
+        const char = source[index];
+        const next = source[index + 1];
+        if (lineComment) {
+            if (char === "\n") {
+                lineComment = false;
+                current += char;
+            }
+            continue;
+        }
+        if (blockComment) {
+            if (char === "*" && next === "/") {
+                blockComment = false;
+                index += 1;
+            }
+            continue;
+        }
+        if (quote) {
+            current += char;
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (char === "\\") {
+                escaped = true;
+                continue;
+            }
+            if (char === quote) {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (char === "/" && next === "/") {
+            lineComment = true;
+            index += 1;
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            blockComment = true;
+            index += 1;
+            continue;
+        }
+        if (char === '"' || char === "'" || char === "`") {
+            quote = char;
+            current += char;
+            continue;
+        }
+        if (char === "(" || char === "[" || char === "{") {
+            depth += 1;
+        }
+        else if (char === ")" || char === "]" || char === "}") {
+            depth = Math.max(0, depth - 1);
+        }
+        if (char === "," && depth === 0) {
+            const entry = current.trim();
+            if (entry)
+                entries.push(entry);
+            current = "";
+            continue;
+        }
+        current += char;
+    }
+    const entry = current.trim();
+    if (entry)
+        entries.push(entry);
+    return entries;
+}
+function metadataSourcePath(targetDir, file) {
+    const targetRelative = normalizePath(path.relative(targetDir, file));
+    if (!targetRelative.startsWith("../"))
+        return targetRelative;
+    const cwdRelative = normalizePath(path.relative(process.cwd(), file));
+    return cwdRelative.startsWith("../") ? file : cwdRelative;
+}
+function isInfraOrServerFile(file, config) {
+    const serverDir = directoryPath(path.dirname(config.paths.server));
+    const infrastructureDir = directoryPath(path.dirname(config.paths.infrastructurePorts));
+    return (file === config.paths.server ||
+        file.startsWith(`${serverDir}/`) ||
+        file === config.paths.infrastructurePorts ||
+        file.startsWith(`${infrastructureDir}/`));
+}
+function isTestSourceFile(file) {
+    return (file.endsWith(".test.ts") ||
+        file.endsWith(".spec.ts") ||
+        file.includes("/tests/"));
+}
+function sourceCreatesTable(source, tableName) {
+    return new RegExp(`\\bCREATE\\s+TABLE\\b[\\s\\S]{0,200}${escapeRegExp(tableName)}\\b`, "i").test(source);
+}
+function sourceDeclaresSchemaTable(source, tableName) {
+    return (sourceDeclaresDrizzleTable(source, tableName) ||
+        sourceReexportsBeignetProviderSchemaTable(source, tableName));
+}
+function sourceDeclaresDrizzleTable(source, tableName) {
+    const quotedTableName = `["'\`]${escapeRegExp(tableName)}["'\`]`;
+    const declarationPatterns = [
+        `\\b(?:sqliteTable|pgTable|mysqlTable)\\s*\\(\\s*${quotedTableName}`,
+        `\\b[A-Za-z_$][\\w$]*Table\\s*\\(\\s*${quotedTableName}`,
+        `\\.table\\s*\\(\\s*${quotedTableName}`,
+    ];
+    return declarationPatterns.some((pattern) => new RegExp(pattern).test(source));
+}
+function sourceReexportsBeignetProviderSchemaTable(source, tableName) {
+    const exportName = beignetProviderSchemaExportName(tableName);
+    if (!exportName)
+        return false;
+    return new RegExp(`\\bexport\\s*\\{[\\s\\S]{0,400}\\b${escapeRegExp(exportName)}\\b[\\s\\S]{0,400}\\}\\s*from\\s*["']@beignet/provider-db-drizzle/(?:sqlite|postgres|mysql)/schema["']`).test(source);
+}
+function beignetProviderSchemaExportName(tableName) {
+    if (tableName === "audit_log")
+        return "auditLog";
+    if (tableName === "idempotency_records")
+        return "idempotencyRecords";
+    if (tableName === "outbox_messages")
+        return "outboxMessages";
+    return undefined;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function requirementSummary(requirement) {
+    if (requirement.status === "none")
+        return "none";
+    if (requirement.status === "inactive")
+        return "inactive";
+    if (requirement.status === "present") {
+        return `${requirement.required.length} ok`;
+    }
+    return `${requirement.missing.length}/${requirement.required.length} missing`;
+}
+function appPortsSummary(appPorts) {
+    if (appPorts.status === "none")
+        return "none";
+    if (appPorts.status === "present")
+        return `${appPorts.required.length} ok`;
+    return `${appPorts.missing.length}/${appPorts.required.length} missing`;
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function table(rows) {
+    const widths = rows[0].map((_, columnIndex) => Math.max(...rows.map((row) => row[columnIndex].length)));
+    return rows
+        .map((row) => row
+        .map((cell, columnIndex) => cell.padEnd(widths[columnIndex]))
+        .join("  ")
+        .trimEnd())
+        .join("\n");
+}
+//# sourceMappingURL=provider-audit.js.map