@schemyx/mcp 0.1.1 → 0.1.2

package/dist/codebase-scanner/database.js

@@ -0,0 +1,1252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractDatabaseModels = extractDatabaseModels;
+exports.extractDatabaseEnums = extractDatabaseEnums;
+exports.extractDatabaseMigrations = extractDatabaseMigrations;
+exports.extractDatabaseAccesses = extractDatabaseAccesses;
+exports.detectDatabaseProvider = detectDatabaseProvider;
+exports.databaseExtractorForFile = databaseExtractorForFile;
+exports.databaseOperationToAccessOperation = databaseOperationToAccessOperation;
+const extractors_1 = require("./extractors");
+const utils_1 = require("./utils");
+const prismaScalarTypes = new Set([
+    'String',
+    'Boolean',
+    'Int',
+    'BigInt',
+    'Float',
+    'Decimal',
+    'DateTime',
+    'Json',
+    'Bytes',
+]);
+const readOperations = new Set([
+    'findUnique',
+    'findUniqueOrThrow',
+    'findFirst',
+    'findFirstOrThrow',
+    'findMany',
+    'count',
+    'aggregate',
+    'groupBy',
+]);
+const createOperations = new Set(['create', 'createMany']);
+const updateOperations = new Set(['update', 'updateMany']);
+const deleteOperations = new Set(['delete', 'deleteMany']);
+const upsertOperations = new Set(['upsert']);
+function extractDatabaseModels(relPath, content) {
+    return (0, utils_1.uniqueBy)([
+        ...extractPrismaDatabaseModels(relPath, content),
+        ...extractSqlDatabaseModels(relPath, content),
+        ...extractDrizzleDatabaseModels(relPath, content),
+        ...extractTypeOrmDatabaseModels(relPath, content),
+        ...extractSequelizeDatabaseModels(relPath, content),
+        ...extractMongooseDatabaseModels(relPath, content),
+        ...extractDjangoDatabaseModels(relPath, content),
+        ...extractRailsMigrationModels(relPath, content),
+        ...extractLaravelMigrationModels(relPath, content),
+    ], (model) => `${model.provider}:${model.name}:${model.tableName ?? ''}:${model.line}`).slice(0, 160);
+}
+function extractDatabaseEnums(relPath, content) {
+    return (0, utils_1.uniqueBy)([...extractPrismaDatabaseEnums(relPath, content), ...extractSqlDatabaseEnums(relPath, content)], (item) => `${item.provider}:${item.name}:${item.values.join('|')}`).slice(0, 120);
+}
+function extractDatabaseMigrations(relPath, content) {
+    const provider = detectDatabaseProvider(relPath, content);
+    const isMigration = provider === 'sql' ||
+        /(?:^|\/)(?:migrations?|db\/migrate|database\/migrations)(?:\/|$)/i.test(relPath) ||
+        /Schema::(?:create|table|drop)|create_table\s+:|add_column\s+:|ALTER\s+TABLE|CREATE\s+TABLE/i.test(content);
+    if (!isMigration) {
+        return [];
+    }
+    const operations = (0, utils_1.uniqueBy)([
+        ...extractSqlMigrationOperations(content),
+        ...extractRailsMigrationOperations(content),
+        ...extractLaravelMigrationOperations(content),
+    ], (operation) => `${operation.kind}:${operation.target ?? ''}:${operation.name ?? ''}:${operation.line}`).slice(0, 240);
+    if (!operations.length) {
+        return [];
+    }
+    return [
+        {
+            name: migrationNameFromPath(relPath),
+            path: relPath,
+            provider,
+            operations,
+            creates: (0, utils_1.unique)(operations
+                .filter((operation) => operation.kind === 'create-table')
+                .map((operation) => operation.target ?? '')),
+            alters: (0, utils_1.unique)(operations
+                .filter((operation) => operation.kind === 'alter-table')
+                .map((operation) => operation.target ?? '')),
+            drops: (0, utils_1.unique)(operations
+                .filter((operation) => operation.kind === 'drop-table')
+                .map((operation) => operation.target ?? '')),
+            indexes: (0, utils_1.unique)(operations
+                .filter((operation) => operation.kind === 'create-index' || operation.kind === 'drop-index')
+                .map((operation) => operation.name ?? operation.target ?? '')),
+            enums: (0, utils_1.unique)(operations
+                .filter((operation) => operation.kind === 'create-enum' || operation.kind === 'drop-enum')
+                .map((operation) => operation.target ?? '')),
+            seedLike: operations.some((operation) => ['insert-seed', 'update-data', 'delete-data'].includes(operation.kind)),
+            destructive: operations.some((operation) => operation.destructive),
+            confidence: provider === 'sql' ? 'high' : 'medium',
+        },
+    ];
+}
+function extractDatabaseAccesses(relPath, content) {
+    if (/\.(md|mdx|css|scss|html|htm|json|yaml|yml|toml|xml|prisma)$/i.test(relPath) ||
+        isMigrationLikePath(relPath)) {
+        return [];
+    }
+    return (0, utils_1.uniqueBy)([
+        ...extractPrismaDatabaseAccesses(content),
+        ...extractSqlDatabaseAccesses(content),
+        ...extractKnexDatabaseAccesses(content),
+        ...extractRepositoryDatabaseAccesses(content),
+        ...extractMongooseDatabaseAccesses(content),
+        ...extractDjangoDatabaseAccesses(content),
+        ...extractActiveRecordDatabaseAccesses(content),
+        ...extractLaravelDatabaseAccesses(content),
+    ], (access) => `${access.framework}:${access.operation}:${access.model ?? ''}:${access.table ?? ''}:${access.receiver ?? ''}:${access.method ?? ''}:${access.line}`).slice(0, 200);
+}
+function detectDatabaseProvider(relPath, content) {
+    if (/schema\.prisma$/i.test(relPath) ||
+        /^\s*(?:model|enum|datasource|generator)\s+\w+/m.test(content)) {
+        return 'prisma';
+    }
+    if (/\b(?:pgTable|mysqlTable|sqliteTable)\s*\(/.test(content)) {
+        return 'drizzle';
+    }
+    if (/@Entity\(|@Column\(|@PrimaryGeneratedColumn\(/.test(content)) {
+        return 'typeorm';
+    }
+    if (/\b(?:sequelize|db)\.define\(/.test(content)) {
+        return 'sequelize';
+    }
+    if (/\bmongoose\.model\(|new\s+(?:mongoose\.)?Schema\(/.test(content)) {
+        return 'mongoose';
+    }
+    if (/class\s+\w+\s*\([^)]*models\.Model[^)]*\)/.test(content)) {
+        return 'django';
+    }
+    if (/class\s+\w+\s*<\s*(?:ApplicationRecord|ActiveRecord::Base|Model)\b/.test(content)) {
+        return 'rails';
+    }
+    if (/Schema::(?:create|table)\(|extends\s+Model\b|\$fillable|\$casts/.test(content)) {
+        return 'laravel';
+    }
+    if (/\b(?:CREATE|ALTER|DROP)\s+(?:TABLE|TYPE|INDEX)|\b(?:SELECT|INSERT|UPDATE|DELETE)\b/iu.test(content)) {
+        return 'sql';
+    }
+    return 'generic-orm';
+}
+function databaseExtractorForFile(relPath, content) {
+    return `database.${detectDatabaseProvider(relPath, content)}`;
+}
+function databaseOperationToAccessOperation(method) {
+    if (readOperations.has(method)) {
+        return method === 'count' || method === 'aggregate' || method === 'groupBy'
+            ? 'aggregate'
+            : 'read';
+    }
+    if (createOperations.has(method)) {
+        return 'create';
+    }
+    if (updateOperations.has(method)) {
+        return 'update';
+    }
+    if (deleteOperations.has(method)) {
+        return 'delete';
+    }
+    if (upsertOperations.has(method)) {
+        return 'upsert';
+    }
+    if (/save|insert|write/i.test(method)) {
+        return 'write';
+    }
+    return 'unknown';
+}
+function extractPrismaDatabaseModels(relPath, content) {
+    const enums = new Set(extractPrismaDatabaseEnums(relPath, content).map((item) => item.name));
+    const models = [];
+    for (const match of content.matchAll(/^model\s+([A-Za-z_$][\w$]*)\s*\{([\s\S]*?)^}/gm)) {
+        const name = match[1];
+        const block = match[2];
+        const line = (0, utils_1.lineNumberAt)(content, match.index);
+        const fields = [];
+        const indexes = [];
+        const relations = [];
+        const uniqueFields = [];
+        let tableName;
+        let primaryKey = [];
+        for (const row of block.split('\n')) {
+            const trimmed = row.trim();
+            const rowLine = line + block.slice(0, block.indexOf(row)).split('\n').length - 1;
+            if (!trimmed || trimmed.startsWith('//')) {
+                continue;
+            }
+            const mapMatch = trimmed.match(/^@@map\(\s*["']([^"']+)["']\s*\)/);
+            if (mapMatch) {
+                tableName = mapMatch[1];
+                continue;
+            }
+            const modelIndex = parsePrismaModelIndex(trimmed, rowLine);
+            if (modelIndex) {
+                indexes.push(modelIndex);
+                if (modelIndex.kind === 'primary') {
+                    primaryKey = modelIndex.fields;
+                }
+                if (modelIndex.kind === 'unique') {
+                    uniqueFields.push(modelIndex.fields);
+                }
+                continue;
+            }
+            const field = parsePrismaField(name, trimmed, rowLine, enums);
+            if (!field) {
+                continue;
+            }
+            fields.push(field);
+            if (field.id) {
+                primaryKey = [field.name];
+            }
+            if (field.unique) {
+                uniqueFields.push([field.name]);
+            }
+            if (field.relation?.model) {
+                relations.push({
+                    fromModel: name,
+                    fromFields: field.relation.fields,
+                    toModel: field.relation.model,
+                    toFields: field.relation.references,
+                    name: field.relation.name,
+                    onDelete: field.relation.onDelete,
+                    onUpdate: field.relation.onUpdate,
+                    line: rowLine,
+                    confidence: field.relation.fields.length ? 'high' : 'medium',
+                });
+            }
+        }
+        models.push({
+            name,
+            tableName,
+            kind: 'model',
+            provider: 'prisma',
+            framework: 'prisma',
+            fields,
+            fieldNames: fields.map((field) => field.name),
+            primaryKey,
+            uniqueFields: (0, utils_1.uniqueBy)(uniqueFields, (fieldsValue) => fieldsValue.join('|')),
+            indexes,
+            relations,
+            enumRefs: (0, utils_1.unique)(fields.map((field) => field.enumName ?? '')),
+            map: tableName,
+            line,
+            confidence: 'high',
+            sourcePath: relPath,
+        });
+    }
+    return models;
+}
+function extractPrismaDatabaseEnums(relPath, content) {
+    const enums = [];
+    for (const match of content.matchAll(/^enum\s+([A-Za-z_$][\w$]*)\s*\{([\s\S]*?)^}/gm)) {
+        const line = (0, utils_1.lineNumberAt)(content, match.index);
+        let mappedName;
+        const values = match[2]
+            .split('\n')
+            .map((row) => row.trim())
+            .filter((row) => row && !row.startsWith('//'))
+            .filter((row) => {
+            const mapMatch = row.match(/^@@map\(\s*["']([^"']+)["']\s*\)/);
+            if (mapMatch) {
+                mappedName = mapMatch[1];
+                return false;
+            }
+            return !row.startsWith('@@');
+        })
+            .map((row) => row.split(/\s+/)[0])
+            .filter(Boolean);
+        enums.push({
+            name: match[1],
+            values,
+            provider: 'prisma',
+            map: mappedName,
+            line,
+            confidence: 'high',
+            sourcePath: relPath,
+        });
+    }
+    return enums;
+}
+function parsePrismaField(modelName, trimmed, line, enums) {
+    if (trimmed.startsWith('@@')) {
+        return undefined;
+    }
+    const match = trimmed.match(/^([A-Za-z_$][\w$]*)\s+([A-Za-z_$][\w$]*)(\[\])?(\?)?(.*)$/);
+    if (!match) {
+        return undefined;
+    }
+    const name = match[1];
+    const type = match[2];
+    const attrs = match[5] ?? '';
+    const relation = enums.has(type) ? undefined : parsePrismaRelation(modelName, type, attrs);
+    const mapMatch = attrs.match(/@map\(\s*["']([^"']+)["']\s*\)/);
+    const nativeTypeMatch = attrs.match(/@db\.([A-Za-z_$][\w$]*(?:\([^)]*\))?)/);
+    return {
+        name,
+        type,
+        databaseName: mapMatch?.[1],
+        required: !match[4] && !match[3],
+        optional: Boolean(match[4]),
+        list: Boolean(match[3]),
+        id: /@id\b/.test(attrs),
+        unique: /@unique\b/.test(attrs),
+        indexed: false,
+        generated: /@default\((?:autoincrement|cuid|uuid|dbgenerated)\b/.test(attrs),
+        updatedAt: /@updatedAt\b/.test(attrs),
+        default: attrs.match(/@default\(([^)]*(?:\)[^)]*)?)\)/)?.[1],
+        enumName: enums.has(type) ? type : undefined,
+        nativeType: nativeTypeMatch?.[1],
+        relation,
+        line,
+        source: 'prisma',
+        raw: trimmed,
+    };
+}
+function parsePrismaRelation(modelName, type, attrs) {
+    const relationMatch = attrs.match(/@relation\(([^)]*)\)/);
+    const likelyRelation = !prismaScalarTypes.has(type) && /^[A-Z]/.test(type);
+    if (!relationMatch && !likelyRelation) {
+        return undefined;
+    }
+    const args = relationMatch?.[1] ?? '';
+    const name = args.match(/["']([^"']+)["']/)?.[1];
+    const fields = parseBracketList(args.match(/fields\s*:\s*\[([^\]]*)\]/)?.[1]);
+    const references = parseBracketList(args.match(/references\s*:\s*\[([^\]]*)\]/)?.[1]);
+    const onDelete = args.match(/onDelete\s*:\s*([A-Za-z_$][\w$]*)/)?.[1];
+    const onUpdate = args.match(/onUpdate\s*:\s*([A-Za-z_$][\w$]*)/)?.[1];
+    return {
+        model: type === modelName ? undefined : type,
+        name,
+        fields,
+        references,
+        onDelete,
+        onUpdate,
+    };
+}
+function parsePrismaModelIndex(trimmed, line) {
+    const match = trimmed.match(/^@@(id|unique|index)\s*\(\s*\[([^\]]*)\]([^)]*)\)/);
+    if (!match) {
+        return undefined;
+    }
+    const kind = match[1] === 'id' ? 'primary' : match[1] === 'unique' ? 'unique' : 'index';
+    const name = match[3]?.match(/name\s*:\s*["']([^"']+)["']/)?.[1];
+    return {
+        kind,
+        name,
+        fields: parseBracketList(match[2]),
+        line,
+    };
+}
+function extractSqlDatabaseModels(relPath, content) {
+    const models = [];
+    for (const match of content.matchAll(/\bCREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?[`"[]?([A-Za-z_][\w.]*)[`"\]]?\s*\(([\s\S]*?)\);/gi)) {
+        const tableName = cleanSqlIdentifier(match[1].split('.').pop() ?? match[1]);
+        const body = match[2];
+        const line = (0, utils_1.lineNumberAt)(content, match.index);
+        const fields = [];
+        const indexes = [];
+        const relations = [];
+        let primaryKey = [];
+        const uniqueFields = [];
+        for (const part of splitSqlDefinitions(body)) {
+            const trimmed = part.trim();
+            const partLine = line + body.slice(0, body.indexOf(part)).split('\n').length - 1;
+            const tableIndex = parseSqlTableConstraint(tableName, trimmed, partLine);
+            if (tableIndex) {
+                indexes.push(tableIndex);
+                if (tableIndex.kind === 'primary') {
+                    primaryKey = tableIndex.fields;
+                }
+                if (tableIndex.kind === 'unique') {
+                    uniqueFields.push(tableIndex.fields);
+                }
+                if (tableIndex.kind === 'foreign' && tableIndex.references) {
+                    relations.push({
+                        fromModel: tableName,
+                        fromFields: tableIndex.fields,
+                        toModel: tableIndex.references.table,
+                        toFields: tableIndex.references.fields,
+                        line: partLine,
+                        confidence: 'high',
+                    });
+                }
+                continue;
+            }
+            const field = parseSqlColumn(tableName, trimmed, partLine);
+            if (!field) {
+                continue;
+            }
+            fields.push(field);
+            if (field.id) {
+                primaryKey = [field.name];
+            }
+            if (field.unique) {
+                uniqueFields.push([field.name]);
+            }
+            if (field.relation?.model) {
+                relations.push({
+                    fromModel: tableName,
+                    fromFields: [field.name],
+                    toModel: field.relation.model,
+                    toFields: field.relation.references,
+                    onDelete: field.relation.onDelete,
+                    onUpdate: field.relation.onUpdate,
+                    line: partLine,
+                    confidence: 'high',
+                });
+            }
+        }
+        models.push({
+            name: tableName,
+            tableName,
+            kind: 'table',
+            provider: 'sql',
+            framework: 'sql',
+            fields,
+            fieldNames: fields.map((field) => field.name),
+            primaryKey,
+            uniqueFields: (0, utils_1.uniqueBy)(uniqueFields, (fieldsValue) => fieldsValue.join('|')),
+            indexes,
+            relations,
+            enumRefs: (0, utils_1.unique)(fields.map((field) => field.enumName ?? '')),
+            line,
+            confidence: 'high',
+            sourcePath: relPath,
+        });
+    }
+    return models;
+}
+function extractSqlDatabaseEnums(relPath, content) {
+    const enums = [];
+    for (const match of content.matchAll(/\bCREATE\s+TYPE\s+[`"[]?([A-Za-z_][\w.]*)[`"\]]?\s+AS\s+ENUM\s*\(([^;]+)\);/gi)) {
+        enums.push({
+            name: cleanSqlIdentifier(match[1].split('.').pop() ?? match[1]),
+            values: Array.from(match[2].matchAll(/'([^']+)'/g)).map((item) => item[1]),
+            provider: 'sql',
+            line: (0, utils_1.lineNumberAt)(content, match.index),
+            confidence: 'high',
+            sourcePath: relPath,
+        });
+    }
+    return enums;
+}
+function extractDrizzleDatabaseModels(relPath, content) {
+    const models = [];
+    const pattern = /(?:export\s+)?const\s+([A-Za-z_$][\w$]*)\s*=\s*(?:pgTable|mysqlTable|sqliteTable)\(\s*['"]([^'"]+)['"]\s*,\s*\{([\s\S]*?)\}\s*(?:,|\))/g;
+    for (const match of content.matchAll(pattern)) {
+        const name = (0, utils_1.toPascalCase)(match[1]);
+        const tableName = match[2];
+        const body = match[3];
+        const line = (0, utils_1.lineNumberAt)(content, match.index);
+        const fields = [];
+        for (const fieldMatch of body.matchAll(/([A-Za-z_$][\w$]*)\s*:\s*([A-Za-z_$][\w$]*)\(\s*['"]([^'"]+)['"][^)]*\)([^,\n}]*)/g)) {
+            const fieldLine = (0, utils_1.lineNumberAt)(content, (match.index ?? 0) + fieldMatch.index);
+            const chain = fieldMatch[4] ?? '';
+            fields.push({
+                name: fieldMatch[1],
+                databaseName: fieldMatch[3],
+                type: fieldMatch[2],
+                required: /\.notNull\(\)/.test(chain),
+                optional: !/\.notNull\(\)/.test(chain),
+                id: /\.primaryKey\(\)/.test(chain),
+                unique: /\.unique\(\)/.test(chain),
+                default: chain.match(/\.default\(([^)]*)\)/)?.[1],
+                line: fieldLine,
+                source: 'drizzle',
+                raw: fieldMatch[0],
+            });
+        }
+        models.push(createModelFromFields(name, tableName, 'table', 'drizzle', fields, line, relPath));
+    }
+    return models;
+}
+function extractTypeOrmDatabaseModels(relPath, content) {
+    const models = [];
+    const pattern = /@Entity\(([^)]*)\)\s*(?:export\s+)?class\s+([A-Za-z_$][\w$]*)\s*\{([\s\S]*?)^}/gm;
+    for (const match of content.matchAll(pattern)) {
+        const entityArgs = match[1] ?? '';
+        const tableName = entityArgs.match(/['"]([^'"]+)['"]/)?.[1];
+        const name = match[2];
+        const body = match[3];
+        const line = (0, utils_1.lineNumberAt)(content, match.index);
+        const fields = [];
+        const relations = [];
+        for (const fieldMatch of body.matchAll(/((?:\s*@[A-Za-z_$][\w$]*(?:\([^)]*\))?\s*)+)\s*(?:public\s+|private\s+|protected\s+)?([A-Za-z_$][\w$]*)[?!]?\s*:\s*([^;=]+)[;=]/g)) {
+            const decorators = fieldMatch[1];
+            const fieldName = fieldMatch[2];
+            const fieldType = fieldMatch[3].trim();
+            const fieldLine = (0, utils_1.lineNumberAt)(content, (match.index ?? 0) + fieldMatch.index);
+            const relationDecorator = decorators.match(/@(ManyToOne|OneToOne|OneToMany|ManyToMany)\(\s*\(\)\s*=>\s*([A-Za-z_$][\w$]*)/);
+            const field = {
+                name: fieldName,
+                type: fieldType,
+                required: !/nullable\s*:\s*true/.test(decorators) && !/[?]|null/.test(fieldType),
+                optional: /nullable\s*:\s*true/.test(decorators) || /[?]|null/.test(fieldType),
+                id: /@Primary/.test(decorators),
+                unique: /unique\s*:\s*true|@Index\([^)]*unique\s*:\s*true/.test(decorators),
+                generated: /@PrimaryGeneratedColumn/.test(decorators),
+                default: decorators.match(/default\s*:\s*([^,}]+)/)?.[1]?.trim(),
+                relation: relationDecorator
+                    ? {
+                        model: relationDecorator[2],
+                        fields: [],
+                        references: [],
+                        name: relationDecorator[1],
+                    }
+                    : undefined,
+                line: fieldLine,
+                source: 'typeorm',
+                raw: fieldMatch[0].trim(),
+            };
+            fields.push(field);
+            if (field.relation?.model) {
+                relations.push({
+                    fromModel: name,
+                    fromFields: [],
+                    toModel: field.relation.model,
+                    toFields: [],
+                    name: field.relation.name,
+                    line: fieldLine,
+                    confidence: 'medium',
+                });
+            }
+        }
+        const model = createModelFromFields(name, tableName, 'table', 'typeorm', fields, line, relPath);
+        model.relations = relations;
+        models.push(model);
+    }
+    return models;
+}
+function extractSequelizeDatabaseModels(relPath, content) {
+    const models = [];
+    for (const match of content.matchAll(/\b(?:sequelize|db)\.define\(\s*['"]([^'"]+)['"]\s*,\s*\{([\s\S]*?)\}\s*(?:,|\))/g)) {
+        const name = (0, utils_1.toPascalCase)(match[1]);
+        const body = match[2];
+        const line = (0, utils_1.lineNumberAt)(content, match.index);
+        const fields = parseObjectOrmFields(body, 'sequelize', content, match.index ?? 0);
+        models.push(createModelFromFields(name, match[1], 'table', 'sequelize', fields, line, relPath));
+    }
+    return models;
+}
+function extractMongooseDatabaseModels(relPath, content) {
+    const schemas = new Map();
+    const models = [];
+    for (const match of content.matchAll(/(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*new\s+(?:mongoose\.)?Schema\(\s*\{([\s\S]*?)\}\s*(?:,|\))/g)) {
+        schemas.set(match[1], match[2]);
+    }
+    for (const match of content.matchAll(/mongoose\.model\(\s*['"]([^'"]+)['"]\s*,\s*([A-Za-z_$][\w$]*)/g)) {
+        const name = match[1];
+        const schemaBody = schemas.get(match[2]) ?? '';
+        const line = (0, utils_1.lineNumberAt)(content, match.index);
+        const fields = parseObjectOrmFields(schemaBody, 'mongoose', content, match.index ?? 0);
+        models.push(createModelFromFields(name, name, 'collection', 'mongoose', fields, line, relPath));
+    }
+    return models;
+}
+function extractDjangoDatabaseModels(relPath, content) {
+    const models = [];
+    for (const match of content.matchAll(/class\s+([A-Z][A-Za-z0-9_]*)\s*\([^)]*models\.Model[^)]*\):([\s\S]*?)(?=\nclass\s|\n\S|$)/g)) {
+        const name = match[1];
+        const body = match[2];
+        const line = (0, utils_1.lineNumberAt)(content, match.index);
+        const fields = [];
+        const relations = [];
+        const tableName = body.match(/db_table\s*=\s*['"]([^'"]+)['"]/)?.[1];
+        for (const fieldMatch of body.matchAll(/^\s+([A-Za-z_][\w]*)\s*=\s*models\.([A-Za-z_][\w]*)\(([^)]*)\)/gm)) {
+            const fieldLine = (0, utils_1.lineNumberAt)(content, (match.index ?? 0) + fieldMatch.index);
+            const fieldType = fieldMatch[2];
+            const args = fieldMatch[3] ?? '';
+            const relationTarget = fieldType.match(/^(?:ForeignKey|OneToOneField|ManyToManyField)$/)
+                ? args.match(/['"]?([A-Z][A-Za-z0-9_]*)['"]?/)?.[1]
+                : undefined;
+            const field = {
+                name: fieldMatch[1],
+                type: fieldType,
+                required: !/null\s*=\s*True|blank\s*=\s*True/.test(args),
+                optional: /null\s*=\s*True|blank\s*=\s*True/.test(args),
+                unique: /unique\s*=\s*True/.test(args),
+                default: args.match(/default\s*=\s*([^,)]+)/)?.[1]?.trim(),
+                relation: relationTarget
+                    ? { model: relationTarget, fields: [fieldMatch[1]], references: ['id'] }
+                    : undefined,
+                line: fieldLine,
+                source: 'django',
+                raw: fieldMatch[0].trim(),
+            };
+            fields.push(field);
+            if (relationTarget) {
+                relations.push({
+                    fromModel: name,
+                    fromFields: [field.name],
+                    toModel: relationTarget,
+                    toFields: ['id'],
+                    line: fieldLine,
+                    confidence: 'medium',
+                });
+            }
+        }
+        const model = createModelFromFields(name, tableName, 'table', 'django', fields, line, relPath);
+        model.relations = relations;
+        models.push(model);
+    }
+    return models;
+}
+function extractRailsMigrationModels(relPath, content) {
+    const models = [];
+    for (const match of content.matchAll(/create_table\s+:([A-Za-z_][\w]*)\s+do\s+\|t\|([\s\S]*?)\n\s*end/g)) {
+        const tableName = match[1];
+        const name = (0, utils_1.toPascalCase)(tableName.replace(/s$/, ''));
+        const body = match[2];
+        const line = (0, utils_1.lineNumberAt)(content, match.index);
+        const fields = parseRailsTableFields(body, content, match.index ?? 0);
+        models.push(createModelFromFields(name, tableName, 'table', 'rails', fields, line, relPath));
+    }
+    return models;
+}
+function extractLaravelMigrationModels(relPath, content) {
+    const models = [];
+    for (const match of content.matchAll(/Schema::create\(\s*['"]([^'"]+)['"]\s*,\s*function\s*\([^)]*\)\s*\{([\s\S]*?)\}\s*\);/g)) {
+        const tableName = match[1];
+        const name = (0, utils_1.toPascalCase)(tableName.replace(/s$/, ''));
+        const body = match[2];
+        const line = (0, utils_1.lineNumberAt)(content, match.index);
+        const fields = parseLaravelTableFields(body, content, match.index ?? 0);
+        models.push(createModelFromFields(name, tableName, 'table', 'laravel', fields, line, relPath));
+    }
+    return models;
+}
+function extractSqlMigrationOperations(content) {
+    const operations = [];
+    addSqlOperationMatches(operations, content, /\bCREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?[`"[]?([A-Za-z_][\w.]*)[`"\]]?\s*\(([\s\S]*?)\);/gi, 'create-table', false);
+    addSqlOperationMatches(operations, content, /\bALTER\s+TABLE\s+(?:ONLY\s+)?[`"[]?([A-Za-z_][\w.]*)[`"\]]?\s+([\s\S]*?);/gi, 'alter-table', false);
+    addSqlOperationMatches(operations, content, /\bDROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?[`"[]?([A-Za-z_][\w.]*)[`"\]]?[^;]*;/gi, 'drop-table', true);
+    addSqlOperationMatches(operations, content, /\bCREATE\s+(?:UNIQUE\s+)?INDEX\s+[`"[]?([A-Za-z_][\w.]*)[`"\]]?\s+ON\s+[`"[]?([A-Za-z_][\w.]*)[`"\]]?\s*\(([^)]*)\)/gi, 'create-index', false);
+    addSqlOperationMatches(operations, content, /\bDROP\s+INDEX\s+(?:IF\s+EXISTS\s+)?[`"[]?([A-Za-z_][\w.]*)[`"\]]?[^;]*;/gi, 'drop-index', true);
+    addSqlOperationMatches(operations, content, /\bCREATE\s+TYPE\s+[`"[]?([A-Za-z_][\w.]*)[`"\]]?\s+AS\s+ENUM\s*\(([^;]+)\);/gi, 'create-enum', false);
+    addSqlOperationMatches(operations, content, /\bDROP\s+TYPE\s+(?:IF\s+EXISTS\s+)?[`"[]?([A-Za-z_][\w.]*)[`"\]]?[^;]*;/gi, 'drop-enum', true);
+    addSqlOperationMatches(operations, content, /\bINSERT\s+INTO\s+[`"[]?([A-Za-z_][\w.]*)[`"\]]?[\s\S]*?;/gi, 'insert-seed', false);
+    addSqlOperationMatches(operations, content, /\bUPDATE\s+[`"[]?([A-Za-z_][\w.]*)[`"\]]?[\s\S]*?;/gi, 'update-data', false);
+    addSqlOperationMatches(operations, content, /\bDELETE\s+FROM\s+[`"[]?([A-Za-z_][\w.]*)[`"\]]?[\s\S]*?;/gi, 'delete-data', true);
+    return operations;
+}
+function extractRailsMigrationOperations(content) {
+    const operations = [];
+    for (const match of content.matchAll(/create_table\s+:([A-Za-z_][\w]*)/g)) {
+        operations.push({
+            kind: 'create-table',
+            target: match[1],
+            line: (0, utils_1.lineNumberAt)(content, match.index),
+            statement: match[0],
+        });
+    }
+    for (const match of content.matchAll(/add_(column|reference|index)\s+:([A-Za-z_][\w]*)/g)) {
+        operations.push({
+            kind: match[1] === 'index' ? 'create-index' : 'alter-table',
+            target: match[2],
+            line: (0, utils_1.lineNumberAt)(content, match.index),
+            statement: match[0],
+        });
+    }
+    for (const match of content.matchAll(/(?:drop_table|remove_column|remove_index)\s+:([A-Za-z_][\w]*)/g)) {
+        operations.push({
+            kind: match[0].startsWith('drop_table') ? 'drop-table' : 'alter-table',
+            target: match[1],
+            destructive: true,
+            line: (0, utils_1.lineNumberAt)(content, match.index),
+            statement: match[0],
+        });
+    }
+    return operations;
+}
+function extractLaravelMigrationOperations(content) {
+    const operations = [];
+    for (const match of content.matchAll(/Schema::(create|table|drop|dropIfExists)\(\s*['"]([^'"]+)['"]/g)) {
+        operations.push({
+            kind: match[1] === 'create'
+                ? 'create-table'
+                : match[1] === 'table'
+                    ? 'alter-table'
+                    : 'drop-table',
+            target: match[2],
+            destructive: match[1] === 'drop' || match[1] === 'dropIfExists',
+            line: (0, utils_1.lineNumberAt)(content, match.index),
+            statement: match[0],
+        });
+    }
+    return operations;
+}
+function addSqlOperationMatches(operations, content, pattern, kind, destructive) {
+    for (const match of content.matchAll(pattern)) {
+        const statement = match[0].replace(/\s+/g, ' ').trim();
+        const target = cleanSqlIdentifier((kind === 'create-index' ? match[2] : match[1]) ?? '');
+        const name = kind === 'create-index' || kind === 'drop-index' ? cleanSqlIdentifier(match[1]) : undefined;
+        const fields = kind === 'create-table'
+            ? extractSqlCreateTableFields(match[2] ?? '')
+            : kind === 'create-index'
+                ? parseSqlFieldList(match[3] ?? '')
+                : [];
+        const references = statement.match(/REFERENCES\s+[`"[]?([A-Za-z_][\w.]*)[`"\]]?\s*\(([^)]*)\)/i);
+        operations.push({
+            kind,
+            target,
+            name,
+            fields,
+            columns: fields,
+            references: references
+                ? {
+                    table: cleanSqlIdentifier(references[1].split('.').pop() ?? references[1]),
+                    columns: parseSqlFieldList(references[2]),
+                }
+                : undefined,
+            destructive,
+            line: (0, utils_1.lineNumberAt)(content, match.index),
+            statement: statement.slice(0, 260),
+        });
+    }
+}
+function extractPrismaDatabaseAccesses(content) {
+    const accesses = [];
+    const prismaAccessPattern = /\b((?:this\.)?prisma|tx|db)\.([a-z][A-Za-z0-9_]*)\.(findUniqueOrThrow|findUnique|findFirstOrThrow|findFirst|findMany|createMany|create|updateMany|update|deleteMany|delete|upsert|count|aggregate|groupBy)\s*\(/g;
+    for (const match of content.matchAll(prismaAccessPattern)) {
+        const model = (0, utils_1.toPascalCase)(match[2]);
+        const method = match[3];
+        const openIndex = (match.index ?? 0) + match[0].lastIndexOf('(');
+        const callBody = (0, extractors_1.readBalancedRange)(content, openIndex, '(', ')') ?? '';
+        const operation = databaseOperationToAccessOperation(method);
+        accesses.push({
+            operation,
+            model,
+            receiver: match[2],
+            method,
+            framework: 'prisma',
+            line: (0, utils_1.lineNumberAt)(content, match.index),
+            fields: extractObjectKeysFromProperty(callBody, 'data'),
+            whereFields: extractObjectKeysFromProperty(callBody, 'where'),
+            relationHints: extractRelationHints(callBody),
+            transactional: match[1] === 'tx',
+            confidence: 'high',
+            risk: databaseAccessRisk(operation, model, callBody),
+        });
+    }
+    for (const match of content.matchAll(/\b(?:this\.)?(?:prisma|db)\.\$(transaction|queryRaw|executeRaw)\b/g)) {
+        const method = match[1];
+        accesses.push({
+            operation: method === 'transaction' ? 'transaction' : 'raw-sql',
+            method,
+            framework: 'prisma',
+            line: (0, utils_1.lineNumberAt)(content, match.index),
+            fields: [],
+            whereFields: [],
+            relationHints: [],
+            transactional: method === 'transaction',
+            raw: method !== 'transaction',
+            confidence: 'medium',
+            risk: method === 'transaction' ? [] : ['raw-sql-review'],
+        });
+    }
+    return accesses;
+}
+function extractSqlDatabaseAccesses(content) {
+    const accesses = [];
+    const patterns = [
+        [/\bSELECT\b[\s\S]*?\bFROM\s+[`"[]?([A-Za-z_][\w.]*)[`"\]]?/gi, 'read'],
+        [/\bINSERT\s+INTO\s+[`"[]?([A-Za-z_][\w.]*)[`"\]]?\s*(?:\(([^)]*)\))?/gi, 'create'],
+        [
+            /\bUPDATE\s+[`"[]?([A-Za-z_][\w.]*)[`"\]]?[\s\S]*?\bSET\s+([\s\S]*?)(?:\bWHERE\b|;|\n)/gi,
+            'update',
+        ],
+        [/\bDELETE\s+FROM\s+[`"[]?([A-Za-z_][\w.]*)[`"\]]?/gi, 'delete'],
+    ];
+    for (const [pattern, operation] of patterns) {
+        for (const match of content.matchAll(pattern)) {
+            const table = cleanSqlIdentifier(match[1].split('.').pop() ?? match[1]);
+            accesses.push({
+                operation,
+                table,
+                framework: 'sql',
+                line: (0, utils_1.lineNumberAt)(content, match.index),
+                fields: operation === 'create'
+                    ? parseSqlFieldList(match[2] ?? '')
+                    : operation === 'update'
+                        ? extractAssignmentFields(match[2] ?? '')
+                        : [],
+                whereFields: extractSqlWhereFields(match[0]),
+                relationHints: [],
+                raw: true,
+                confidence: /[`'"]/.test(match[0]) ? 'medium' : 'high',
+                risk: databaseAccessRisk(operation, table, match[0]),
+            });
+        }
+    }
+    return accesses;
+}
+function extractKnexDatabaseAccesses(content) {
+    const accesses = [];
+    const pattern = /\b(?:knex|db|database)\(\s*['"]([^'"]+)['"]\s*\)(?:\.[A-Za-z_$][\w$]+\([^)]*\))*\.(select|first|where|insert|update|del|delete|count)\s*\(([^)]*)\)/g;
+    for (const match of content.matchAll(pattern)) {
+        const method = match[2];
+        const operation = method === 'insert'
+            ? 'create'
+            : method === 'update'
+                ? 'update'
+                : method === 'del' || method === 'delete'
+                    ? 'delete'
+                    : method === 'count'
+                        ? 'aggregate'
+                        : 'read';
+        accesses.push({
+            operation,
+            table: match[1],
+            receiver: 'knex',
+            method,
+            framework: 'sql',
+            line: (0, utils_1.lineNumberAt)(content, match.index),
+            fields: extractStringArgs(match[3] ?? ''),
+            whereFields: [],
+            relationHints: [],
+            confidence: 'medium',
+            risk: databaseAccessRisk(operation, match[1], match[0]),
+        });
+    }
+    return accesses;
+}
+function extractRepositoryDatabaseAccesses(content) {
+    const accesses = [];
+    const pattern = /\b(?:this\.)?([A-Za-z_$][\w$]*(?:Repository|Repo|Store))\.(find|findOne|findBy|findAndCount|save|insert|create|update|upsert|delete|remove|count)\s*\(([\s\S]*?)\)/g;
+    for (const match of content.matchAll(pattern)) {
+        const receiver = match[1];
+        const method = match[2];
+        const operation = method === 'find' || method === 'findOne' || method === 'findBy'
+            ? 'read'
+            : method === 'count' || method === 'findAndCount'
+                ? 'aggregate'
+                : databaseOperationToAccessOperation(method);
+        const model = repositoryReceiverToModel(receiver);
+        accesses.push({
+            operation,
+            model,
+            receiver,
+            method,
+            framework: 'typeorm',
+            line: (0, utils_1.lineNumberAt)(content, match.index),
+            fields: extractObjectKeysFromProperty(match[3] ?? '', 'data'),
+            whereFields: extractObjectKeysFromProperty(match[3] ?? '', 'where'),
+            relationHints: extractRelationHints(match[3] ?? ''),
+            confidence: 'medium',
+            risk: databaseAccessRisk(operation, model, match[0]),
+        });
+    }
+    return accesses;
+}
+function extractMongooseDatabaseAccesses(content) {
+    const accesses = [];
+    const pattern = /\b([A-Z][A-Za-z0-9_]*)\.(find|findOne|findById|create|insertMany|updateOne|updateMany|findByIdAndUpdate|deleteOne|deleteMany|findByIdAndDelete|countDocuments|aggregate)\s*\(([\s\S]*?)\)/g;
+    for (const match of content.matchAll(pattern)) {
+        const method = match[2];
+        const operation = method.startsWith('find') || method === 'findOne'
+            ? 'read'
+            : method === 'create' || method === 'insertMany'
+                ? 'create'
+                : method.includes('Update')
+                    ? 'update'
+                    : method.includes('delete') || method.includes('Delete')
+                        ? 'delete'
+                        : method === 'aggregate' || method === 'countDocuments'
+                            ? 'aggregate'
+                            : 'unknown';
+        accesses.push({
+            operation,
+            model: match[1],
+            receiver: match[1],
+            method,
+            framework: 'mongoose',
+            line: (0, utils_1.lineNumberAt)(content, match.index),
+            fields: [],
+            whereFields: extractObjectKeys(match[3] ?? ''),
+            relationHints: [],
+            confidence: 'medium',
+            risk: databaseAccessRisk(operation, match[1], match[0]),
+        });
+    }
+    return accesses;
+}
+function extractDjangoDatabaseAccesses(content) {
+    const accesses = [];
+    const pattern = /\b([A-Z][A-Za-z0-9_]*)\.objects\.(filter|get|all|create|update|get_or_create|update_or_create|delete|count)\s*\(([^)]*)\)/g;
+    for (const match of content.matchAll(pattern)) {
+        const method = match[2];
+        const operation = method === 'filter' || method === 'get' || method === 'all'
+            ? 'read'
+            : method === 'count'
+                ? 'aggregate'
+                : method.includes('create')
+                    ? 'create'
+                    : method === 'update'
+                        ? 'update'
+                        : method === 'delete'
+                            ? 'delete'
+                            : 'unknown';
+        accesses.push({
+            operation,
+            model: match[1],
+            receiver: `${match[1]}.objects`,
+            method,
+            framework: 'django',
+            line: (0, utils_1.lineNumberAt)(content, match.index),
+            fields: extractKeywordArgs(match[3] ?? ''),
+            whereFields: extractKeywordArgs(match[3] ?? ''),
+            relationHints: [],
+            confidence: 'medium',
+            risk: databaseAccessRisk(operation, match[1], match[0]),
+        });
+    }
+    return accesses;
+}
+function extractActiveRecordDatabaseAccesses(content) {
+    const accesses = [];
+    const pattern = /\b([A-Z][A-Za-z0-9_]*)\.(where|find|find_by|all|create|create!|update|update!|destroy|delete|count)\s*(?:\(([^)]*)\))?/g;
+    for (const match of content.matchAll(pattern)) {
+        const method = match[2];
+        const operation = method === 'where' || method === 'find' || method === 'find_by' || method === 'all'
+            ? 'read'
+            : method === 'count'
+                ? 'aggregate'
+                : method.startsWith('create')
+                    ? 'create'
+                    : method.startsWith('update')
+                        ? 'update'
+                        : method === 'destroy' || method === 'delete'
+                            ? 'delete'
+                            : 'unknown';
+        accesses.push({
+            operation,
+            model: match[1],
+            receiver: match[1],
+            method,
+            framework: 'rails',
+            line: (0, utils_1.lineNumberAt)(content, match.index),
+            fields: extractRubyHashKeys(match[3] ?? ''),
+            whereFields: extractRubyHashKeys(match[3] ?? ''),
+            relationHints: [],
+            confidence: 'medium',
+            risk: databaseAccessRisk(operation, match[1], match[0]),
+        });
+    }
+    return accesses;
+}
+function extractLaravelDatabaseAccesses(content) {
+    const accesses = [];
+    const pattern = /\b([A-Z][A-Za-z0-9_]*)::(?:query\(\)->)?(where|find|all|create|update|upsert|delete|count)\s*\(([^)]*)\)/g;
+    for (const match of content.matchAll(pattern)) {
+        const method = match[2];
+        const operation = method === 'where' || method === 'find' || method === 'all'
+            ? 'read'
+            : method === 'count'
+                ? 'aggregate'
+                : databaseOperationToAccessOperation(method);
+        accesses.push({
+            operation,
+            model: match[1],
+            receiver: match[1],
+            method,
+            framework: 'laravel',
+            line: (0, utils_1.lineNumberAt)(content, match.index),
+            fields: extractStringArgs(match[3] ?? ''),
+            whereFields: extractStringArgs(match[3] ?? ''),
+            relationHints: [],
+            confidence: 'medium',
+            risk: databaseAccessRisk(operation, match[1], match[0]),
+        });
+    }
+    return accesses;
+}
+function createModelFromFields(name, tableName, kind, provider, fields, line, relPath) {
+    return {
+        name,
+        tableName,
+        kind,
+        provider,
+        framework: provider,
+        fields,
+        fieldNames: fields.map((field) => field.name),
+        primaryKey: fields.filter((field) => field.id).map((field) => field.name),
+        uniqueFields: fields.filter((field) => field.unique).map((field) => [field.name]),
+        indexes: fields
+            .filter((field) => field.id || field.unique || field.indexed)
+            .map((field) => ({
+            kind: field.id ? 'primary' : field.unique ? 'unique' : 'index',
+            fields: [field.name],
+            line: field.line,
+        })),
+        relations: fields
+            .filter((field) => field.relation?.model)
+            .map((field) => ({
+            fromModel: name,
+            fromFields: field.relation?.fields.length ? field.relation.fields : [field.name],
+            toModel: field.relation?.model ?? '',
+            toFields: field.relation?.references.length ? field.relation.references : ['id'],
+            name: field.relation?.name,
+            onDelete: field.relation?.onDelete,
+            onUpdate: field.relation?.onUpdate,
+            line: field.line,
+            confidence: 'medium',
+        })),
+        enumRefs: (0, utils_1.unique)(fields.map((field) => field.enumName ?? '')),
+        line,
+        confidence: provider === 'generic-orm' ? 'low' : 'medium',
+        sourcePath: relPath,
+    };
+}
+function parseSqlColumn(tableName, trimmed, line) {
+    const match = trimmed.match(/^[`"[]?([A-Za-z_][\w]*)[`"\]]?\s+(.+)$/);
+    if (!match || /^(?:CONSTRAINT|PRIMARY|FOREIGN|UNIQUE|KEY|INDEX|CHECK)\b/i.test(match[1])) {
+        return undefined;
+    }
+    const name = cleanSqlIdentifier(match[1]);
+    const rest = match[2];
+    const type = rest
+        .split(/\s+(?:NOT\s+NULL|NULL|DEFAULT|PRIMARY\s+KEY|UNIQUE|REFERENCES|CONSTRAINT|CHECK)\b/i)[0]
+        .trim();
+    const references = rest.match(/REFERENCES\s+[`"[]?([A-Za-z_][\w.]*)[`"\]]?\s*\(([^)]*)\)/i);
+    return {
+        name,
+        type,
+        required: /\bNOT\s+NULL\b/i.test(rest) || /\bPRIMARY\s+KEY\b/i.test(rest),
+        optional: !/\bNOT\s+NULL\b/i.test(rest) && !/\bPRIMARY\s+KEY\b/i.test(rest),
+        id: /\bPRIMARY\s+KEY\b/i.test(rest),
+        unique: /\bUNIQUE\b/i.test(rest),
+        default: rest.match(/\bDEFAULT\s+([^,\n]+)/i)?.[1]?.trim(),
+        relation: references
+            ? {
+                model: cleanSqlIdentifier(references[1].split('.').pop() ?? references[1]),
+                fields: [name],
+                references: parseSqlFieldList(references[2]),
+                onDelete: rest.match(/\bON\s+DELETE\s+([A-Z]+)/i)?.[1],
+                onUpdate: rest.match(/\bON\s+UPDATE\s+([A-Z]+)/i)?.[1],
+            }
+            : undefined,
+        line,
+        source: 'sql',
+        raw: trimmed,
+    };
+}
+function parseSqlTableConstraint(tableName, trimmed, line) {
+    const normalized = trimmed.replace(/^CONSTRAINT\s+[`"[]?[A-Za-z_][\w.]*[`"\]]?\s+/i, '');
+    const primary = normalized.match(/^PRIMARY\s+KEY\s*\(([^)]*)\)/i);
+    const uniqueMatch = normalized.match(/^UNIQUE\s*\(([^)]*)\)/i);
+    const foreign = normalized.match(/^FOREIGN\s+KEY\s*\(([^)]*)\)\s+REFERENCES\s+[`"[]?([A-Za-z_][\w.]*)[`"\]]?\s*\(([^)]*)\)/i);
+    if (primary) {
+        return { kind: 'primary', fields: parseSqlFieldList(primary[1]), line };
+    }
+    if (uniqueMatch) {
+        return { kind: 'unique', fields: parseSqlFieldList(uniqueMatch[1]), line };
+    }
+    if (foreign) {
+        return {
+            kind: 'foreign',
+            fields: parseSqlFieldList(foreign[1]),
+            references: {
+                table: cleanSqlIdentifier(foreign[2].split('.').pop() ?? foreign[2]),
+                fields: parseSqlFieldList(foreign[3]),
+            },
+            line,
+        };
+    }
+    void tableName;
+    return undefined;
+}
+function parseObjectOrmFields(body, source, content, offset) {
+    const fields = [];
+    for (const match of body.matchAll(/([A-Za-z_$][\w$]*)\s*:\s*(?:\{([^{}]*)\}|([A-Za-z_$][\w$.]*))/g)) {
+        const raw = match[0];
+        const config = match[2] ?? match[3] ?? '';
+        const type = config.match(/type\s*:\s*([A-Za-z_$][\w$.]*)/)?.[1] ?? match[3];
+        fields.push({
+            name: match[1],
+            type,
+            required: /required\s*:\s*true|allowNull\s*:\s*false/.test(config),
+            optional: /required\s*:\s*false|allowNull\s*:\s*true/.test(config),
+            id: /primaryKey\s*:\s*true/.test(config),
+            unique: /unique\s*:\s*true/.test(config),
+            default: config.match(/default(?:Value)?\s*:\s*([^,}]+)/)?.[1]?.trim(),
+            line: (0, utils_1.lineNumberAt)(content, offset + (match.index ?? 0)),
+            source,
+            raw,
+        });
+    }
+    return fields;
+}
+function parseRailsTableFields(body, content, offset) {
+    const fields = [];
+    for (const match of body.matchAll(/t\.([a-z_]+)\s+:([A-Za-z_][\w]*)([^,\n]*)/g)) {
+        fields.push({
+            name: match[2],
+            type: match[1],
+            required: /null:\s*false/.test(match[3] ?? ''),
+            optional: !/null:\s*false/.test(match[3] ?? ''),
+            unique: /unique:\s*true/.test(match[3] ?? ''),
+            indexed: /index:\s*true/.test(match[3] ?? ''),
+            relation: match[1] === 'references'
+                ? { model: (0, utils_1.toPascalCase)(match[2]), fields: [match[2]], references: ['id'] }
+                : undefined,
+            line: (0, utils_1.lineNumberAt)(content, offset + (match.index ?? 0)),
+            source: 'rails',
+            raw: match[0],
+        });
+    }
+    return fields;
+}
+function parseLaravelTableFields(body, content, offset) {
+    const fields = [];
+    for (const match of body.matchAll(/\$table->([A-Za-z_][\w]*)\(([^)]*)\)([^;\n]*);/g)) {
+        const method = match[1];
+        const args = match[2] ?? '';
+        const name = extractStringArgs(args)[0] ?? (method === 'id' ? 'id' : method);
+        const chain = match[3] ?? '';
+        fields.push({
+            name,
+            type: method,
+            required: !/nullable\(\)/.test(chain),
+            optional: /nullable\(\)/.test(chain),
+            id: method === 'id' || /primary\(\)/.test(chain),
+            unique: /unique\(\)/.test(chain),
+            indexed: /index\(\)/.test(chain) || /foreignId|constrained/.test(method + chain),
+            default: chain.match(/default\(([^)]*)\)/)?.[1],
+            relation: method === 'foreignId' || /constrained\(\)/.test(chain)
+                ? {
+                    model: (0, utils_1.toPascalCase)(name.replace(/_id$|Id$/, '')),
+                    fields: [name],
+                    references: ['id'],
+                }
+                : undefined,
+            line: (0, utils_1.lineNumberAt)(content, offset + (match.index ?? 0)),
+            source: 'laravel',
+            raw: match[0],
+        });
+    }
+    return fields;
+}
+function splitSqlDefinitions(value) {
+    const parts = [];
+    let depth = 0;
+    let quote;
+    let start = 0;
+    for (let index = 0; index < value.length; index += 1) {
+        const char = value[index];
+        if (quote) {
+            if (char === quote && value[index - 1] !== '\\') {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'" || char === '`') {
+            quote = char;
+            continue;
+        }
+        if (char === '(')
+            depth += 1;
+        if (char === ')')
+            depth = Math.max(0, depth - 1);
+        if (char === ',' && depth === 0) {
+            parts.push(value.slice(start, index));
+            start = index + 1;
+        }
+    }
+    parts.push(value.slice(start));
+    return parts;
+}
+function extractSqlCreateTableFields(body) {
+    return splitSqlDefinitions(body)
+        .map((part) => part.trim().match(/^[`"[]?([A-Za-z_][\w]*)[`"\]]?\s+/)?.[1] ?? '')
+        .filter((field) => field && !/^(?:CONSTRAINT|PRIMARY|FOREIGN|UNIQUE|KEY|INDEX|CHECK)$/i.test(field));
+}
+function parseBracketList(value) {
+    if (!value) {
+        return [];
+    }
+    return (0, utils_1.unique)(value
+        .split(',')
+        .map((item) => item.trim().replace(/[`"'[\]]/g, ''))
+        .filter(Boolean));
+}
+function parseSqlFieldList(value) {
+    return parseBracketList(value).map(cleanSqlIdentifier);
+}
+function cleanSqlIdentifier(value) {
+    return value.trim().replace(/^[`"[]+|[`"\]]+$/g, '');
+}
+function extractObjectKeysFromProperty(body, property) {
+    const match = body.match(new RegExp(`\\b${(0, utils_1.escapeRegExp)(property)}\\s*:\\s*\\{([\\s\\S]*?)\\}`, 'm'));
+    return match ? extractObjectKeys(match[1]) : [];
+}
+function extractObjectKeys(body) {
+    return (0, utils_1.unique)(Array.from(body.matchAll(/\b([A-Za-z_$][\w$]*)\s*:/g)).map((match) => match[1]))
+        .filter((item) => !['where', 'data', 'select', 'include', 'orderBy'].includes(item))
+        .slice(0, 60);
+}
+function extractRelationHints(body) {
+    const hints = new Set();
+    for (const match of body.matchAll(/\binclude\s*:\s*\{([\s\S]*?)\}/g)) {
+        for (const key of extractObjectKeys(match[1])) {
+            hints.add(key);
+        }
+    }
+    return Array.from(hints).slice(0, 40);
+}
+function extractAssignmentFields(body) {
+    return (0, utils_1.unique)(Array.from(body.matchAll(/\b([A-Za-z_][\w]*)\s*=/g)).map((match) => match[1])).slice(0, 60);
+}
+function extractSqlWhereFields(body) {
+    const where = body.match(/\bWHERE\b([\s\S]*)/i)?.[1] ?? '';
+    return (0, utils_1.unique)(Array.from(where.matchAll(/[`"[]?([A-Za-z_][\w]*)[`"\]]?\s*(?:=|<>|!=|<|>|LIKE|IN\b)/gi)).map((match) => cleanSqlIdentifier(match[1]))).slice(0, 60);
+}
+function extractStringArgs(body) {
+    return (0, utils_1.unique)(Array.from(body.matchAll(/['"]([^'"]+)['"]/g)).map((match) => match[1])).slice(0, 60);
+}
+function extractKeywordArgs(body) {
+    return (0, utils_1.unique)(Array.from(body.matchAll(/\b([A-Za-z_][\w]*)\s*=/g)).map((match) => match[1])).slice(0, 60);
+}
+function extractRubyHashKeys(body) {
+    return (0, utils_1.unique)(Array.from(body.matchAll(/\b([A-Za-z_][\w]*):/g)).map((match) => match[1])).slice(0, 60);
+}
+function repositoryReceiverToModel(receiver) {
+    return (0, utils_1.toPascalCase)(receiver.replace(/(?:Repository|Repo|Store)$/i, ''));
+}
+function databaseAccessRisk(operation, modelOrTable, context) {
+    const risk = [];
+    const lower = `${modelOrTable ?? ''} ${context}`.toLowerCase();
+    if (['create', 'update', 'delete', 'upsert', 'write', 'raw-sql'].includes(operation)) {
+        risk.push('mutates-data');
+    }
+    if (operation === 'delete') {
+        risk.push('destructive-write');
+    }
+    if (/user|session|token|password|auth|billing|payment|stripe|permission|role|api.?key/.test(lower)) {
+        risk.push('sensitive-model');
+    }
+    if (/raw|queryRaw|executeRaw|\bDELETE\b|\bDROP\b|\bTRUNCATE\b/.test(context)) {
+        risk.push('manual-review');
+    }
+    return (0, utils_1.unique)(risk);
+}
+function migrationNameFromPath(relPath) {
+    const parts = relPath.split('/');
+    const migrationDir = parts.length > 1 ? parts[parts.length - 2] : undefined;
+    const fileName = parts[parts.length - 1]?.replace(/\.[^.]+$/, '');
+    return migrationDir && !/^migrations?$/i.test(migrationDir) ? migrationDir : fileName || relPath;
+}
+function isMigrationLikePath(relPath) {
+    return /(?:^|\/)(?:migrations?|db\/migrate|database\/migrations)(?:\/|$)/i.test(relPath);
+}
+//# sourceMappingURL=database.js.map