@restforgejs/platform 4.1.1 → 4.3.1

package/generators/scripts/validate-dbschema-catalog.js

@@ -1,708 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * RESTForge - dbschema-kit Catalog Sync Validator
- *
- * Cross-check catalog metadata vs parser source code and spec doc
- * to detect drift between artifacts:
- *
- *   1. Catalog data    : generators/lib/templates/dbschema-catalog.js
- *   2. Parser code     : generators/lib/dbschema-kit/parser/shorthand-parser.js
- *                        generators/lib/dbschema-kit/ir-builder.js
- *                        generators/lib/dbschema-kit/validator/schema-validator.js
- *                        generators/lib/dbschema-kit/define-model.js
- *   3. Spec doc        : <repo-root>/docs/schema-reference/schema-definition.md
- *
- * Levels of validation:
- *   Level 1: Catalog structure integrity (required keys, field shape)
- *   Level 2: Parser source cross-reference (Set membership match)
- *   Level 3: Smoke test (catalog examples execute through actual parser)
- *   Level 4: Default value type consistency (parsed type matches field type)
- *   Level 5: Spec doc references (each entity is mentioned in markdown)
- *
- * Usage (jalankan dari folder packages/platform):
- *   node generators/scripts/validate-dbschema-catalog.js [--strict] [--quiet]
- *
- * Exit codes:
- *   0 = no issues, or only warnings (default)
- *   1 = errors found, or warnings found in --strict mode
- *
- * @module scripts/validate-dbschema-catalog
- */
-
-const fs = require('fs');
-const path = require('path');
-
-// ============================================================================
-// CONFIG
-// ============================================================================
-
-const CATALOG_PATH = path.join(__dirname, '..', 'lib', 'templates', 'dbschema-catalog.js');
-const SHORTHAND_PARSER_PATH = path.join(__dirname, '..', 'lib', 'dbschema-kit', 'parser', 'shorthand-parser.js');
-const IR_BUILDER_PATH = path.join(__dirname, '..', 'lib', 'dbschema-kit', 'ir-builder.js');
-const SCHEMA_VALIDATOR_PATH = path.join(__dirname, '..', 'lib', 'dbschema-kit', 'validator', 'schema-validator.js');
-const DEFINE_MODEL_PATH = path.join(__dirname, '..', 'lib', 'dbschema-kit', 'define-model.js');
-// Spec doc lives at <repo-root>/docs/schema-reference/schema-definition.md (v3 layout).
-// __dirname = packages/platform/generators/scripts → naik 4 level untuk reach repo root.
-const SPEC_DOC_PATH = path.join(__dirname, '..', '..', '..', '..', 'docs', 'schema-reference', 'schema-definition.md');
-
-// Mirrors ir-builder.js AUTO_UPDATE_TOKEN_RE_G (used to pre-strip autoUpdate before parser)
-const AUTO_UPDATE_RE = /(?:^|\s)autoUpdate(?=\s|$)/g;
-
-// ============================================================================
-// REPORTING
-// ============================================================================
-
-const report = {
-    errors: [],
-    warnings: [],
-    info: []
-};
-
-function err(msg) { report.errors.push(msg); }
-function warn(msg) { report.warnings.push(msg); }
-function info(msg) { report.info.push(msg); }
-
-// ============================================================================
-// PARSE ARGUMENTS
-// ============================================================================
-
-function parseArgs() {
-    const args = process.argv.slice(2);
-    return {
-        strict: args.includes('--strict'),
-        quiet: args.includes('--quiet')
-    };
-}
-
-// ============================================================================
-// HELPER — extract `new Set([...])` contents from source file text
-// ============================================================================
-
-function extractSetContents(source, varName) {
-    const re = new RegExp(`const\\s+${varName}\\s*=\\s*new Set\\(\\[([^\\]]+)\\]\\)`);
-    const m = source.match(re);
-    if (!m) return null;
-
-    const body = m[1];
-    const items = [];
-    const itemRe = /['"]([a-zA-Z_][a-zA-Z0-9_]*)['"]/g;
-    let im;
-    while ((im = itemRe.exec(body)) !== null) {
-        items.push(im[1]);
-    }
-    return new Set(items);
-}
-
-function readSource(filePath, label) {
-    if (!fs.existsSync(filePath)) {
-        err(`${label} not found: ${filePath}`);
-        return null;
-    }
-    return fs.readFileSync(filePath, 'utf8');
-}
-
-// ============================================================================
-// LEVEL 1: CATALOG STRUCTURE INTEGRITY
-// ============================================================================
-
-function checkCatalogStructure(catalog) {
-    const requiredKeys = [
-        'schemaVersion', 'source', 'summary',
-        'defineModelOptions', 'fieldTypes', 'constraints',
-        'relationTypes', 'referentialActions', 'checkOperations',
-        'auditColumns', 'shorthandSyntax', 'namingRules', 'dialectSupport'
-    ];
-    for (const key of requiredKeys) {
-        if (!(key in catalog)) err(`Catalog missing required top-level key: '${key}'`);
-    }
-
-    if (!Array.isArray(catalog.defineModelOptions)) err('catalog.defineModelOptions must be an array');
-    if (!Array.isArray(catalog.fieldTypes)) err('catalog.fieldTypes must be an array');
-    if (!Array.isArray(catalog.constraints)) err('catalog.constraints must be an array');
-    if (!Array.isArray(catalog.relationTypes)) err('catalog.relationTypes must be an array');
-    if (!Array.isArray(catalog.referentialActions)) err('catalog.referentialActions must be an array');
-    if (!Array.isArray(catalog.checkOperations)) err('catalog.checkOperations must be an array');
-    if (!Array.isArray(catalog.dialectSupport)) err('catalog.dialectSupport must be an array');
-}
-
-function checkFieldTypesIntegrity(fieldTypes) {
-    const requiredFields = ['name', 'description', 'requiresModifier', 'example'];
-    const seen = new Set();
-
-    for (const t of fieldTypes) {
-        for (const f of requiredFields) {
-            if (!(f in t)) err(`Field type '${t.name || '<unknown>'}' missing field: '${f}'`);
-        }
-        if (seen.has(t.name)) err(`Duplicate field type name: '${t.name}'`);
-        seen.add(t.name);
-
-        if (t.requiresModifier === true && !t.modifierFormat) {
-            err(`Field type '${t.name}': requiresModifier=true but missing modifierFormat`);
-        }
-    }
-}
-
-function checkConstraintsIntegrity(constraints) {
-    const requiredFields = ['name', 'kind', 'description', 'example'];
-    const validKinds = ['standalone', 'value'];
-    const seen = new Set();
-
-    for (const c of constraints) {
-        for (const f of requiredFields) {
-            if (!(f in c)) err(`Constraint '${c.name || '<unknown>'}' missing field: '${f}'`);
-        }
-        if (!validKinds.includes(c.kind)) {
-            err(`Constraint '${c.name}': invalid kind '${c.kind}' (must be one of: ${validKinds.join(', ')})`);
-        }
-        if (seen.has(c.name)) err(`Duplicate constraint name: '${c.name}'`);
-        seen.add(c.name);
-
-        if (c.kind === 'value' && !c.valueFormat) {
-            err(`Constraint '${c.name}': kind='value' but missing 'valueFormat'`);
-        }
-    }
-}
-
-function checkRelationTypesIntegrity(relationTypes) {
-    const requiredFields = ['name', 'description', 'requiredFields', 'optionalFields', 'example'];
-    const seen = new Set();
-
-    for (const r of relationTypes) {
-        for (const f of requiredFields) {
-            if (!(f in r)) err(`Relation type '${r.name || '<unknown>'}' missing field: '${f}'`);
-        }
-        if (seen.has(r.name)) err(`Duplicate relation type name: '${r.name}'`);
-        seen.add(r.name);
-
-        if (!Array.isArray(r.requiredFields)) err(`Relation type '${r.name}': requiredFields must be array`);
-        if (!Array.isArray(r.optionalFields)) err(`Relation type '${r.name}': optionalFields must be array`);
-    }
-}
-
-function checkReferentialActionsIntegrity(actions) {
-    const requiredFields = ['name', 'description', 'appliesTo'];
-    const seen = new Set();
-
-    for (const a of actions) {
-        for (const f of requiredFields) {
-            if (!(f in a)) err(`Referential action '${a.name || '<unknown>'}' missing field: '${f}'`);
-        }
-        if (seen.has(a.name)) err(`Duplicate referential action name: '${a.name}'`);
-        seen.add(a.name);
-
-        if (!Array.isArray(a.appliesTo)) err(`Referential action '${a.name}': appliesTo must be array`);
-    }
-}
-
-function checkCheckOperationsIntegrity(ops) {
-    const requiredFields = ['name', 'description', 'valueType', 'example'];
-    const seen = new Set();
-
-    for (const op of ops) {
-        for (const f of requiredFields) {
-            if (!(f in op)) err(`Check operation '${op.name || '<unknown>'}' missing field: '${f}'`);
-        }
-        if (seen.has(op.name)) err(`Duplicate check operation name: '${op.name}'`);
-        seen.add(op.name);
-    }
-}
-
-function checkAuditColumnsIntegrity(auditColumns) {
-    if (!auditColumns || typeof auditColumns !== 'object') {
-        err('catalog.auditColumns must be an object');
-        return;
-    }
-    if (!Array.isArray(auditColumns.columns)) {
-        err('catalog.auditColumns.columns must be an array');
-        return;
-    }
-
-    const required = ['name', 'shorthand', 'nullable', 'purpose'];
-    for (const col of auditColumns.columns) {
-        for (const f of required) {
-            if (!(f in col)) err(`Audit column '${col.name || '<unknown>'}' missing field: '${f}'`);
-        }
-    }
-}
-
-function checkDialectSupportIntegrity(dialects) {
-    const requiredFields = ['name', 'driver', 'booleanStorage'];
-    const seen = new Set();
-
-    for (const d of dialects) {
-        for (const f of requiredFields) {
-            if (!(f in d)) err(`Dialect '${d.name || '<unknown>'}' missing field: '${f}'`);
-        }
-        if (seen.has(d.name)) err(`Duplicate dialect name: '${d.name}'`);
-        seen.add(d.name);
-    }
-}
-
-// ============================================================================
-// LEVEL 2: PARSER SOURCE CROSS-REFERENCE (GROUND TRUTH)
-// ============================================================================
-
-function checkFieldTypesVsParser(catalog) {
-    const source = readSource(SHORTHAND_PARSER_PATH, 'Shorthand parser');
-    if (!source) return;
-
-    const parserTypes = extractSetContents(source, 'VALID_TYPES');
-    if (!parserTypes) {
-        warn('Could not extract VALID_TYPES from shorthand-parser.js (regex pattern may need update)');
-        return;
-    }
-
-    const catalogTypes = new Set(catalog.fieldTypes.map(t => t.name));
-
-    for (const t of parserTypes) {
-        if (!catalogTypes.has(t)) {
-            err(`Parser drift: type '${t}' exists in VALID_TYPES but missing from catalog.fieldTypes`);
-        }
-    }
-
-    for (const t of catalogTypes) {
-        if (!parserTypes.has(t)) {
-            err(`Parser drift: type '${t}' in catalog.fieldTypes but missing from parser VALID_TYPES`);
-        }
-    }
-}
-
-function checkConstraintsVsParser(catalog) {
-    const parserSrc = readSource(SHORTHAND_PARSER_PATH, 'Shorthand parser');
-    if (!parserSrc) return;
-
-    const standaloneFromParser = extractSetContents(parserSrc, 'STANDALONE_CONSTRAINTS') || new Set();
-    const valueFromParser = extractSetContents(parserSrc, 'VALUE_CONSTRAINTS') || new Set();
-
-    // autoUpdate is pre-processed in ir-builder.js, also a valid constraint at the API surface
-    let irHasAutoUpdate = false;
-    const irSrc = readSource(IR_BUILDER_PATH, 'IR builder');
-    if (irSrc) irHasAutoUpdate = /AUTO_UPDATE_TOKEN_RE/.test(irSrc);
-
-    const parserConstraints = new Set([...standaloneFromParser, ...valueFromParser]);
-    if (irHasAutoUpdate) parserConstraints.add('autoUpdate');
-
-    const catalogConstraintNames = new Set(catalog.constraints.map(c => c.name));
-
-    for (const c of parserConstraints) {
-        if (!catalogConstraintNames.has(c)) {
-            err(`Parser drift: constraint '${c}' valid in parser but missing from catalog.constraints`);
-        }
-    }
-
-    for (const c of catalogConstraintNames) {
-        if (!parserConstraints.has(c)) {
-            err(`Parser drift: constraint '${c}' in catalog but not recognized by parser or ir-builder`);
-        }
-    }
-
-    // Verify kind matches parser STANDALONE_CONSTRAINTS / VALUE_CONSTRAINTS partitioning
-    for (const c of catalog.constraints) {
-        if (standaloneFromParser.has(c.name) && c.kind !== 'standalone') {
-            err(`Constraint '${c.name}': kind='${c.kind}' in catalog but is STANDALONE in parser`);
-        }
-        if (valueFromParser.has(c.name) && c.kind !== 'value') {
-            err(`Constraint '${c.name}': kind='${c.kind}' in catalog but is VALUE in parser`);
-        }
-    }
-}
-
-function checkRelationTypesVsValidator(catalog) {
-    const source = readSource(SCHEMA_VALIDATOR_PATH, 'Schema validator');
-    if (!source) return;
-
-    const validatorTypes = extractSetContents(source, 'VALID_RELATION_TYPES');
-    if (!validatorTypes) {
-        warn('Could not extract VALID_RELATION_TYPES from schema-validator.js');
-    } else {
-        const catalogTypes = new Set(catalog.relationTypes.map(r => r.name));
-
-        for (const t of validatorTypes) {
-            if (!catalogTypes.has(t)) {
-                err(`Validator drift: relation type '${t}' valid in VALID_RELATION_TYPES but missing from catalog.relationTypes`);
-            }
-        }
-        for (const t of catalogTypes) {
-            if (!validatorTypes.has(t)) {
-                err(`Validator drift: relation type '${t}' in catalog but not in VALID_RELATION_TYPES`);
-            }
-        }
-    }
-
-    // Validator throws if localKey is missing — so it must be in requiredFields, not optional
-    const requiresLocalKey = /missing\s+'localKey'/.test(source);
-    if (requiresLocalKey) {
-        for (const r of catalog.relationTypes) {
-            if (r.optionalFields.includes('localKey')) {
-                err(`Relation type '${r.name}': validator throws on missing 'localKey' but catalog marks it as OPTIONAL`);
-            }
-            if (!r.requiredFields.includes('localKey')) {
-                err(`Relation type '${r.name}': validator requires 'localKey' but catalog does not list it in requiredFields`);
-            }
-        }
-    }
-
-    // The validator only checks typeof rel.references === 'string', so it expects a bare column name
-    // Catalog examples that show 'references: "table(column)"' would mislead consumers
-    for (const r of catalog.relationTypes) {
-        if (typeof r.example !== 'string') continue;
-        const refMatch = r.example.match(/references:\s*["']([^"']+)["']/);
-        if (refMatch && /\(.*\)/.test(refMatch[1])) {
-            err(`Relation type '${r.name}': example shows 'references: "${refMatch[1]}"' (table(column) form) but validator expects a bare column name`);
-        }
-    }
-}
-
-function checkReferentialActionsVsValidator(catalog) {
-    const source = readSource(SCHEMA_VALIDATOR_PATH, 'Schema validator');
-    if (!source) return;
-
-    const validatorActions = extractSetContents(source, 'VALID_REFERENTIAL_ACTIONS');
-    if (!validatorActions) {
-        warn('Could not extract VALID_REFERENTIAL_ACTIONS from schema-validator.js');
-        return;
-    }
-
-    const catalogActions = new Set(catalog.referentialActions.map(a => a.name));
-
-    for (const a of validatorActions) {
-        if (!catalogActions.has(a)) {
-            err(`Validator drift: referential action '${a}' valid in validator but missing from catalog`);
-        }
-    }
-    for (const a of catalogActions) {
-        if (!validatorActions.has(a)) {
-            err(`Validator drift: referential action '${a}' in catalog but not in VALID_REFERENTIAL_ACTIONS`);
-        }
-    }
-}
-
-function checkCheckOperationsVsIrBuilder(catalog) {
-    const source = readSource(IR_BUILDER_PATH, 'IR builder');
-    if (!source) return;
-
-    const irOps = extractSetContents(source, 'VALID_CHECK_OPS');
-    if (!irOps) {
-        warn('Could not extract VALID_CHECK_OPS from ir-builder.js');
-    } else {
-        const catalogOps = new Set(catalog.checkOperations.map(o => o.name));
-
-        for (const o of irOps) {
-            if (!catalogOps.has(o)) {
-                err(`IR drift: check op '${o}' valid in VALID_CHECK_OPS but missing from catalog`);
-            }
-        }
-        for (const o of catalogOps) {
-            if (!irOps.has(o)) {
-                err(`IR drift: check op '${o}' in catalog but not in VALID_CHECK_OPS`);
-            }
-        }
-    }
-
-    // User-facing format is `{ field, <op>: value }` (operator as key).
-    // The `{ op, field, value }` shape is the IR output, not the user input.
-    for (const op of catalog.checkOperations) {
-        if (typeof op.example === 'string' && /\bop\s*:\s*['"]/.test(op.example)) {
-            err(`Check op '${op.name}': example uses IR output shape '{ op: ... }' instead of user input shape '{ field, ${op.name}: ... }'`);
-        }
-    }
-}
-
-// Scan ALL catalog sections for IR check anti-pattern. Catches cases where
-// description or example anywhere in the catalog (not just checkOperations)
-// uses the internal IR shape `{ op, field, value }` instead of user input
-// shape `{ field, <op>: value }`. This complements checkCheckOperationsVsIrBuilder
-// which only scans the checkOperations section itself.
-function checkAllCatalogForIrCheckPattern(catalog) {
-    const opValueRe = /\bop\s*:\s*['"](?:in|eq|neq|gt|gte|lt|lte)['"]/;
-    const descShapeRe = /\{[^}]*\bop\b[^}]*\bfield\b[^}]*\bvalue\b[^}]*\}/;
-
-    const arraySections = [
-        'defineModelOptions', 'fieldTypes', 'constraints',
-        'relationTypes', 'referentialActions', 'dialectSupport'
-        // Skip checkOperations — already covered by checkCheckOperationsVsIrBuilder
-    ];
-
-    for (const sectionName of arraySections) {
-        const items = catalog[sectionName];
-        if (!Array.isArray(items)) continue;
-
-        for (const item of items) {
-            const label = item.name ? `${sectionName}.${item.name}` : sectionName;
-
-            if (typeof item.example === 'string' && opValueRe.test(item.example)) {
-                err(`${label}.example uses IR check shape '{ op: "...", field, value }'. Use user input shape '{ field, <op>: <value> }' instead.`);
-            }
-            if (typeof item.description === 'string' && descShapeRe.test(item.description)) {
-                err(`${label}.description describes IR check shape '{ ..., op, field, value, ... }'. User input shape uses operator-as-key.`);
-            }
-        }
-    }
-
-    // Also scan shorthandSyntax.examples meaning strings
-    if (catalog.shorthandSyntax && Array.isArray(catalog.shorthandSyntax.examples)) {
-        for (const ex of catalog.shorthandSyntax.examples) {
-            if (typeof ex.meaning === 'string' && opValueRe.test(ex.meaning)) {
-                err(`shorthandSyntax.examples meaning uses IR check shape: '${ex.meaning}'`);
-            }
-        }
-    }
-}
-
-function checkDefineModelSignature(catalog) {
-    const source = readSource(DEFINE_MODEL_PATH, 'define-model');
-    if (!source) return;
-
-    const isPositional = /function\s+defineModel\s*\(\s*tableName\s*,\s*options\s*\)/.test(source);
-    if (!isPositional) {
-        warn('Could not verify defineModel signature in define-model.js (regex pattern may need update)');
-        return;
-    }
-
-    const tableNameOption = catalog.defineModelOptions.find(o => o.name === 'tableName');
-    if (tableNameOption) {
-        err(`Signature drift: 'tableName' is a positional argument in defineModel(tableName, options) but catalog.defineModelOptions lists it as an options property`);
-    }
-}
-
-// ============================================================================
-// LEVEL 3: SMOKE TEST — execute catalog examples through actual parser
-// ============================================================================
-
-function collectShorthandExamples(catalog) {
-    const examples = [];
-
-    for (const t of catalog.fieldTypes) {
-        if (typeof t.example === 'string') {
-            examples.push({ source: `fieldTypes.${t.name}.example`, input: t.example });
-        }
-    }
-    for (const c of catalog.constraints) {
-        if (typeof c.example === 'string') {
-            examples.push({ source: `constraints.${c.name}.example`, input: c.example });
-        }
-    }
-    if (catalog.shorthandSyntax && Array.isArray(catalog.shorthandSyntax.examples)) {
-        for (const ex of catalog.shorthandSyntax.examples) {
-            if (typeof ex.input === 'string') {
-                examples.push({ source: `shorthandSyntax.examples[${JSON.stringify(ex.input)}]`, input: ex.input });
-            }
-        }
-    }
-    if (catalog.auditColumns && Array.isArray(catalog.auditColumns.columns)) {
-        for (const col of catalog.auditColumns.columns) {
-            if (typeof col.shorthand === 'string') {
-                examples.push({ source: `auditColumns.${col.name}.shorthand`, input: col.shorthand });
-            }
-        }
-    }
-
-    return examples;
-}
-
-function loadParser() {
-    try {
-        const mod = require(SHORTHAND_PARSER_PATH);
-        if (typeof mod.parseFieldShorthand !== 'function') {
-            err('shorthand-parser.js does not export parseFieldShorthand');
-            return null;
-        }
-        return mod.parseFieldShorthand;
-    } catch (e) {
-        err(`Could not load shorthand-parser.js: ${e.message}`);
-        return null;
-    }
-}
-
-function checkExamplesParseable(catalog, parseFieldShorthand) {
-    if (!parseFieldShorthand) return;
-    const examples = collectShorthandExamples(catalog);
-
-    for (const { source, input } of examples) {
-        const cleaned = input.replace(AUTO_UPDATE_RE, ' ').trim();
-        if (cleaned === '') continue;
-
-        try {
-            parseFieldShorthand(cleaned, '_smoke_test_');
-        } catch (e) {
-            err(`Smoke test FAIL: ${source} — input '${input}' threw: ${e.message}`);
-        }
-    }
-}
-
-// ============================================================================
-// LEVEL 4: DEFAULT VALUE TYPE CONSISTENCY
-// ============================================================================
-
-function checkDefaultValueTypeConsistency(catalog, parseFieldShorthand) {
-    if (!parseFieldShorthand) return;
-
-    const examples = collectShorthandExamples(catalog).filter(e => e.input.includes('default:'));
-
-    for (const { source, input } of examples) {
-        let parsed;
-        try {
-            const cleaned = input.replace(AUTO_UPDATE_RE, ' ').trim();
-            parsed = parseFieldShorthand(cleaned, '_type_test_');
-        } catch {
-            continue; // caught by smoke test
-        }
-
-        if (!parsed || !parsed.default || parsed.default.kind !== 'literal') continue;
-        const valueType = typeof parsed.default.value;
-
-        if (parsed.type === 'boolean' && valueType !== 'boolean') {
-            warn(`${source}: type 'boolean' with default '${input}' parses default as ${valueType}, expected boolean. Use 'default:true' (raw, no quote) instead.`);
-        }
-        if ((parsed.type === 'integer' || parsed.type === 'bigint' || parsed.type === 'decimal') && valueType !== 'number') {
-            warn(`${source}: type '${parsed.type}' with default '${input}' parses default as ${valueType}, expected number. Use raw form like 'default:0' (no quote) instead.`);
-        }
-        if ((parsed.type === 'string' || parsed.type === 'text') && valueType !== 'string') {
-            warn(`${source}: type '${parsed.type}' with default '${input}' parses default as ${valueType}, expected string. Use quoted form like 'default:\\'value\\'' instead.`);
-        }
-    }
-}
-
-// ============================================================================
-// LEVEL 5: SPEC DOC REFERENCE
-// ============================================================================
-
-function checkSpecDocReferences(catalog) {
-    if (!fs.existsSync(SPEC_DOC_PATH)) {
-        warn(`Spec doc not found: ${SPEC_DOC_PATH}`);
-        return;
-    }
-
-    const doc = fs.readFileSync(SPEC_DOC_PATH, 'utf8');
-
-    const checks = [
-        { items: catalog.fieldTypes, label: 'field type' },
-        { items: catalog.constraints, label: 'constraint' },
-        { items: catalog.relationTypes, label: 'relation type' },
-        { items: catalog.referentialActions, label: 'referential action' },
-        { items: catalog.checkOperations, label: 'check op' },
-        { items: catalog.dialectSupport, label: 'dialect' }
-    ];
-
-    for (const { items, label } of checks) {
-        for (const it of items) {
-            const re = new RegExp(`\\b${it.name}\\b`, 'i');
-            if (!re.test(doc)) warn(`Spec doc: ${label} '${it.name}' not referenced in schema-definition.md`);
-        }
-    }
-}
-
-// ============================================================================
-// MAIN
-// ============================================================================
-
-function printReport(quiet) {
-    const lines = [];
-
-    lines.push('');
-    lines.push('================================================================');
-    lines.push('  dbschema-kit Catalog Sync Validator');
-    lines.push('================================================================');
-    lines.push('');
-
-    if (report.errors.length > 0) {
-        lines.push(`ERRORS (${report.errors.length}):`);
-        for (const e of report.errors) lines.push(`  [X] ${e}`);
-        lines.push('');
-    }
-
-    if (report.warnings.length > 0) {
-        lines.push(`WARNINGS (${report.warnings.length}):`);
-        for (const w of report.warnings) lines.push(`  [!] ${w}`);
-        lines.push('');
-    }
-
-    if (!quiet && report.info.length > 0) {
-        lines.push(`INFO (${report.info.length}):`);
-        for (const i of report.info) lines.push(`  [i] ${i}`);
-        lines.push('');
-    }
-
-    lines.push('----------------------------------------------------------------');
-    lines.push('  Summary');
-    lines.push('----------------------------------------------------------------');
-    lines.push(`  Errors  : ${report.errors.length}`);
-    lines.push(`  Warnings: ${report.warnings.length}`);
-    lines.push(`  Info    : ${report.info.length}`);
-    lines.push('');
-
-    if (report.errors.length === 0 && report.warnings.length === 0) {
-        lines.push('  Status: PASS — catalog is in sync with parser source and spec doc.');
-    } else if (report.errors.length === 0) {
-        lines.push('  Status: PASS WITH WARNINGS — review warnings above.');
-    } else {
-        lines.push('  Status: FAIL — fix errors before commit.');
-    }
-    lines.push('');
-
-    console.log(lines.join('\n'));
-}
-
-function main() {
-    const opts = parseArgs();
-
-    let catalog;
-    try {
-        ({ DBSCHEMA_CATALOG: catalog } = require(CATALOG_PATH));
-    } catch (e) {
-        console.error(`Failed to load catalog from ${CATALOG_PATH}`);
-        console.error(e.message);
-        process.exit(1);
-    }
-
-    info(`Catalog loaded from: ${path.relative(process.cwd(), CATALOG_PATH)}`);
-    info(`Schema version: ${catalog.schemaVersion}`);
-    info(
-        `Field types: ${catalog.fieldTypes ? catalog.fieldTypes.length : 0}, ` +
-        `Constraints: ${catalog.constraints ? catalog.constraints.length : 0}, ` +
-        `Relation types: ${catalog.relationTypes ? catalog.relationTypes.length : 0}, ` +
-        `Check ops: ${catalog.checkOperations ? catalog.checkOperations.length : 0}`
-    );
-
-    // Level 1: catalog structural integrity
-    checkCatalogStructure(catalog);
-    if (Array.isArray(catalog.fieldTypes)) checkFieldTypesIntegrity(catalog.fieldTypes);
-    if (Array.isArray(catalog.constraints)) checkConstraintsIntegrity(catalog.constraints);
-    if (Array.isArray(catalog.relationTypes)) checkRelationTypesIntegrity(catalog.relationTypes);
-    if (Array.isArray(catalog.referentialActions)) checkReferentialActionsIntegrity(catalog.referentialActions);
-    if (Array.isArray(catalog.checkOperations)) checkCheckOperationsIntegrity(catalog.checkOperations);
-    if (catalog.auditColumns) checkAuditColumnsIntegrity(catalog.auditColumns);
-    if (Array.isArray(catalog.dialectSupport)) checkDialectSupportIntegrity(catalog.dialectSupport);
-
-    // Stop early on structural failure — downstream checks would be misleading
-    if (report.errors.length > 0) {
-        printReport(opts.quiet);
-        process.exit(1);
-    }
-
-    // Level 2: parser source cross-reference
-    checkFieldTypesVsParser(catalog);
-    checkConstraintsVsParser(catalog);
-    checkRelationTypesVsValidator(catalog);
-    checkReferentialActionsVsValidator(catalog);
-    checkCheckOperationsVsIrBuilder(catalog);
-    checkAllCatalogForIrCheckPattern(catalog);
-    checkDefineModelSignature(catalog);
-
-    // Level 3 + 4: parser smoke test + default value type consistency
-    const parseFieldShorthand = loadParser();
-    checkExamplesParseable(catalog, parseFieldShorthand);
-    checkDefaultValueTypeConsistency(catalog, parseFieldShorthand);
-
-    // Level 5: spec doc references
-    checkSpecDocReferences(catalog);
-
-    printReport(opts.quiet);
-
-    if (report.errors.length > 0) process.exit(1);
-    if (opts.strict && report.warnings.length > 0) process.exit(1);
-    process.exit(0);
-}
-
-main();