@gaurav.codes/schemacheck 0.1.0

package/cli.js

@@ -0,0 +1,798 @@
+#!/usr/bin/env node
+'use strict'
+
+/**
+ * schemacheck — zero-dependency runner
+ * Works immediately: node run.js ./schema.prisma
+ * Full TypeScript build: npm install && npx tsc && node dist/cli.js
+ */
+
+const fs = require('fs')
+const path = require('path')
+
+// ═══════════════════════════════════════════════════════════════
+// PARSERS
+// ═══════════════════════════════════════════════════════════════
+
+// ── Prisma ────────────────────────────────────────────────────
+
+function normalizePrismaType(raw) {
+    const base = raw.replace('?', '').replace('[]', '').toLowerCase()
+    const map = {
+        string: 'string', int: 'int', bigint: 'int', float: 'float',
+        decimal: 'float', boolean: 'boolean', datetime: 'datetime', json: 'json', bytes: 'bytes'
+    }
+    return map[base] ?? 'unknown'
+}
+
+function parsePrisma(source) {
+    const models = []
+    const modelRegex = /model\s+(\w+)\s*\{([^}]+)\}/g
+    let match
+
+    while ((match = modelRegex.exec(source)) !== null) {
+        const [, modelName, body] = match
+        const fields = []
+        const indexes = []
+        let lineNum = source.slice(0, match.index).split('\n').length
+
+        for (const line of body.split('\n')) {
+            lineNum++
+            const t = line.trim()
+            if (!t || t.startsWith('//')) continue
+
+            if (t.startsWith('@@index')) {
+                const m = t.match(/\[([^\]]+)\]/)
+                if (m) indexes.push({ fields: m[1].split(',').map(s => s.trim()), isUnique: false })
+                continue
+            }
+            if (t.startsWith('@@unique')) {
+                const m = t.match(/\[([^\]]+)\]/)
+                if (m) indexes.push({ fields: m[1].split(',').map(s => s.trim()), isUnique: true })
+                continue
+            }
+            if (t.startsWith('@@')) continue
+
+            const parts = t.split(/\s+/)
+            if (parts.length < 2 || parts[0].startsWith('@')) continue
+
+            const [fieldName, rawType] = parts
+            const defMatch = t.match(/@default\(([^)]+)\)/)
+
+            fields.push({
+                name: fieldName,
+                type: normalizePrismaType(rawType),
+                isRequired: !rawType.endsWith('?') && !rawType.endsWith('[]'),
+                isUnique: t.includes('@unique'),
+                isPrimary: t.includes('@id'),
+                isArray: rawType.endsWith('[]'),
+                default: defMatch?.[1],
+                line: lineNum,
+            })
+        }
+
+        // Extract relations from fields
+        const relations = []
+        for (const f of fields) {
+            if (f.type === 'unknown') {
+                relations.push({ fromField: f.name, toModel: f.name, type: f.isArray ? 'one-to-many' : 'one-to-one' })
+            }
+        }
+
+        models.push({ name: modelName, fields: fields.filter(f => f.type !== 'unknown'), indexes, relations })
+    }
+
+    return { format: 'prisma', models, rawSource: source }
+}
+
+// ── SQL ───────────────────────────────────────────────────────
+
+function normalizeSQLType(raw) {
+    const t = raw.toLowerCase()
+    if (/varchar|char|text|nvarchar/.test(t)) return 'string'
+    if (/int|serial|bigint|smallint/.test(t)) return 'int'
+    if (/float|double|decimal|numeric|real/.test(t)) return 'float'
+    if (/bool/.test(t)) return 'boolean'
+    if (/timestamp|datetime|date/.test(t)) return 'datetime'
+    if (/json/.test(t)) return 'json'
+    if (/uuid/.test(t)) return 'uuid'
+    if (/bytea|blob|binary/.test(t)) return 'bytes'
+    return 'unknown'
+}
+
+function parseSQL(source) {
+    const models = []
+    const tableRegex = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["`]?(\w+)["`]?\s*\(([^;]+)\)/gis
+    let match
+
+    while ((match = tableRegex.exec(source)) !== null) {
+        const [, tableName, body] = match
+        const fields = []
+        const indexes = []
+
+        for (const line of body.split('\n')) {
+            const t = line.trim().replace(/,$/, '')
+            if (!t) continue
+            const up = t.toUpperCase()
+
+            if (up.startsWith('PRIMARY KEY')) {
+                const m = t.match(/\(([^)]+)\)/)
+                if (m) m[1].split(',').map(s => s.trim()).forEach(col => {
+                    const f = fields.find(f => f.name === col)
+                    if (f) f.isPrimary = true
+                })
+                continue
+            }
+            if (up.startsWith('UNIQUE')) {
+                const m = t.match(/\(([^)]+)\)/)
+                if (m) indexes.push({ fields: m[1].split(',').map(s => s.trim()), isUnique: true })
+                continue
+            }
+            if (up.startsWith('INDEX') || up.startsWith('KEY')) {
+                const m = t.match(/\(([^)]+)\)/)
+                if (m) indexes.push({ fields: m[1].split(',').map(s => s.trim()), isUnique: false })
+                continue
+            }
+            if (up.startsWith('FOREIGN KEY') || up.startsWith('CONSTRAINT') || up.startsWith(')')) continue
+
+            const colMatch = t.match(/^["`]?(\w+)["`]?\s+(\w+(?:\([^)]*\))?)(.*)/i)
+            if (!colMatch) continue
+            const [, colName, dataType, rest] = colMatch
+            const restUp = rest.toUpperCase()
+            const defMatch = rest.match(/DEFAULT\s+([^\s,]+)/i)
+
+            fields.push({
+                name: colName,
+                type: normalizeSQLType(dataType),
+                isRequired: restUp.includes('NOT NULL'),
+                isUnique: restUp.includes('UNIQUE'),
+                isPrimary: restUp.includes('PRIMARY KEY'),
+                isArray: false,
+                default: defMatch?.[1],
+            })
+        }
+
+        models.push({ name: tableName, fields, indexes, relations: [] })
+    }
+
+    // Standalone CREATE INDEX
+    const idxRegex = /CREATE\s+(UNIQUE\s+)?INDEX\s+\w+\s+ON\s+["`]?(\w+)["`]?\s*\(([^)]+)\)/gis
+    while ((match = idxRegex.exec(source)) !== null) {
+        const [, unique, tableName, cols] = match
+        const model = models.find(m => m.name.toLowerCase() === tableName.toLowerCase())
+        if (model) model.indexes.push({
+            fields: cols.split(',').map(s => s.trim()),
+            isUnique: !!unique,
+        })
+    }
+
+    return { format: 'sql', models, rawSource: source }
+}
+
+// ── Mongoose ──────────────────────────────────────────────────
+
+function normalizeMongooseType(raw) {
+    const t = raw.toLowerCase()
+    if (t.includes('string')) return 'string'
+    if (t.includes('number')) return 'int'
+    if (t.includes('boolean') || t.includes('bool')) return 'boolean'
+    if (t.includes('date')) return 'datetime'
+    if (t.includes('buffer')) return 'bytes'
+    if (t.includes('mixed') || t.includes('object')) return 'json'
+    if (t.includes('objectid')) return 'uuid'
+    return 'unknown'
+}
+
+function parseMongoose(source) {
+    const models = []
+
+    // Find model name mappings: mongoose.model('User', UserSchema)
+    const modelNameMap = new Map()
+    const modelRegex = /(?:mongoose\.)?model\s*\(\s*['"`](\w+)['"`]\s*,\s*(\w+)/g
+    let m
+    while ((m = modelRegex.exec(source)) !== null) modelNameMap.set(m[2], m[1])
+
+    // Find new Schema({ }) blocks
+    const schemaRegex = /(?:const|let|var)\s+(\w+)\s*=\s*new\s+(?:\w+\.)?Schema\s*\(\s*\{/g
+    while ((m = schemaRegex.exec(source)) !== null) {
+        const varName = m[1]
+        const start = m.index + m[0].length - 1
+        let depth = 0, i = start
+        while (i < source.length) {
+            if (source[i] === '{') depth++
+            if (source[i] === '}') { depth--; if (depth === 0) break }
+            i++
+        }
+        const body = source.slice(start + 1, i)
+        const fields = []
+
+        // Parse top-level fields — collect each field's full block (handles multi-line)
+        // Strategy: scan char by char, collect top-level key:value pairs
+        const SKIP = new Set(['type', 'default', 'required', 'unique', 'index', 'ref',
+            'min', 'max', 'enum', 'select', 'trim', 'lowercase', 'uppercase', 'match',
+            'validate', 'get', 'set', 'alias', 'keys', 'endpoint', 'auth', 'p256dh',
+            'minLen', 'maxLen', 'expires', 'sparse', 'immutable', 'of'])
+
+        // Split body into top-level field blocks by tracking brace depth
+        const topLevelFields = []
+        let depth2 = 0, current = '', inStr = false, strChar = ''
+        for (let ci = 0; ci < body.length; ci++) {
+            const ch = body[ci]
+            if (inStr) {
+                current += ch
+                if (ch === strChar && body[ci - 1] !== '\\') inStr = false
+                continue
+            }
+            if (ch === '"' || ch === "'") { inStr = true; strChar = ch; current += ch; continue }
+            if (ch === '{') depth2++
+            if (ch === '}') depth2--
+            if (ch === ',' && depth2 === 0) {
+                if (current.trim()) topLevelFields.push(current.trim())
+                current = ''
+                continue
+            }
+            current += ch
+        }
+        if (current.trim()) topLevelFields.push(current.trim())
+
+        for (const block of topLevelFields) {
+            // Extract field name — first word before colon
+            const nameMatch = block.match(/^(\w+)\s*:/)
+            if (!nameMatch) continue
+            const fieldName = nameMatch[1]
+            if (SKIP.has(fieldName)) continue
+
+            // Get everything after the first colon
+            const afterColon = block.slice(block.indexOf(':') + 1).trim()
+            const isArr = afterColon.startsWith('[')
+
+            // Check if this is a nested subdocument (pure object with no type key at top level)
+            // e.g. subscription: { endpoint: {...}, keys: {...} }
+            // vs   username: { type: String, required: true }
+            const isNestedSubdoc = afterColon.startsWith('{') &&
+                !/type\s*:/.test(afterColon) &&
+                // has nested objects inside
+                /:\s*\{/.test(afterColon)
+
+            if (isNestedSubdoc) continue
+
+            const typeMatch = afterColon.match(/type\s*:\s*([A-Za-z]+)/)
+            const rawType = typeMatch ? typeMatch[1] : afterColon.replace(/[{},]/g, '').trim().split(/\s/)[0]
+
+            const isUniq = /unique\s*:\s*true/.test(afterColon)
+            const isReq = /required\s*:\s*true/.test(afterColon)
+            const defMatch = afterColon.match(/default\s*:\s*([^,}\n]+)/)
+
+            fields.push({
+                name: fieldName,
+                type: normalizeMongooseType(rawType),
+                isRequired: isReq,
+                isUnique: isUniq,
+                isPrimary: fieldName === '_id',
+                isArray: isArr,
+                default: defMatch?.[1]?.trim(),
+            })
+        }
+
+        // Auto-add _id
+        if (!fields.find(f => f.name === '_id')) {
+            fields.unshift({ name: '_id', type: 'uuid', isRequired: true, isUnique: true, isPrimary: true, isArray: false })
+        }
+
+        // Find .index() calls
+        const indexes = []
+        const idxRegex = new RegExp(`${varName}\\.index\\s*\\(\\s*\\{([^}]+)\\}`, 'g')
+        let im
+        while ((im = idxRegex.exec(source)) !== null) {
+            const idxFields = [...im[1].matchAll(/(\w+)\s*:/g)].map(x => x[1])
+            indexes.push({ fields: idxFields, isUnique: /unique\s*:\s*true/.test(source.slice(im.index, im.index + 100)) })
+        }
+
+        models.push({ name: modelNameMap.get(varName) ?? varName, fields, indexes, relations: [] })
+    }
+
+    return { format: 'mongoose', models, rawSource: source }
+}
+
+// ── Drizzle ───────────────────────────────────────────────────
+
+function normalizeDrizzleType(def) {
+    const t = def.toLowerCase()
+    if (/varchar|text|char\(/.test(t)) return 'string'
+    if (/integer|serial|bigint|smallint/.test(t)) return 'int'
+    if (/real|numeric|decimal|double|float/.test(t)) return 'float'
+    if (/boolean/.test(t)) return 'boolean'
+    if (/timestamp|date|time/.test(t)) return 'datetime'
+    if (/jsonb|json/.test(t)) return 'json'
+    if (/uuid/.test(t)) return 'uuid'
+    return 'unknown'
+}
+
+function parseDrizzle(source) {
+    const models = []
+    const tableRegex = /(?:pgTable|mysqlTable|sqliteTable)\s*\(\s*['"`](\w+)['"`]\s*,\s*\{([^}]+)\}/g
+    let match
+
+    while ((match = tableRegex.exec(source)) !== null) {
+        const [, tableName, body] = match
+        const fields = []
+
+        for (const line of body.split('\n')) {
+            const t = line.trim().replace(/,$/, '')
+            if (!t || t.startsWith('//')) continue
+            const fieldMatch = t.match(/^(\w+)\s*:\s*(.+)/)
+            if (!fieldMatch) continue
+            const [, fieldName, def] = fieldMatch
+            const defVal = def.match(/\.default\(([^)]+)\)/)?.[1]
+            fields.push({
+                name: fieldName,
+                type: normalizeDrizzleType(def),
+                isRequired: def.includes('.notNull()'),
+                isUnique: def.includes('.unique()'),
+                isPrimary: def.includes('primaryKey') || def.includes('.primaryKey()'),
+                isArray: false,
+                default: defVal,
+            })
+        }
+
+        models.push({ name: tableName, fields, indexes: [], relations: [] })
+    }
+
+    return { format: 'drizzle', models, rawSource: source }
+}
+
+// ── Auto-detect + dispatch ────────────────────────────────────
+
+function detectFormat(filePath, source) {
+    const ext = path.extname(filePath).toLowerCase()
+    if (ext === '.prisma') return 'prisma'
+    if (ext === '.sql') return 'sql'
+    if (/(?:pgTable|mysqlTable|sqliteTable)\s*\(/.test(source)) return 'drizzle'
+    if (/new\s+(?:\w+\.)?Schema\s*\(/.test(source)) return 'mongoose'
+    if (/^CREATE\s+TABLE/im.test(source)) return 'sql'
+    if (/^model\s+\w+\s*\{/m.test(source)) return 'prisma'
+    throw new Error(`Cannot detect format for "${filePath}". Use --format=prisma|drizzle|sql|mongoose`)
+}
+
+function parseSchema(filePath, forceFormat) {
+    if (!fs.existsSync(filePath)) throw new Error(`File not found: ${filePath}`)
+    const source = fs.readFileSync(filePath, 'utf-8')
+    const format = forceFormat ?? detectFormat(filePath, source)
+    switch (format) {
+        case 'prisma': return parsePrisma(source)
+        case 'sql': return parseSQL(source)
+        case 'drizzle': return parseDrizzle(source)
+        case 'mongoose': return parseMongoose(source)
+        default: throw new Error(`Unsupported format: ${format}`)
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// LINT RULES
+// ═══════════════════════════════════════════════════════════════
+
+const FK_SUFFIXES = ['Id', '_id', 'Fk', '_fk']
+const FK_EXCLUSION_PATTERNS = [
+    /[Pp]ublic[Ii][dD]$/,
+    /[Cc]lient[Ii][dD]$/,
+    /[Ss]ession[Ii][dD]$/,
+    /[Rr]equest[Ii][dD]$/,
+    /[Cc]orrelation[Ii][dD]$/,
+    /[Tt]race[Ii][dD]$/,
+    /[Ee]xternal[Ii][dD]$/,
+]
+function isFKExclusion(name) { return FK_EXCLUSION_PATTERNS.some(p => p.test(name)) }
+
+function hasIndexOn(model, fieldName) {
+    return model.indexes.some(idx => idx.fields.includes(fieldName))
+}
+
+function isPrimaryField(f) {
+    return f.isPrimary || f.name === 'id' || f.name === '_id'
+}
+
+const RULES = [
+
+    // SC001 — Missing primary key
+    {
+        id: 'SC001', name: 'Missing primary key', severity: 'error',
+        check(schema) {
+            return schema.models
+                .filter(m => !m.fields.some(isPrimaryField))
+                .map(m => ({
+                    ruleId: 'SC001', severity: 'error', model: m.name,
+                    message: `"${m.name}" has no primary key field`,
+                    suggestion: `Add: id String @id @default(cuid())`,
+                }))
+        },
+    },
+
+    // SC002 — FK field missing index
+    {
+        id: 'SC002', name: 'Foreign key missing index', severity: 'error',
+        check(schema) {
+            const issues = []
+            for (const model of schema.models) {
+                const fkFields = model.fields.filter(f =>
+                    !isPrimaryField(f) && !isFKExclusion(f.name) && FK_SUFFIXES.some(s => f.name.endsWith(s) && f.name.length > s.length)
+                )
+                for (const field of fkFields) {
+                    if (!hasIndexOn(model, field.name)) {
+                        issues.push({
+                            ruleId: 'SC002', severity: 'error', model: model.name, field: field.name,
+                            message: `"${model.name}.${field.name}" looks like a foreign key but has no index`,
+                            suggestion: `Add @@index([${field.name}]) to "${model.name}"`,
+                        })
+                    }
+                }
+            }
+            return issues
+        },
+    },
+
+    // SC003 — Missing timestamps
+    {
+        id: 'SC003', name: 'Missing timestamps', severity: 'warning',
+        check(schema) {
+            const issues = []
+            const CREATED = ['createdat', 'created_at', 'createdate']
+            const UPDATED = ['updatedat', 'updated_at', 'updatedate']
+            for (const m of schema.models) {
+                const names = m.fields.map(f => f.name.toLowerCase())
+                if (!CREATED.some(t => names.includes(t)))
+                    issues.push({
+                        ruleId: 'SC003', severity: 'warning', model: m.name,
+                        message: `"${m.name}" is missing a createdAt timestamp`,
+                        suggestion: `Add: createdAt DateTime @default(now())`
+                    })
+                if (!UPDATED.some(t => names.includes(t)))
+                    issues.push({
+                        ruleId: 'SC003', severity: 'warning', model: m.name,
+                        message: `"${m.name}" is missing an updatedAt timestamp`,
+                        suggestion: `Add: updatedAt DateTime @updatedAt`
+                    })
+            }
+            return issues
+        },
+    },
+
+    // SC004 — No soft delete
+    {
+        id: 'SC004', name: 'No soft delete field', severity: 'info',
+        check(schema) {
+            const SOFT = ['deletedat', 'deleted_at', 'isdeleted', 'is_deleted', 'archivedat']
+            return schema.models
+                .filter(m => !m.fields.some(f => SOFT.includes(f.name.toLowerCase())))
+                .map(m => ({
+                    ruleId: 'SC004', severity: 'info', model: m.name,
+                    message: `"${m.name}" has no soft delete field`,
+                    suggestion: `Consider: deletedAt DateTime? — allows recovery without data loss`,
+                }))
+        },
+    },
+
+    // SC005 — God model
+    {
+        id: 'SC005', name: 'God model — too many fields', severity: 'warning',
+        check(schema) {
+            return schema.models
+                .filter(m => m.fields.length > 20)
+                .map(m => ({
+                    ruleId: 'SC005', severity: 'warning', model: m.name,
+                    message: `"${m.name}" has ${m.fields.length} fields — may be doing too much`,
+                    suggestion: `Split into separate models or move related fields into a JSON column`,
+                }))
+        },
+    },
+
+    // SC006 — Unbounded string (SQL only)
+    {
+        id: 'SC006', name: 'Unbounded string field', severity: 'warning',
+        check(schema) {
+            if (schema.format !== 'sql') return []
+            const issues = []
+            for (const m of schema.models)
+                for (const f of m.fields)
+                    if (f.type === 'string' && !f.isPrimary && !f.isUnique)
+                        issues.push({
+                            ruleId: 'SC006', severity: 'warning', model: m.name, field: f.name,
+                            message: `"${m.name}.${f.name}" is an unbounded TEXT — consider VARCHAR(n)`,
+                            suggestion: `Use VARCHAR(255) or appropriate limit if max length is known`
+                        })
+            return issues
+        },
+    },
+
+    // SC007 — Email not unique
+    {
+        id: 'SC007', name: 'Email field not unique', severity: 'error',
+        check(schema) {
+            const issues = []
+            const EMAIL_NAMES = ['email', 'emailaddress', 'email_address', 'useremail']
+            for (const m of schema.models) {
+                for (const f of m.fields) {
+                    if (!EMAIL_NAMES.includes(f.name.toLowerCase())) continue
+                    const uniqueIdx = m.indexes.some(i => i.isUnique && i.fields.includes(f.name))
+                    if (!f.isUnique && !uniqueIdx)
+                        issues.push({
+                            ruleId: 'SC007', severity: 'error', model: m.name, field: f.name,
+                            message: `"${m.name}.${f.name}" should have a unique constraint`,
+                            suggestion: `Add @unique to the field or @@unique([${f.name}]) at model level`
+                        })
+                }
+            }
+            return issues
+        },
+    },
+
+    // SC008 — Inconsistent naming
+    {
+        id: 'SC008', name: 'Inconsistent field naming', severity: 'warning',
+        check(schema) {
+            const issues = []
+            for (const m of schema.models) {
+                const names = m.fields.map(f => f.name)
+                const camel = names.filter(n => /^[a-z][a-zA-Z0-9]*$/.test(n) && /[A-Z]/.test(n)).length
+                const snake = names.filter(n => /^[a-z][a-z0-9_]*_[a-z]/.test(n)).length
+                if (camel > 0 && snake > 0)
+                    issues.push({
+                        ruleId: 'SC008', severity: 'warning', model: m.name,
+                        message: `"${m.name}" mixes camelCase and snake_case field names`,
+                        suggestion: `Pick one: camelCase (userId) or snake_case (user_id)`
+                    })
+            }
+            return issues
+        },
+    },
+
+    // SC009 — Poor boolean naming
+    {
+        id: 'SC009', name: 'Boolean field unclear name', severity: 'info',
+        check(schema) {
+            const issues = []
+            const PREFIXES = ['is', 'has', 'can', 'should', 'allow', 'enable', 'show', 'hide']
+            for (const m of schema.models)
+                for (const f of m.fields)
+                    if (f.type === 'boolean' && !PREFIXES.some(p => f.name.toLowerCase().startsWith(p)))
+                        issues.push({
+                            ruleId: 'SC009', severity: 'info', model: m.name, field: f.name,
+                            message: `"${m.name}.${f.name}" is a boolean but doesn't start with is/has/can`,
+                            suggestion: `Rename to "is${f.name[0].toUpperCase()}${f.name.slice(1)}"`
+                        })
+            return issues
+        },
+    },
+
+    // SC010 — JSON field in relational schema
+    {
+        id: 'SC010', name: 'JSON field — consider typed relation', severity: 'info',
+        check(schema) {
+            if (schema.format === 'mongoose') return []
+            return schema.models.flatMap(m =>
+                m.fields
+                    .filter(f => f.type === 'json')
+                    .map(f => ({
+                        ruleId: 'SC010', severity: 'info', model: m.name, field: f.name,
+                        message: `"${m.name}.${f.name}" stores JSON — ensure this is intentional`,
+                        suggestion: `If data has a consistent shape, model it as a related table`
+                    }))
+            )
+        },
+    },
+
+    // SC011 — Missing tenantId consistency (multi-tenancy smell)
+    {
+        id: 'SC011', name: 'Inconsistent multi-tenancy', severity: 'warning',
+        check(schema) {
+            if (schema.models.length < 2) return []
+            const TENANT_FIELDS = ['tenantid', 'tenant_id', 'orgid', 'org_id', 'organizationid', 'workspace_id']
+            const modelsWithTenant = schema.models.filter(m =>
+                m.fields.some(f => TENANT_FIELDS.includes(f.name.toLowerCase()))
+            )
+            const modelsWithout = schema.models.filter(m =>
+                !m.fields.some(f => TENANT_FIELDS.includes(f.name.toLowerCase()))
+            )
+            if (modelsWithTenant.length > 0 && modelsWithout.length > 0)
+                return modelsWithout.map(m => ({
+                    ruleId: 'SC011', severity: 'warning', model: m.name,
+                    message: `"${m.name}" is missing a tenantId while other models have one`,
+                    suggestion: `Add tenantId to all models if building a multi-tenant SaaS`
+                }))
+            return []
+        },
+    },
+
+]
+
+// ═══════════════════════════════════════════════════════════════
+// SCORER
+// ═══════════════════════════════════════════════════════════════
+
+function analyze(schema) {
+    const issues = RULES.flatMap(rule => { try { return rule.check(schema) } catch { return [] } })
+
+    const WEIGHTS = { error: 10, warning: 4, info: 1 }
+    const penalty = issues.reduce((s, i) => s + WEIGHTS[i.severity], 0)
+    const modelCount = Math.max(schema.models.length, 1)
+    const fieldCount = Math.max(schema.models.reduce((s, m) => s + m.fields.length, 0), 1)
+    // Scale max penalty by both model count and field count so single-model schemas score fairly
+    const maxPenalty = Math.max(modelCount * 20, fieldCount * 2)
+    const norm = Math.min(penalty, maxPenalty)
+    const score = Math.max(0, Math.round(100 - (norm / maxPenalty) * 100))
+
+    const grade = score >= 90 ? 'A' : score >= 75 ? 'B' : score >= 60 ? 'C' : score >= 40 ? 'D' : 'F'
+
+    const issuesByModel = {}
+    for (const issue of issues) {
+        const key = issue.model ?? '_global'
+        if (!issuesByModel[key]) issuesByModel[key] = []
+        issuesByModel[key].push(issue)
+    }
+
+    return {
+        format: schema.format,
+        score, grade,
+        totalModels: schema.models.length,
+        totalFields: schema.models.reduce((s, m) => s + m.fields.length, 0),
+        issues, issuesByModel,
+        summary: {
+            errors: issues.filter(i => i.severity === 'error').length,
+            warnings: issues.filter(i => i.severity === 'warning').length,
+            infos: issues.filter(i => i.severity === 'info').length,
+        },
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// REPORTER
+// ═══════════════════════════════════════════════════════════════
+
+const C = {
+    reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+    red: '\x1b[31m', yellow: '\x1b[33m', blue: '\x1b[34m',
+    green: '\x1b[32m', cyan: '\x1b[36m', white: '\x1b[37m',
+    bgRed: '\x1b[41m', bgGreen: '\x1b[42m', bgYellow: '\x1b[43m',
+}
+const cc = (...codes) => text => codes.join('') + text + C.reset
+
+function scoreColor(s) { return s >= 90 ? C.green : s >= 75 ? C.cyan : s >= 60 ? C.yellow : C.red }
+
+function scoreBar(score, w = 28) {
+    const f = Math.round((score / 100) * w)
+    return scoreColor(score) + '█'.repeat(f) + C.dim + '░'.repeat(w - f) + C.reset
+}
+
+function severityBadge(sev) {
+    if (sev === 'error') return C.bold + C.bgRed + C.white + ' ERR ' + C.reset
+    if (sev === 'warning') return C.bold + C.bgYellow + ' WRN ' + C.reset
+    return C.bold + C.blue + ' INF ' + C.reset
+}
+
+function printReport(report, filePath) {
+    const hr = C.dim + '─'.repeat(58) + C.reset
+    const out = []
+
+    out.push('')
+    out.push(C.bold + C.cyan + '  schemacheck' + C.reset + C.dim + '  v0.1.0' + C.reset)
+    out.push(C.dim + `  ${filePath}` + C.reset)
+    out.push('')
+    out.push(hr)
+    out.push('')
+
+    const col = scoreColor(report.score)
+    out.push(
+        `  ${C.bold}Health score${C.reset}   ` +
+        col + C.bold + report.score + C.reset + C.dim + '/100' + C.reset +
+        '  ' + scoreBar(report.score) +
+        '  ' + col + C.bold + `Grade ${report.grade}` + C.reset
+    )
+    out.push('')
+    out.push(
+        C.dim + '  Format: ' + C.reset + C.white + report.format + C.reset +
+        C.dim + '   Models: ' + C.reset + C.white + report.totalModels + C.reset +
+        C.dim + '   Fields: ' + C.reset + C.white + report.totalFields + C.reset
+    )
+    out.push('')
+    out.push(hr)
+
+    if (report.issues.length === 0) {
+        out.push('')
+        out.push(C.green + C.bold + '  ✓ No issues found — schema looks healthy!' + C.reset)
+        out.push('')
+    } else {
+        out.push('')
+        out.push(
+            `  ${C.red + C.bold + report.summary.errors + ' error' + (report.summary.errors !== 1 ? 's' : '') + C.reset}` +
+            `  ${C.yellow + C.bold + report.summary.warnings + ' warning' + (report.summary.warnings !== 1 ? 's' : '') + C.reset}` +
+            `  ${C.blue + report.summary.infos + ' suggestion' + (report.summary.infos !== 1 ? 's' : '') + C.reset}`
+        )
+        out.push('')
+
+        for (const [modelName, issues] of Object.entries(report.issuesByModel)) {
+            out.push(`  ${C.bold + C.white + modelName + C.reset}`)
+            for (const issue of issues) {
+                out.push(`    ${severityBadge(issue.severity)} ${C.dim}[${issue.ruleId}]${C.reset} ${issue.message}`)
+                out.push(`    ${C.dim}        ↳ ${issue.suggestion}${C.reset}`)
+                out.push('')
+            }
+        }
+    }
+
+    out.push(hr)
+    out.push('')
+    process.stdout.write(out.join('\n'))
+}
+
+function printJSON(report) {
+    process.stdout.write(JSON.stringify(report, null, 2) + '\n')
+}
+
+function printCI(report, filePath) {
+    const lines = [
+        `schemacheck: ${filePath}`,
+        `score=${report.score} grade=${report.grade} errors=${report.summary.errors} warnings=${report.summary.warnings}`,
+    ]
+    for (const i of report.issues) {
+        const loc = [i.model, i.field].filter(Boolean).join('.')
+        lines.push(`::${i.severity === 'error' ? 'error' : 'warning'} title=${i.ruleId}::${loc}: ${i.message}`)
+    }
+    process.stdout.write(lines.join('\n') + '\n')
+}
+
+// ═══════════════════════════════════════════════════════════════
+// CLI
+// ═══════════════════════════════════════════════════════════════
+
+function printHelp() {
+    console.log(`
+  schemacheck — database schema health analyzer
+
+  Usage:
+    node run.js <schema-file> [options]
+    npx schemacheck <schema-file> [options]       (after npm publish)
+
+  Options:
+    --format=<fmt>      Force: prisma | drizzle | sql | mongoose
+    --output=<fmt>      Output: terminal (default) | json | ci
+    --fail-below=<n>    Exit 1 if score < n  (great for CI)
+    --help, -h          Show help
+
+  Examples:
+    node run.js ./prisma/schema.prisma
+    node run.js ./schema.sql --output=json
+    node run.js ./schema.prisma --fail-below=80 --output=ci
+`)
+}
+
+function main() {
+    const argv = process.argv.slice(2)
+
+    if (argv.length === 0 || argv.includes('--help') || argv.includes('-h')) {
+        printHelp(); process.exit(0)
+    }
+
+    const filePath = argv.find(a => !a.startsWith('-'))
+    const formatArg = argv.find(a => a.startsWith('--format='))?.split('=')[1]
+    const outputArg = argv.find(a => a.startsWith('--output='))?.split('=')[1] ?? 'terminal'
+    const failBelow = argv.find(a => a.startsWith('--fail-below='))?.split('=')[1]
+
+    if (!filePath) { console.error('  Error: no schema file provided. Run --help'); process.exit(1) }
+
+    try {
+        const schema = parseSchema(path.resolve(filePath), formatArg)
+        const report = analyze(schema)
+
+        if (outputArg === 'json') printJSON(report)
+        else if (outputArg === 'ci') printCI(report, filePath)
+        else printReport(report, filePath)
+
+        if (failBelow && report.score < parseInt(failBelow)) { process.exit(1) }
+        if (!failBelow && report.summary.errors > 0) { process.exit(1) }
+
+    } catch (err) {
+        console.error(`\n  Error: ${err.message}\n`)
+        process.exit(1)
+    }
+}
+
+main()

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@gaurav.codes/schemacheck",
+  "version": "0.1.0",
+  "description": "Database schema health analyzer for Prisma, Drizzle, SQL and Mongoose — catch missing indexes, bad patterns and anti-patterns before they hit production",
+  "author": "your-actual-name",
+  "license": "MIT",
+  "homepage": "https://github.com/your-username/schemacheck",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/your-username/schemacheck.git"
+  },
+  "bugs": {
+    "url": "https://github.com/your-username/schemacheck/issues"
+  },
+  "keywords": [
+    "schema",
+    "linter",
+    "prisma",
+    "drizzle",
+    "sql",
+    "mongoose",
+    "database",
+    "health",
+    "analyzer",
+    "cli",
+    "orm"
+  ],
+  "bin": {
+    "schemacheck": "cli.js"
+  },
+  "main": "./run.js",
+  "files": [
+    "run.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "dev": "ts-node src/cli.ts",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src/**/*.ts",
+    "prepublishOnly": "echo 'ready to publish'",
+    "start": "node run.js"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^7.0.0",
+    "@typescript-eslint/parser": "^7.0.0",
+    "eslint": "^8.57.0",
+    "jest": "^29.5.0",
+    "node-sql-parser": "^4.18.0",
+    "ts-jest": "^29.1.0",
+    "ts-morph": "^21.0.1",
+    "ts-node": "^10.9.0",
+    "typescript": "^5.4.0"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "testMatch": [
+      "**/tests/**/*.test.ts"
+    ],
+    "collectCoverageFrom": [
+      "src/**/*.ts"
+    ]
+  }
+}