@empline/preflight 1.1.0

package/dist/checks/database/prisma-overfetch-detection.d.ts

@@ -0,0 +1,27 @@
+#!/usr/bin/env tsx
+/**
+ * Prisma Over-Fetch Detection Preflight (Enhanced)
+ *
+ * Detects Prisma queries that fetch all columns when only a subset is needed.
+ * This prevents unnecessary data transfer and improves query performance.
+ *
+ * Features:
+ * 1. Column count threshold - Only flags tables with 15+ columns
+ * 2. Allowlist for legitimate full-fetches (admin exports, backups, soft-delete)
+ * 3. Duplicate query detection - Same table queried multiple times in one file
+ * 4. Field usage suggestions - Based on what's actually used after the query
+ *
+ * Usage:
+ *   pnpm preflight:prisma-overfetch
+ *   pnpm preflight:prisma-overfetch --verbose
+ *   pnpm preflight:prisma-overfetch --warning-only
+ *   pnpm preflight:prisma-overfetch --json
+ */
+export declare const id = "database/prisma-overfetch-detection";
+export declare const name = "Prisma Overfetch Detection";
+export declare const category = "database";
+export declare const blocking = true;
+export declare const description = "Prisma Over-Fetch Detection Preflight (Enhanced)";
+export declare const tags: string[];
+export declare function run(): Promise<void>;
+//# sourceMappingURL=prisma-overfetch-detection.d.ts.map

package/dist/checks/database/prisma-overfetch-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma-overfetch-detection.d.ts","sourceRoot":"","sources":["../../../src/checks/database/prisma-overfetch-detection.ts"],"names":[],"mappings":";AAEA;;;;;;;;;;;;;;;;;GAiBG;AASH,eAAO,MAAM,EAAE,wCAAwC,CAAC;AACxD,eAAO,MAAM,IAAI,+BAA+B,CAAC;AACjD,eAAO,MAAM,QAAQ,aAAa,CAAC;AACnC,eAAO,MAAM,QAAQ,OAAO,CAAC;AAC7B,eAAO,MAAM,WAAW,qDAAqD,CAAC;AAC9E,eAAO,MAAM,IAAI,UAAe,CAAC;AA4rBjC,wBAAsB,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAiEzC"}

package/dist/checks/database/prisma-overfetch-detection.js

@@ -0,0 +1,669 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Prisma Over-Fetch Detection Preflight (Enhanced)
+ *
+ * Detects Prisma queries that fetch all columns when only a subset is needed.
+ * This prevents unnecessary data transfer and improves query performance.
+ *
+ * Features:
+ * 1. Column count threshold - Only flags tables with 15+ columns
+ * 2. Allowlist for legitimate full-fetches (admin exports, backups, soft-delete)
+ * 3. Duplicate query detection - Same table queried multiple times in one file
+ * 4. Field usage suggestions - Based on what's actually used after the query
+ *
+ * Usage:
+ *   pnpm preflight:prisma-overfetch
+ *   pnpm preflight:prisma-overfetch --verbose
+ *   pnpm preflight:prisma-overfetch --warning-only
+ *   pnpm preflight:prisma-overfetch --json
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tags = exports.description = exports.blocking = exports.category = exports.name = exports.id = void 0;
+exports.run = run;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const console_chars_1 = require("../../utils/console-chars");
+const universal_progress_reporter_1 = require("../system/universal-progress-reporter");
+// Check metadata
+exports.id = "database/prisma-overfetch-detection";
+exports.name = "Prisma Overfetch Detection";
+exports.category = "database";
+exports.blocking = true;
+exports.description = "Prisma Over-Fetch Detection Preflight (Enhanced)";
+exports.tags = ["database"];
+const TABLE_CONFIGS = [
+    {
+        name: "authStores",
+        columnCount: 52,
+        commonFields: [
+            "id",
+            "userId",
+            "displayName",
+            "username",
+            "avatarUrl",
+            "rating",
+            "verified",
+            "active",
+            "approvalStatus",
+        ],
+    },
+    {
+        name: "authUser",
+        columnCount: 28,
+        commonFields: ["id", "name", "email", "image", "role", "emailVerified"],
+    },
+    {
+        name: "coreListings",
+        columnCount: 45,
+        commonFields: [
+            "id",
+            "slug",
+            "price",
+            "imageUrls",
+            "listingStatus",
+            "storeId",
+            "productType",
+            "condition",
+            "quantityAvailable",
+        ],
+    },
+    {
+        name: "coreOrders",
+        columnCount: 35,
+        commonFields: ["id", "orderNumber", "status", "totalAmount", "buyerId", "createdAt"],
+    },
+    {
+        name: "catalogSportsCards",
+        columnCount: 38,
+        commonFields: ["id", "playerName", "year", "brand", "series", "cardNumber", "category"],
+    },
+    {
+        name: "catalogTcgCards",
+        columnCount: 32,
+        commonFields: ["id", "cardName", "setName", "cardNumber", "rarity", "category"],
+    },
+    {
+        name: "catalogNonSportsCards",
+        columnCount: 30,
+        commonFields: ["id", "characterName", "year", "brand", "series", "category"],
+    },
+    {
+        name: "storeTeamMember",
+        columnCount: 12,
+        commonFields: ["id", "storeId", "userId", "role", "status"],
+    },
+    {
+        name: "storeTeamInvitation",
+        columnCount: 14,
+        commonFields: ["id", "storeId", "email", "role", "status", "expiresAt"],
+    },
+];
+// Minimum columns to consider a table "large" enough to warrant select
+const COLUMN_THRESHOLD = 15;
+// Get tables that exceed the threshold
+const LARGE_TABLES = TABLE_CONFIGS.filter((t) => t.columnCount >= COLUMN_THRESHOLD).map((t) => t.name);
+const ALLOWLIST_PATHS = [
+    { pattern: /admin.*export/i, reason: "Admin export needs all fields" },
+    { pattern: /admin.*backup/i, reason: "Backup needs all fields" },
+    { pattern: /soft-delete/i, reason: "Soft delete operations need full record" },
+    { pattern: /prisma-soft-delete/i, reason: "Soft delete helper" },
+    { pattern: /migration/i, reason: "Migration scripts" },
+    { pattern: /seed/i, reason: "Seed scripts" },
+    { pattern: /cron.*cleanup/i, reason: "Cleanup jobs may need full records" },
+    { pattern: /e2e.*util/i, reason: "E2E test utilities" },
+];
+const ALLOWLIST_COMMENTS = [
+    "// prisma-overfetch-ignore",
+    "// @prisma-overfetch-ignore",
+    "/* prisma-overfetch-ignore */",
+];
+// TYPES
+const QUERY_METHODS = [
+    "findMany",
+    "findFirst",
+    "findUnique",
+    "findFirstOrThrow",
+    "findUniqueOrThrow",
+];
+// HELPERS
+function parseArgs() {
+    const args = process.argv.slice(2);
+    return {
+        verbose: args.includes("--verbose") || args.includes("-v"),
+        warningOnly: args.includes("--warning-only") || args.includes("-w"),
+        json: args.includes("--json"),
+    };
+}
+function getSourceFiles() {
+    const extensions = ["ts", "tsx"];
+    const searchDirs = ["app", "lib", "components", "hooks", "contexts"];
+    const files = [];
+    const walkDir = (currentPath) => {
+        if (!fs.existsSync(currentPath))
+            return;
+        const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentPath, entry.name);
+            if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+                walkDir(fullPath);
+            }
+            else if (entry.isFile() && extensions.some((ext) => entry.name.endsWith(`.${ext}`))) {
+                files.push(path.relative(process.cwd(), fullPath));
+            }
+        }
+    };
+    for (const dir of searchDirs) {
+        const dirPath = path.join(process.cwd(), dir);
+        walkDir(dirPath);
+    }
+    return [...new Set(files)];
+}
+function isAllowlisted(filePath, lineContent, surroundingLines) {
+    // Check path patterns
+    for (const entry of ALLOWLIST_PATHS) {
+        if (typeof entry.pattern === "string") {
+            if (filePath.includes(entry.pattern))
+                return true;
+        }
+        else if (entry.pattern.test(filePath)) {
+            return true;
+        }
+    }
+    // Check for ignore comments
+    for (const comment of ALLOWLIST_COMMENTS) {
+        if (lineContent.includes(comment))
+            return true;
+        for (const line of surroundingLines) {
+            if (line.includes(comment))
+                return true;
+        }
+    }
+    return false;
+}
+function extractQueryContext(content, matchIndex) {
+    const start = Math.max(0, matchIndex - 200);
+    const end = Math.min(content.length, matchIndex + 1500);
+    return content.slice(start, end);
+}
+function hasSelectClause(context) {
+    // Look for select clause - it should appear before the closing of the query
+    const selectIndex = context.search(/select\s*:\s*\{/);
+    const includeIndex = context.search(/include\s*:\s*\{/);
+    // If select appears and either no include or select comes first
+    if (selectIndex !== -1 && (includeIndex === -1 || selectIndex < includeIndex)) {
+        return true;
+    }
+    // Check for select: true/false pattern
+    if (/select\s*:\s*(true|false)/.test(context)) {
+        return true;
+    }
+    // Also check for select with newlines/whitespace between : and {
+    if (/select\s*:\s*[\n\r\s]*\{/.test(context)) {
+        return true;
+    }
+    // Check for select with function call pattern (e.g., select: getListingSelect())
+    if (/select\s*:\s*[a-zA-Z_][a-zA-Z0-9_]*\s*\(/.test(context)) {
+        return true;
+    }
+    // Check for select with variable reference (e.g., select: listingSelect)
+    if (/select\s*:\s*[a-zA-Z_][a-zA-Z0-9_]*\s*[,}\n]/.test(context)) {
+        return true;
+    }
+    return false;
+}
+function isInTestFile(filePath) {
+    return (filePath.includes(".test.") ||
+        filePath.includes(".spec.") ||
+        filePath.includes("__tests__") ||
+        filePath.includes("__mocks__"));
+}
+function getTableConfig(tableName) {
+    return TABLE_CONFIGS.find((t) => t.name.toLowerCase() === tableName.toLowerCase());
+}
+// Keywords that look like functions but aren't
+const NON_FUNCTION_KEYWORDS = new Set([
+    "catch",
+    "try",
+    "if",
+    "else",
+    "for",
+    "while",
+    "switch",
+    "with",
+    "do",
+]);
+function detectFunctionScopes(content) {
+    const scopes = [];
+    const lines = content.split("\n");
+    // Match function declarations, arrow functions, and methods
+    const functionPatterns = [
+        /(?:async\s+)?function\s+(\w+)\s*\(/g,
+        /(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s*)?\([^)]*\)\s*(?::\s*[^=]+)?\s*=>/g,
+        /(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s*)?function/g,
+        /(?:async\s+)?(\w+)\s*\([^)]*\)\s*(?::\s*[^{]+)?\s*\{/g, // class methods
+    ];
+    let lineNumber = 0;
+    let braceDepth = 0;
+    let currentFunction = null;
+    for (const line of lines) {
+        lineNumber++;
+        // Check for function start
+        if (!currentFunction) {
+            for (const pattern of functionPatterns) {
+                pattern.lastIndex = 0;
+                const match = pattern.exec(line);
+                if (match && match[1] && !NON_FUNCTION_KEYWORDS.has(match[1])) {
+                    currentFunction = { name: match[1], startLine: lineNumber };
+                    braceDepth = 0;
+                    break;
+                }
+            }
+        }
+        // Track brace depth
+        if (currentFunction) {
+            for (const char of line) {
+                if (char === "{")
+                    braceDepth++;
+                if (char === "}") {
+                    braceDepth--;
+                    if (braceDepth === 0) {
+                        scopes.push({
+                            name: currentFunction.name,
+                            startLine: currentFunction.startLine,
+                            endLine: lineNumber,
+                        });
+                        currentFunction = null;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    return scopes;
+}
+function getFunctionAtLine(scopes, lineNumber) {
+    for (const scope of scopes) {
+        if (lineNumber >= scope.startLine && lineNumber <= scope.endLine) {
+            return scope.name;
+        }
+    }
+    return null;
+}
+// FIELD USAGE DETECTION
+function detectUsedFields(content, variableName, tableName) {
+    const usedFields = new Set();
+    const tableConfig = getTableConfig(tableName);
+    if (!tableConfig)
+        return [];
+    // Common access patterns: variable.field, variable?.field, variable["field"]
+    const patterns = [
+        new RegExp(`${variableName}\\.([a-zA-Z_][a-zA-Z0-9_]*)`, "g"),
+        new RegExp(`${variableName}\\?\\.([a-zA-Z_][a-zA-Z0-9_]*)`, "g"),
+        new RegExp(`${variableName}\\["([a-zA-Z_][a-zA-Z0-9_]*)"\\]`, "g"),
+        new RegExp(`${variableName}\\['([a-zA-Z_][a-zA-Z0-9_]*)'\\]`, "g"),
+    ];
+    for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(content)) !== null) {
+            const field = match[1];
+            // Only include if it's a known common field
+            if (tableConfig.commonFields.includes(field)) {
+                usedFields.add(field);
+            }
+        }
+    }
+    // Always suggest id
+    usedFields.add("id");
+    return [...usedFields].sort();
+}
+function extractVariableName(context) {
+    // Match: const varName = await prisma... or let varName = await prisma...
+    const patterns = [
+        /(?:const|let|var)\s+(\w+)\s*=\s*(?:await\s+)?prisma\./,
+        /(\w+)\s*=\s*(?:await\s+)?prisma\./,
+    ];
+    for (const pattern of patterns) {
+        const match = pattern.exec(context);
+        if (match)
+            return match[1];
+    }
+    return null;
+}
+// ANALYSIS
+function analyzeFile(filePath, config) {
+    const issues = [];
+    const queryLocations = new Map(); // table -> line numbers with function context
+    const fullPath = path.join(process.cwd(), filePath);
+    if (!fs.existsSync(fullPath))
+        return { issues, duplicates: [] };
+    if (isInTestFile(filePath)) {
+        return { issues, duplicates: [] };
+    }
+    const content = fs.readFileSync(fullPath, "utf8");
+    const lines = content.split("\n");
+    if (!content.includes("prisma."))
+        return { issues, duplicates: [] };
+    // Detect function scopes for smarter duplicate detection
+    const functionScopes = detectFunctionScopes(content);
+    for (const table of LARGE_TABLES) {
+        const tableConfig = getTableConfig(table);
+        for (const method of QUERY_METHODS) {
+            const pattern = new RegExp(`prisma\\.${table}\\.${method}\\s*\\(`, "g");
+            let match;
+            while ((match = pattern.exec(content)) !== null) {
+                const context = extractQueryContext(content, match.index);
+                const beforeMatch = content.slice(0, match.index);
+                const lineNumber = beforeMatch.split("\n").length;
+                const lineContent = lines[lineNumber - 1] || "";
+                // Get surrounding lines for allowlist check (lineNumber is 1-indexed, slice is 0-indexed)
+                const surroundingLines = lines.slice(Math.max(0, lineNumber - 4), Math.min(lines.length, lineNumber + 1));
+                // Check allowlist
+                if (isAllowlisted(filePath, lineContent, surroundingLines))
+                    continue;
+                // Skip if has select clause
+                if (hasSelectClause(context))
+                    continue;
+                // Skip count queries
+                if (context.includes("_count") || context.includes("count:"))
+                    continue;
+                // Track for duplicate detection with function context
+                const key = table;
+                const functionName = getFunctionAtLine(functionScopes, lineNumber);
+                if (!queryLocations.has(key)) {
+                    queryLocations.set(key, []);
+                }
+                queryLocations.get(key).push({ line: lineNumber, functionName });
+                // Detect used fields for suggestions
+                const variableName = extractVariableName(context);
+                let suggestedFields;
+                if (variableName && tableConfig) {
+                    const detected = detectUsedFields(content, variableName, table);
+                    if (detected.length > 0 && detected.length < tableConfig.columnCount) {
+                        suggestedFields = detected;
+                    }
+                    else {
+                        // Fall back to common fields
+                        suggestedFields = tableConfig.commonFields.slice(0, 6);
+                    }
+                }
+                const severity = method === "findMany" ? "error" : "warning";
+                issues.push({
+                    file: filePath,
+                    line: lineNumber,
+                    table,
+                    method,
+                    message: `${table}.${method}() without select - fetches ${tableConfig?.columnCount || "all"} columns`,
+                    severity,
+                    snippet: lineContent.trim().substring(0, 100),
+                    columnCount: tableConfig?.columnCount,
+                    suggestedFields,
+                });
+            }
+        }
+    }
+    // Detect duplicates - now with function awareness
+    const duplicates = [];
+    for (const [table, locations] of queryLocations) {
+        if (locations.length > 1) {
+            // Group by function
+            const byFunction = new Map();
+            for (const loc of locations) {
+                const key = loc.functionName;
+                if (!byFunction.has(key)) {
+                    byFunction.set(key, []);
+                }
+                byFunction.get(key).push(loc.line);
+            }
+            // Check if any function has multiple queries (actionable duplicate)
+            let isSameFunction = false;
+            let sameFunctionName;
+            for (const [funcName, funcLines] of byFunction) {
+                if (funcLines.length > 1 && funcName) {
+                    isSameFunction = true;
+                    sameFunctionName = funcName;
+                    break;
+                }
+            }
+            duplicates.push({
+                file: filePath,
+                table,
+                count: locations.length,
+                lines: locations.map((l) => l.line),
+                functionName: sameFunctionName,
+                isSameFunction,
+            });
+            // Only mark as duplicate if in same function (actionable)
+            if (isSameFunction) {
+                for (const issue of issues) {
+                    if (issue.file === filePath && issue.table === table) {
+                        issue.isDuplicate = true;
+                    }
+                }
+            }
+        }
+    }
+    return { issues, duplicates };
+}
+// OUTPUT
+function printIssue(issue, config) {
+    const icon = issue.severity === "error" ? console_chars_1.emoji.error : console_chars_1.emoji.warning;
+    const color = issue.severity === "error" ? "\x1b[31m" : "\x1b[33m";
+    const reset = "\x1b[0m";
+    const dim = "\x1b[2m";
+    let prefix = "";
+    if (issue.isDuplicate) {
+        prefix = `${console_chars_1.emoji.warning} `;
+    }
+    console.log(`${color}${prefix}${icon} ${issue.file}:${issue.line}${reset}`);
+    console.log(`   ${issue.message}`);
+    if (config.verbose && issue.snippet) {
+        console.log(`   ${dim}${issue.snippet}${reset}`);
+    }
+    if (issue.suggestedFields && issue.suggestedFields.length > 0) {
+        console.log(`   ${console_chars_1.emoji.hint} Suggested: select: { ${issue.suggestedFields.map((f) => `${f}: true`).join(", ")} }`);
+    }
+    console.log();
+}
+function printDuplicates(duplicates) {
+    if (duplicates.length === 0)
+        return;
+    const actionable = duplicates.filter((d) => d.isSameFunction);
+    const informational = duplicates.filter((d) => !d.isSameFunction);
+    if (actionable.length > 0) {
+        console.log(`\n${console_chars_1.emoji.warning} Actionable Duplicates (same function - consider consolidating):`);
+        for (const dup of actionable) {
+            console.log(`   ${dup.file}: ${dup.table} queried ${dup.count}x in ${dup.functionName}() (lines: ${dup.lines.join(", ")})`);
+        }
+    }
+    if (informational.length > 0 && actionable.length > 0) {
+        console.log(`\n${console_chars_1.emoji.info} Cross-Function Queries (different functions - usually OK):`);
+        for (const dup of informational) {
+            console.log(`   ${dup.file}: ${dup.table} queried ${dup.count}x across functions (lines: ${dup.lines.join(", ")})`);
+        }
+    }
+    else if (informational.length > 0) {
+        console.log(`\n${console_chars_1.emoji.info} Cross-Function Queries (different functions - usually OK):`);
+        for (const dup of informational) {
+            console.log(`   ${dup.file}: ${dup.table} queried ${dup.count}x across functions (lines: ${dup.lines.join(", ")})`);
+        }
+    }
+    console.log();
+}
+function printSummary(issues, duplicates, config) {
+    const errors = issues.filter((i) => i.severity === "error");
+    const warnings = issues.filter((i) => i.severity === "warning");
+    const actionableDuplicates = duplicates.filter((d) => d.isSameFunction);
+    const crossFunctionDuplicates = duplicates.filter((d) => !d.isSameFunction);
+    console.log("\n" + "=".repeat(70));
+    if (issues.length === 0) {
+        console.log(`${console_chars_1.emoji.success} No Prisma over-fetching issues detected`);
+    }
+    else {
+        console.log(`${console_chars_1.emoji.search} Prisma Over-Fetch Detection Results:`);
+        console.log(`   Errors:     ${errors.length} (findMany without select)`);
+        console.log(`   Warnings:   ${warnings.length} (findFirst/findUnique without select)`);
+        console.log(`   Actionable duplicates: ${actionableDuplicates.length} (same function - consolidate)`);
+        console.log(`   Cross-function queries: ${crossFunctionDuplicates.length} (different functions - OK)`);
+        // Group by table with column counts
+        const byTable = new Map();
+        for (const issue of issues) {
+            const existing = byTable.get(issue.table) || { count: 0, columns: issue.columnCount || 0 };
+            byTable.set(issue.table, {
+                count: existing.count + 1,
+                columns: issue.columnCount || existing.columns,
+            });
+        }
+        console.log("\n   By table (column count):");
+        for (const [table, info] of [...byTable.entries()].sort((a, b) => b[1].count - a[1].count)) {
+            console.log(`     ${table}: ${info.count} issues (${info.columns} columns)`);
+        }
+    }
+    console.log("\n" + "=".repeat(70));
+}
+function printFixSuggestions() {
+    console.log(`
+${console_chars_1.emoji.info} How to fix over-fetching:
+
+  ${console_chars_1.emoji.error} BAD - Fetches all 52 columns:
+  const store = await prisma.authStores.findFirst({
+    where: { username }
+  });
+
+  ${console_chars_1.emoji.success} GOOD - Fetches only needed columns:
+  const store = await prisma.authStores.findFirst({
+    where: { username },
+    select: {
+      id: true,
+      displayName: true,
+      username: true,
+      avatarUrl: true,
+      rating: true,
+      verified: true,
+    }
+  });
+
+  ${console_chars_1.emoji.info} To allowlist a query, add comment above it:
+  // prisma-overfetch-ignore - needs all fields for export
+  const store = await prisma.authStores.findFirst({ ... });
+
+  ${console_chars_1.emoji.info} Allowlisted paths: admin/**/export, admin/**/backup, **/soft-delete*, seed, migration
+`);
+}
+function printJsonOutput(issues, duplicates) {
+    const actionableDuplicates = duplicates.filter((d) => d.isSameFunction);
+    const crossFunctionDuplicates = duplicates.filter((d) => !d.isSameFunction);
+    const output = {
+        summary: {
+            totalIssues: issues.length,
+            errors: issues.filter((i) => i.severity === "error").length,
+            warnings: issues.filter((i) => i.severity === "warning").length,
+            actionableDuplicates: actionableDuplicates.length,
+            crossFunctionQueries: crossFunctionDuplicates.length,
+        },
+        issues: issues.map((i) => ({
+            file: i.file,
+            line: i.line,
+            table: i.table,
+            method: i.method,
+            severity: i.severity,
+            columnCount: i.columnCount,
+            suggestedFields: i.suggestedFields,
+            isDuplicate: i.isDuplicate,
+        })),
+        actionableDuplicates,
+        crossFunctionQueries: crossFunctionDuplicates,
+    };
+    console.log(JSON.stringify(output, null, 2));
+}
+// MAIN
+async function run() {
+    const reporter = (0, universal_progress_reporter_1.createUniversalProgressReporter)(exports.name);
+    const config = parseArgs();
+    if (!config.json) {
+        console.log(`${console_chars_1.emoji.search} Scanning for Prisma over-fetching issues...\n`);
+        console.log(`   Column threshold: ${COLUMN_THRESHOLD}+ columns`);
+        console.log(`   Tables checked: ${LARGE_TABLES.join(", ")}\n`);
+    }
+    const files = getSourceFiles();
+    if (config.verbose && !config.json) {
+        console.log(`Found ${files.length} files to scan\n`);
+    }
+    const allIssues = [];
+    const allDuplicates = [];
+    for (const file of files) {
+        const { issues, duplicates } = analyzeFile(file, config);
+        allIssues.push(...issues);
+        allDuplicates.push(...duplicates);
+    }
+    // Sort by severity (errors first) then by file
+    allIssues.sort((a, b) => {
+        if (a.severity !== b.severity) {
+            return a.severity === "error" ? -1 : 1;
+        }
+        return a.file.localeCompare(b.file);
+    });
+    if (config.json) {
+        printJsonOutput(allIssues, allDuplicates);
+        process.exit(allIssues.filter((i) => i.severity === "error").length > 0 && !config.warningOnly ? 1 : 0);
+    }
+    // Print issues
+    for (const issue of allIssues) {
+        printIssue(issue, config);
+    }
+    printDuplicates(allDuplicates);
+    printSummary(allIssues, allDuplicates, config);
+    const errors = allIssues.filter((i) => i.severity === "error");
+    if (errors.length > 0 && !config.warningOnly) {
+        printFixSuggestions();
+        console.log(`\n${console_chars_1.emoji.error} Preflight FAILED: ${errors.length} over-fetching error(s) found`);
+        console.log(`   Run with --warning-only to treat as warnings\n`);
+        process.exit(1);
+    }
+    if (allIssues.length > 0) {
+        printFixSuggestions();
+        console.log(`${console_chars_1.emoji.warning} Preflight passed with ${allIssues.length} warning(s)\n`);
+    }
+    else {
+        console.log(`${console_chars_1.emoji.success} Preflight PASSED\n`);
+    }
+    process.exit(0);
+}
+// Allow direct execution
+if (require.main === module) {
+    run().catch(console.error);
+}
+//# sourceMappingURL=prisma-overfetch-detection.js.map