@empline/preflight 1.1.11 → 1.1.13

package/dist/checks/core/database.js

@@ -0,0 +1,699 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Database Preflight Checks
+ * Comprehensive database validation for SuperCatch platform
+ */
+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 });
+const dotenv_1 = require("dotenv");
+const console_chars_1 = require("../../utils/console-chars");
+const file_scanner_1 = require("../../utils/file-scanner");
+const preflight_runner_1 = require("../../utils/preflight-runner");
+// Load environment variables from .env.local
+(0, dotenv_1.config)({ path: ".env.local" });
+// Helper function to find and read Prisma schema
+async function findAndReadSchema(scanner) {
+    // Try scanner first
+    let schemaFile = await scanner.findFiles(/prisma\/schema\.prisma$/);
+    if (schemaFile.length > 0) {
+        const content = await scanner.readFileContent(schemaFile[0].path);
+        if (content) {
+            return { content, path: schemaFile[0].path };
+        }
+    }
+    // Try alternative paths
+    const { readFile } = await Promise.resolve().then(() => __importStar(require("fs/promises")));
+    const { join } = await Promise.resolve().then(() => __importStar(require("path")));
+    const possiblePaths = [
+        "prisma/schema.prisma",
+        "../../../prisma/schema.prisma",
+        join(process.cwd(), "prisma/schema.prisma"),
+    ];
+    for (const path of possiblePaths) {
+        try {
+            const content = await readFile(path, "utf-8");
+            return { content, path };
+        }
+        catch (error) {
+            // Continue to next path
+        }
+    }
+    return null;
+}
+function extractModelBlocks(schema) {
+    const models = [];
+    const lines = schema.split("\n");
+    let currentName = null;
+    let braceDepth = 0;
+    let buffer = [];
+    for (const line of lines) {
+        if (currentName === null) {
+            const match = line.match(/^\s*model\s+(\w+)\s*\{/);
+            if (match) {
+                currentName = match[1];
+                braceDepth = (line.match(/\{/g) || []).length - (line.match(/\}/g) || []).length;
+                const afterBraceIndex = line.indexOf("{") + 1;
+                const afterBrace = line.slice(afterBraceIndex).trim();
+                if (afterBrace) {
+                    buffer.push(afterBrace);
+                }
+            }
+            continue;
+        }
+        braceDepth += (line.match(/\{/g) || []).length;
+        braceDepth -= (line.match(/\}/g) || []).length;
+        if (braceDepth <= 0) {
+            models.push({ name: currentName, block: buffer.join("\n") });
+            currentName = null;
+            buffer = [];
+            braceDepth = 0;
+            continue;
+        }
+        buffer.push(line);
+    }
+    return models;
+}
+function isAnalyticsTimeSeriesModel(model) {
+    if (model.name.startsWith("Analytics")) {
+        return true;
+    }
+    const mapMatch = model.block.match(/@@map\("([^"]+)"\)/);
+    return Boolean(mapMatch && mapMatch[1]?.startsWith("analytics_"));
+}
+function validateAnalyticsModel(model) {
+    const violations = [];
+    const lines = model.block.split("\n");
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("@@") || line.startsWith("//")) {
+            continue;
+        }
+        const fieldMatch = line.match(/^(\w+)/);
+        if (!fieldMatch) {
+            continue;
+        }
+        const fieldName = fieldMatch[1];
+        // Skip Prisma directives that might slip through
+        if (fieldName.startsWith("@")) {
+            continue;
+        }
+        // Check for snake_case field names (should use camelCase)
+        if (fieldName.includes("_")) {
+            violations.push(`Analytics model ${model.name}.${fieldName} should use camelCase field names.`);
+        }
+        // NOTE: @map() annotations are NOT required - Prisma handles snake_case mapping automatically
+    }
+    return violations;
+}
+async function runDatabasePreflights() {
+    const runner = new preflight_runner_1.PreflightRunner(true);
+    const scanner = new file_scanner_1.FileScanner();
+    // Database Connection (Schema-based validation only)
+    runner.addCheck((0, preflight_runner_1.createCheck)("Database Configuration", "Validate database configuration and environment variables", async () => {
+        const errors = [];
+        const warnings = [];
+        const info = [];
+        // Check for DATABASE_URL - warning only since schema validation works without it
+        if (!process.env.DATABASE_URL) {
+            warnings.push("DATABASE_URL environment variable is not set - database connectivity not verified");
+            info.push(`${console_chars_1.emoji.info} Schema validation will still run without database connection`);
+        }
+        else {
+            info.push("${chars.check} DATABASE_URL environment variable is configured");
+        }
+        // Check for SHADOW_DATABASE_URL (optional but recommended)
+        if (!process.env.SHADOW_DATABASE_URL) {
+            warnings.push("SHADOW_DATABASE_URL not set - migrations may be slower");
+        }
+        else {
+            info.push("✓ SHADOW_DATABASE_URL environment variable is configured");
+        }
+        return {
+            passed: true, // Always pass - missing DATABASE_URL is a warning, not an error
+            errors,
+            warnings,
+            info,
+        };
+    }, true));
+    // Prisma Schema Validation
+    runner.addCheck((0, preflight_runner_1.createCheck)("Prisma Schema Validation", "Validate Prisma schema structure and conventions", async () => {
+        const errors = [];
+        const warnings = [];
+        const info = [];
+        const schemaResult = await findAndReadSchema(scanner);
+        if (!schemaResult) {
+            errors.push("Prisma schema file not found");
+            return { passed: false, errors, warnings };
+        }
+        const { content, path } = schemaResult;
+        info.push(`✓ Found Prisma schema at: ${path}`);
+        if (!content) {
+            errors.push("Could not read Prisma schema file");
+            return { passed: false, errors, warnings };
+        }
+        // Check for required configurations
+        if (!content.includes("generator client")) {
+            errors.push("Missing Prisma client generator");
+        }
+        else {
+            info.push("${chars.check} Prisma client generator configured");
+        }
+        if (!content.includes("datasource db")) {
+            errors.push("Missing database datasource");
+        }
+        else {
+            info.push("✓ Database datasource configured");
+        }
+        // Check for SuperCatch-specific core models (current Prisma model names)
+        const requiredCoreModels = [
+            "User",
+            "Store",
+            "Listing",
+            "Order",
+            "SportsCard",
+            "RecognitionJob",
+        ];
+        const requiredCatalogModels = [
+            "VideoGame",
+            "TcgCard",
+            "Autograph",
+            "Ticket",
+            "Memorabilia",
+            "NonSportsCard",
+        ];
+        const requiredJobModels = ["JobsIntegration", "jobsImport", "jobsExport"];
+        const hasModel = (modelName) => new RegExp(`model\\s+${modelName}\\b`).test(content);
+        // Check core business models
+        for (const model of requiredCoreModels) {
+            if (hasModel(model)) {
+                info.push(`${console_chars_1.chars.check} Core model ${model} found`);
+            }
+            else {
+                errors.push(`Critical model ${model} not found - required for SuperCatch functionality`);
+            }
+        }
+        // Check catalog models
+        let catalogModelsFound = 0;
+        for (const model of requiredCatalogModels) {
+            if (hasModel(model)) {
+                info.push(`${console_chars_1.chars.check} Catalog model ${model} found`);
+                catalogModelsFound++;
+            }
+        }
+        if (catalogModelsFound === 0) {
+            warnings.push("No catalog models found - may be expected for minimal deployment");
+        }
+        else {
+            info.push(`${console_chars_1.chars.check} Found ${catalogModelsFound}/${requiredCatalogModels.length} catalog models`);
+        }
+        // Check job models
+        let jobModelsFound = 0;
+        for (const model of requiredJobModels) {
+            if (hasModel(model)) {
+                info.push(`${console_chars_1.chars.check} Job model ${model} found`);
+                jobModelsFound++;
+            }
+        }
+        if (jobModelsFound === 0) {
+            warnings.push("No job models found - integrations may not be available");
+        }
+        else {
+            info.push(`${console_chars_1.chars.check} Found ${jobModelsFound}/${requiredJobModels.length} job models`);
+        }
+        // Check for proper ID strategy (Crockford Base32)
+        // NOTE: Analytics models may use cuid() for simplicity - that's acceptable
+        const idPattern = /@id @default\(cuid\(\)\)/g;
+        const cuidMatches = content.match(idPattern);
+        if (cuidMatches && cuidMatches.length > 0) {
+            // Downgrade from error to warning - analytics models may use cuid() for simplicity
+            warnings.push(`Found ${cuidMatches.length} CUID usage(s) - core models should use Crockford Base32 (analytics models may use cuid)`);
+        }
+        else {
+            info.push("${chars.check} No CUID usage detected");
+        }
+        // Check for proper indexing
+        if (content.includes("@@index")) {
+            info.push("✓ Database indexes configured");
+        }
+        else {
+            warnings.push("No database indexes found - consider adding for performance");
+        }
+        // Enforce analytics time-series naming conventions
+        const parsedModels = extractModelBlocks(content);
+        const analyticsModels = parsedModels.filter(isAnalyticsTimeSeriesModel);
+        if (analyticsModels.length > 0) {
+            info.push(`✓ Found ${analyticsModels.length} analytics time-series model(s)`);
+            let analyticsViolations = 0;
+            for (const model of analyticsModels) {
+                const violations = validateAnalyticsModel(model);
+                analyticsViolations += violations.length;
+                if (violations.length > 0) {
+                    errors.push(...violations);
+                }
+            }
+            if (analyticsViolations === 0) {
+                info.push("${chars.check} Analytics models use proper camelCase field naming");
+            }
+        }
+        // NOTE: @@map() and @map() are NOT required - Prisma handles table/column naming automatically
+        // We only validate that model names follow PascalCase convention
+        const scalarTypes = new Set([
+            "String",
+            "Int",
+            "Float",
+            "Decimal",
+            "Boolean",
+            "DateTime",
+            "Json",
+            "Bytes",
+            "BigInt",
+        ]);
+        // Validate model naming conventions (PascalCase)
+        for (const model of parsedModels) {
+            // Check model name is PascalCase
+            if (!/^[A-Z][a-zA-Z0-9]*$/.test(model.name)) {
+                warnings.push(`Model ${model.name} should use PascalCase naming`);
+            }
+        }
+        info.push("${chars.check} Prisma models validated (@@map/@map not required)");
+        return { passed: errors.length === 0, errors, warnings, info };
+    }));
+    // Migration Status
+    runner.addCheck((0, preflight_runner_1.createCheck)("Migration Status", "Check database migration status", async () => {
+        const errors = [];
+        const warnings = [];
+        const info = [];
+        try {
+            const { execSync } = await Promise.resolve().then(() => __importStar(require("child_process")));
+            // Check migration status (requires shadow database in some environments)
+            const output = execSync("npx prisma migrate status", {
+                encoding: "utf-8",
+                stdio: "pipe",
+            });
+            if (output.includes("Database is up to date")) {
+                info.push("✓ Database migrations are up to date");
+            }
+            else if (output.includes("pending migration")) {
+                warnings.push("Pending database migrations detected");
+            }
+        }
+        catch (error) {
+            // Migration status check failed - this is normal in production environments
+            // without shadow database access. Skip warning in production.
+            const isProduction = process.env.NODE_ENV === "production" || process.env.VERCEL_ENV === "production";
+            if (!isProduction) {
+                info.push(`${console_chars_1.emoji.info} Migration status check skipped (requires shadow database)`);
+            }
+        }
+        return { passed: errors.length === 0, errors, warnings, info };
+    }));
+    // Database Constraints
+    runner.addCheck((0, preflight_runner_1.createCheck)("Database Constraints", "Validate database constraints and relationships", async () => {
+        const errors = [];
+        const warnings = [];
+        const info = [];
+        const schemaResult = await findAndReadSchema(scanner);
+        if (!schemaResult) {
+            return { passed: true, errors, warnings }; // Already checked in schema validation
+        }
+        const { content } = schemaResult;
+        // Check for foreign key relationships
+        const relationPattern = /@relation/g;
+        const relations = content.match(relationPattern);
+        if (relations) {
+            info.push(`${console_chars_1.chars.check} Found ${relations.length} database relationships`);
+        }
+        // Check for unique constraints
+        const uniquePattern = /@unique/g;
+        const uniqueConstraints = content.match(uniquePattern);
+        if (uniqueConstraints) {
+            info.push(`${console_chars_1.chars.check} Found ${uniqueConstraints.length} unique constraints`);
+        }
+        // Check for required fields
+        const requiredFields = content.match(/\s+\w+\s+\w+(?!\?)/g);
+        if (requiredFields) {
+            info.push(`${console_chars_1.chars.check} Found required field constraints`);
+        }
+        return { passed: errors.length === 0, errors, warnings, info };
+    }));
+    // Database Model/Table Name Consistency
+    runner.addCheck((0, preflight_runner_1.createCheck)("Database Model/Table Name Consistency", "Validate that code uses correct Prisma model names matching database tables", async () => {
+        const errors = [];
+        const warnings = [];
+        const info = [];
+        // Get Prisma schema to extract actual model names
+        const schemaResult = await findAndReadSchema(scanner);
+        if (!schemaResult) {
+            errors.push("Prisma schema file not found");
+            return { passed: false, errors, warnings };
+        }
+        const { content: schemaContent } = schemaResult;
+        // Extract actual model names from schema
+        const modelMatches = schemaContent.match(/^model\s+(\w+)\s*{/gm);
+        const actualModels = modelMatches
+            ? modelMatches.map((match) => match.match(/model\s+(\w+)/)?.[1]).filter(Boolean)
+            : [];
+        info.push(`${console_chars_1.chars.check} Found ${actualModels.length} models in schema: ${actualModels.join(", ")}`);
+        // Check TypeScript/JavaScript files for incorrect model usage
+        const codeFiles = await scanner.findFiles(/\.(ts|tsx|js|jsx)$/);
+        let totalViolations = 0;
+        for (const file of codeFiles) {
+            // Skip node_modules and other irrelevant directories
+            const pathLower = file.path.toLowerCase().replace(/\\/g, "/");
+            if (pathLower.includes("node_modules") ||
+                pathLower.includes(".next") ||
+                pathLower.includes("dist") ||
+                pathLower.includes(".git") ||
+                pathLower.includes("tests/") ||
+                pathLower.includes("__tests__/") ||
+                pathLower.includes(".test.") ||
+                pathLower.includes(".spec.") ||
+                pathLower.includes("scripts/") ||
+                pathLower.includes("docs/") ||
+                pathLower.includes("docs\\") ||
+                pathLower.includes(".kiro/steering-archive/") ||
+                pathLower.includes(".kiro\\steering-archive\\") ||
+                pathLower.includes(".kiro/steering/") ||
+                pathLower.includes(".kiro\\steering\\") ||
+                pathLower.includes("backups/") ||
+                pathLower.includes("backups\\")) {
+                continue;
+            }
+            const content = await scanner.readFileContent(file.path);
+            if (!content)
+                continue;
+            // Check for old incorrect model names that should be corrected to current schema names
+            const incorrectPatterns = [
+                {
+                    incorrect: "prisma.cardMasterCatalog",
+                    correct: "prisma.card",
+                    description: "Card catalog model",
+                },
+                {
+                    incorrect: "prisma.cardBrand",
+                    correct: "prisma.brand",
+                    description: "Card brand model",
+                },
+                {
+                    incorrect: "prisma.cardSeries",
+                    correct: "prisma.series",
+                    description: "Card series model",
+                },
+            ];
+            for (const pattern of incorrectPatterns) {
+                // Create a more precise regex that matches the exact model name, not partial matches
+                const escapedPattern = pattern.incorrect.replace(".", "\\.");
+                const regex = new RegExp(`\\b${escapedPattern}\\b(?!_)`, "g");
+                const matches = content.match(regex);
+                if (matches) {
+                    // Filter out matches that are actually correct (like prisma.userCollections containing "user")
+                    const actualMatches = matches.filter((match) => {
+                        const lines = content.split("\n");
+                        for (const line of lines) {
+                            if (line.includes(match)) {
+                                // Skip if it's part of a longer valid model name
+                                if (line.includes(`${match}_`) ||
+                                    line.includes("userCollections") ||
+                                    line.includes("userCollectionItems") ||
+                                    line.includes("userWishlistItems") ||
+                                    line.includes("seller_shipping_rules") ||
+                                    line.includes("authStores") ||
+                                    line.includes("authUser") ||
+                                    line.includes("coreListings") ||
+                                    line.includes("coreOrders") ||
+                                    line.includes("coreOrderItems") ||
+                                    line.includes("catalog_cards") ||
+                                    line.includes("catalogRecognitionJobs") ||
+                                    line.includes("jobsIntegration")) {
+                                    return false;
+                                }
+                            }
+                        }
+                        return true;
+                    });
+                    if (actualMatches.length > 0) {
+                        totalViolations += actualMatches.length;
+                        errors.push(`${file.path}: Found ${actualMatches.length} usage(s) of '${pattern.incorrect}' - should be '${pattern.correct}' (${pattern.description})`);
+                    }
+                }
+            }
+            // Check for any prisma.modelName that doesn't exist in schema
+            const prismaUsageRegex = /prisma\.([a-zA-Z_][a-zA-Z0-9_]*)/g;
+            let match;
+            while ((match = prismaUsageRegex.exec(content)) !== null) {
+                const modelName = match[1] || "";
+                // Skip known valid patterns that aren't models
+                if ([
+                    "$connect",
+                    "$disconnect",
+                    "$transaction",
+                    "$executeRaw",
+                    "$queryRaw",
+                    "$executeRawUnsafe",
+                    "$queryRawUnsafe",
+                ].includes(modelName)) {
+                    continue;
+                }
+                // Prisma generates camelCase model names in code, so check both PascalCase and camelCase
+                const pascalCase = modelName[0].toUpperCase() + modelName.slice(1);
+                const camelCase = modelName[0].toLowerCase() + modelName.slice(1);
+                if (!actualModels.includes(modelName) &&
+                    !actualModels.includes(pascalCase) &&
+                    !actualModels.includes(camelCase)) {
+                    errors.push(`${file.path}: Uses 'prisma.${modelName}' but model '${modelName}' not found in schema. Available models: ${actualModels.join(", ")}`);
+                    totalViolations++;
+                }
+            }
+        }
+        if (totalViolations === 0) {
+            info.push("${chars.check} All Prisma model usage matches schema definitions");
+        }
+        else {
+            errors.push(`Found ${totalViolations} total model name violations across ${errors.length} files`);
+        }
+        return { passed: errors.length === 0, errors, warnings, info };
+    }, true));
+    // SuperCatch-Specific Database Checks
+    runner.addCheck((0, preflight_runner_1.createCheck)("SuperCatch Database Rules", "Validate SuperCatch-specific database patterns and table organization", async () => {
+        const errors = [];
+        const warnings = [];
+        const info = [];
+        const schemaResult = await findAndReadSchema(scanner);
+        if (!schemaResult) {
+            return { passed: true, errors, warnings };
+        }
+        const { content } = schemaResult;
+        const hasModel = (modelName) => new RegExp(`model\\s+${modelName}\\b`).test(content);
+        // Check for proper domain organization using current model names
+        const modelGroups = {
+            "Core commerce": {
+                models: [
+                    "Listing",
+                    "Order",
+                    "OrderItem",
+                    "DuplicateListing",
+                    "ListingHistory",
+                    "PriceHistory",
+                ],
+                critical: true,
+            },
+            Catalog: {
+                models: [
+                    "Card",
+                    "VideoGame",
+                    "TcgCard",
+                    "Autograph",
+                    "Ticket",
+                    "Memorabilia",
+                    "RecognitionJob",
+                ],
+                critical: true,
+            },
+            Authentication: {
+                models: [
+                    "User",
+                    "Seller",
+                    "Account",
+                    "Organization",
+                    "Session",
+                    "VerificationToken",
+                    "StoreNotification",
+                ],
+                critical: true,
+            },
+            Collections: {
+                models: [
+                    "UserCollection",
+                    "UserCollectionItem",
+                    "UserWishlistItem",
+                    "UserSavedSearch",
+                    "userRecentlyViewed",
+                ],
+            },
+            Reference: {
+                models: [
+                    "Brand",
+                    "Series",
+                    "Material",
+                    "Language",
+                    "Country",
+                    "GradingCompany",
+                    "League",
+                    "Team",
+                    "Size",
+                ],
+            },
+            Jobs: {
+                models: [
+                    "JobsIntegration",
+                    "JobsIntegrationConfig",
+                    "jobsIntegrationHistory",
+                    "JobsIntegrationOauth",
+                    "jobsImport",
+                    "jobsExport",
+                ],
+            },
+            Analytics: {
+                models: ["AnalyticsListingViewsTs", "AnalyticsSearchQueriesTs"],
+            },
+            System: {
+                models: [
+                    "SystemDuplicateReport",
+                    "systemImageUsageTracking",
+                    "SystemBrandCache",
+                    "SystemSetting",
+                    "SystemAuditLog",
+                ],
+            },
+            Email: {
+                models: ["EmailTemplate"],
+            },
+        };
+        let totalModelsFound = 0;
+        let totalModelsExpected = 0;
+        for (const [groupName, group] of Object.entries(modelGroups)) {
+            const foundInGroup = group.models.filter(hasModel);
+            totalModelsExpected += group.models.length;
+            totalModelsFound += foundInGroup.length;
+            if (foundInGroup.length > 0) {
+                info.push(`${console_chars_1.chars.check} ${groupName}: ${foundInGroup.length}/${group.models.length} models present`);
+            }
+            else if (group.critical) {
+                warnings.push(`No ${groupName.toLowerCase()} models found - critical for SuperCatch functionality`);
+            }
+            else {
+                info.push(`${console_chars_1.chars.bullet} ${groupName}: 0/${group.models.length} models detected`);
+            }
+        }
+        info.push(`${console_chars_1.chars.check} Total tracked Prisma models: ${totalModelsFound}/${totalModelsExpected}`);
+        // Check for proper indexing patterns
+        const criticalIndexes = [
+            "idx_listing_status",
+            "idx_listing_seller",
+            "idx_user_email",
+            "idx_recognition_status",
+        ];
+        let indexesFound = 0;
+        for (const index of criticalIndexes) {
+            if (content.includes(index)) {
+                indexesFound++;
+            }
+        }
+        if (indexesFound > 0) {
+            info.push(`${console_chars_1.chars.check} Critical indexes: ${indexesFound}/${criticalIndexes.length} found`);
+        }
+        else {
+            warnings.push("No critical database indexes found - performance may be impacted");
+        }
+        // Check for duplicate prevention patterns
+        const uniqueConstraints = content.match(/@@unique/g);
+        if (uniqueConstraints && uniqueConstraints.length > 0) {
+            info.push(`${console_chars_1.chars.check} Found ${uniqueConstraints.length} unique constraints for duplicate prevention`);
+        }
+        else {
+            warnings.push("No unique constraints found - consider adding for duplicate prevention");
+        }
+        // Check for proper enum usage
+        const enumPattern = /enum\s+(\w+)/g;
+        const enums = content.match(enumPattern);
+        if (enums && enums.length > 0) {
+            info.push(`${console_chars_1.chars.check} Found ${enums.length} enum definitions for type safety`);
+        }
+        else {
+            warnings.push("No enum definitions found - consider adding for type safety");
+        }
+        return { passed: errors.length === 0, errors, warnings, info };
+    }));
+    // Database Performance
+    runner.addCheck((0, preflight_runner_1.createCheck)("Database Performance", "Check for performance optimization patterns", async () => {
+        const errors = [];
+        const warnings = [];
+        const info = [];
+        const schemaResult = await findAndReadSchema(scanner);
+        if (!schemaResult) {
+            return { passed: true, errors, warnings };
+        }
+        const { content } = schemaResult;
+        // Check for indexes on frequently queried fields
+        const indexPatterns = ["status", "category", "createdAt", "updatedAt", "userId", "storeId"];
+        for (const field of indexPatterns) {
+            if (content.includes(`@@index([${field}])`) || content.includes(`@@index(${field})`)) {
+                info.push(`${console_chars_1.chars.check} Index found for ${field}`);
+            }
+        }
+        // Check for composite indexes
+        if (content.includes("@@index([") && content.includes(",")) {
+            info.push("${chars.check} Composite indexes configured");
+        }
+        else {
+            warnings.push("Consider adding composite indexes for complex queries");
+        }
+        return { passed: errors.length === 0, errors, warnings, info };
+    }));
+    const result = await runner.runAll();
+    if (!result.passed) {
+        console.log(`\n${console_chars_1.emoji.bell} Database preflight checks failed!`);
+        process.exit(1);
+    }
+    console.log(`\n${console_chars_1.emoji.database} All database preflight checks passed!`);
+    return result;
+}
+// Run if called directly
+if (require.main === module) {
+    runDatabasePreflights().catch(console.error);
+}
+exports.default = runDatabasePreflights;
+//# sourceMappingURL=database.js.map