@happyvertical/smrt-cli 0.30.0

package/dist/json-validator-zsI8zUQC.js

@@ -0,0 +1,912 @@
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { basename, resolve } from "node:path";
+import { getPackageConfig } from "@happyvertical/smrt-config";
+import { ObjectRegistry } from "@happyvertical/smrt-core";
+import glob from "fast-glob";
+const ValidationCodes = {
+  // Structure issues
+  INVALID_JSON: "INVALID_JSON",
+  NOT_ARRAY: "NOT_ARRAY",
+  EMPTY_OBJECT: "EMPTY_OBJECT",
+  // ID/Slug issues
+  MISSING_ID: "MISSING_ID",
+  DUPLICATE_ID: "DUPLICATE_ID",
+  INVALID_ID_FORMAT: "INVALID_ID_FORMAT",
+  MISSING_SLUG: "MISSING_SLUG",
+  DUPLICATE_SLUG_CONTEXT: "DUPLICATE_SLUG_CONTEXT",
+  // Type issues
+  INVALID_TYPE: "INVALID_TYPE",
+  INVALID_DATE: "INVALID_DATE",
+  INVALID_JSON_FIELD: "INVALID_JSON_FIELD",
+  INVALID_BOOLEAN: "INVALID_BOOLEAN",
+  INVALID_NUMBER: "INVALID_NUMBER",
+  INVALID_INTEGER: "INVALID_INTEGER",
+  // STI issues
+  MISSING_META_TYPE: "MISSING_META_TYPE",
+  UNKNOWN_META_TYPE: "UNKNOWN_META_TYPE",
+  INVALID_META_DATA: "INVALID_META_DATA",
+  // Required field issues
+  MISSING_REQUIRED_FIELD: "MISSING_REQUIRED_FIELD",
+  // Constraint issues
+  VALUE_OUT_OF_RANGE: "VALUE_OUT_OF_RANGE",
+  STRING_TOO_LONG: "STRING_TOO_LONG",
+  STRING_TOO_SHORT: "STRING_TOO_SHORT",
+  PATTERN_MISMATCH: "PATTERN_MISMATCH",
+  // Relationship issues (full validation only)
+  INVALID_FOREIGN_KEY: "INVALID_FOREIGN_KEY",
+  MISSING_FK_TABLE: "MISSING_FK_TABLE",
+  ORPHANED_RECORD: "ORPHANED_RECORD",
+  // Schema mismatch
+  UNKNOWN_FIELD: "UNKNOWN_FIELD",
+  MISSING_TABLE_FILE: "MISSING_TABLE_FILE",
+  UNKNOWN_TABLE: "UNKNOWN_TABLE"
+};
+function toSnakeCase(str) {
+  return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+}
+async function resolveDataPath(explicitPath) {
+  if (explicitPath) {
+    const resolved = resolve(process.cwd(), explicitPath);
+    if (!existsSync(resolved)) {
+      return null;
+    }
+    return resolved;
+  }
+  try {
+    const { DEFAULT_CLI_CONFIG: defaultConfig } = await import("./config-C8pQD-tk.js");
+    const config = getPackageConfig(
+      "cli",
+      defaultConfig
+    );
+    if (config.database?.url) {
+      const dbUrl = config.database.url;
+      if (!dbUrl.includes(":memory:") && !dbUrl.endsWith(".db") && !dbUrl.endsWith(".sqlite")) {
+        const configPath = resolve(process.cwd(), dbUrl);
+        if (existsSync(configPath)) {
+          const hasJsonFiles = await glob("*.json", { cwd: configPath });
+          if (hasJsonFiles.length > 0) {
+            return configPath;
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  const commonPaths = ["./data", "./db", "./.data", "./json-db"];
+  for (const path of commonPaths) {
+    const resolved = resolve(process.cwd(), path);
+    if (existsSync(resolved)) {
+      const hasJsonFiles = await glob("*.json", { cwd: resolved });
+      if (hasJsonFiles.length > 0) {
+        return resolved;
+      }
+    }
+  }
+  return null;
+}
+async function discoverJsonFiles(dataPath) {
+  return glob("*.json", {
+    cwd: dataPath,
+    absolute: true,
+    ignore: ["*.schema.json", "package.json", "tsconfig.json", "manifest.json"]
+  });
+}
+function inferTableName(fileName) {
+  return fileName.replace(/\.json$/, "").toLowerCase();
+}
+const IRREGULAR_PLURALS = {
+  people: "person",
+  children: "child",
+  men: "man",
+  women: "woman",
+  mice: "mouse",
+  geese: "goose",
+  teeth: "tooth",
+  feet: "foot",
+  data: "datum",
+  media: "medium",
+  criteria: "criterion",
+  phenomena: "phenomenon",
+  analyses: "analysis",
+  indices: "index",
+  matrices: "matrix",
+  vertices: "vertex"
+};
+function toSingular(tableName) {
+  const lower = tableName.toLowerCase();
+  if (IRREGULAR_PLURALS[lower]) {
+    return IRREGULAR_PLURALS[lower];
+  }
+  return tableName.replace(/s$/, "");
+}
+function findObjectTypeForTable(tableName) {
+  const allClasses = ObjectRegistry.getAllClasses();
+  for (const [_key, metadata] of allClasses) {
+    const simpleName = metadata.name || _key;
+    const registeredTableName = ObjectRegistry.getTableName(simpleName);
+    if (registeredTableName === tableName) {
+      return simpleName;
+    }
+  }
+  const singular = toSingular(tableName);
+  for (const [_key, metadata] of allClasses) {
+    const simpleName = metadata.name || _key;
+    if (simpleName.toLowerCase() === singular) {
+      return simpleName;
+    }
+  }
+  return null;
+}
+class JsonDatabaseValidator {
+  dataPath;
+  quickMode;
+  verbose;
+  loadedData = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.dataPath = options.dataPath;
+    this.quickMode = options.quickMode;
+    this.verbose = options.verbose;
+  }
+  /**
+   * Run validation on all discovered JSON files
+   */
+  async validate(jsonFiles) {
+    const results = [];
+    const fixableIssues = [];
+    await this.loadAllFiles(jsonFiles);
+    for (const filePath of jsonFiles) {
+      const result = await this.validateFile(filePath);
+      results.push(result);
+      for (const issue of result.issues) {
+        if (issue.fixable) {
+          fixableIssues.push(issue);
+        }
+      }
+    }
+    if (!this.quickMode) {
+      await this.validateForeignKeys(results);
+    }
+    return { objectResults: results, fixableIssues };
+  }
+  /**
+   * Load all JSON files into memory for cross-file validation (FK checks).
+   *
+   * @remarks
+   * Files that fail to load are silently skipped here but will produce
+   * validation errors when validateFile() is called. In verbose mode,
+   * load failures are logged for debugging.
+   */
+  async loadAllFiles(jsonFiles) {
+    for (const filePath of jsonFiles) {
+      const fileName = basename(filePath, ".json");
+      const tableName = inferTableName(fileName);
+      try {
+        const content = await readFile(filePath, "utf-8");
+        const data = JSON.parse(content);
+        if (Array.isArray(data)) {
+          this.loadedData.set(tableName, data);
+        }
+      } catch (error) {
+        if (this.verbose) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          console.error(
+            `  [verbose] Failed to pre-load ${filePath}: ${errorMessage}`
+          );
+        }
+      }
+    }
+  }
+  /**
+   * Validate a single JSON file
+   */
+  async validateFile(filePath) {
+    const issues = [];
+    const fileName = basename(filePath, ".json");
+    const tableName = inferTableName(fileName);
+    const objectType = findObjectTypeForTable(tableName);
+    const fields = objectType ? ObjectRegistry.getFields(objectType) : /* @__PURE__ */ new Map();
+    let records;
+    try {
+      const content = await readFile(filePath, "utf-8");
+      records = JSON.parse(content);
+    } catch (error) {
+      issues.push({
+        severity: "error",
+        code: ValidationCodes.INVALID_JSON,
+        message: `Invalid JSON: ${error instanceof Error ? error.message : String(error)}`,
+        file: filePath
+      });
+      return this.createResult(objectType, tableName, filePath, 0, issues, 0);
+    }
+    if (!Array.isArray(records)) {
+      issues.push({
+        severity: "error",
+        code: ValidationCodes.NOT_ARRAY,
+        message: "Root element must be an array",
+        file: filePath
+      });
+      return this.createResult(objectType, tableName, filePath, 0, issues, 0);
+    }
+    if (!objectType) {
+      issues.push({
+        severity: "warning",
+        code: ValidationCodes.UNKNOWN_TABLE,
+        message: `No SMRT object found for table '${tableName}' - skipping field validation`,
+        file: filePath
+      });
+    }
+    const seenIds = /* @__PURE__ */ new Set();
+    const seenSlugContext = /* @__PURE__ */ new Set();
+    let validCount = 0;
+    for (let i = 0; i < records.length; i++) {
+      const record = records[i];
+      if (typeof record !== "object" || record === null) {
+        issues.push({
+          severity: "error",
+          code: ValidationCodes.EMPTY_OBJECT,
+          message: `Record at index ${i} is not an object`,
+          file: filePath,
+          objectId: `[index:${i}]`
+        });
+        continue;
+      }
+      const recordIssues = this.validateRecord(
+        record,
+        fields,
+        objectType,
+        filePath,
+        i,
+        seenIds,
+        seenSlugContext
+      );
+      if (recordIssues.length === 0) {
+        validCount++;
+      }
+      issues.push(...recordIssues);
+    }
+    return this.createResult(
+      objectType,
+      tableName,
+      filePath,
+      records.length,
+      issues,
+      validCount
+    );
+  }
+  /**
+   * Validate a single record
+   */
+  validateRecord(record, fields, objectType, filePath, index, seenIds, seenSlugContext) {
+    const issues = [];
+    const objectId = record.id || `[index:${index}]`;
+    if (!record.id) {
+      issues.push({
+        severity: "error",
+        code: ValidationCodes.MISSING_ID,
+        message: `Record at index ${index} missing required 'id' field`,
+        file: filePath,
+        objectId: `[index:${index}]`
+      });
+    } else if (typeof record.id !== "string") {
+      issues.push({
+        severity: "error",
+        code: ValidationCodes.INVALID_ID_FORMAT,
+        message: `Record ID must be a string, got ${typeof record.id}`,
+        file: filePath,
+        objectId: String(record.id)
+      });
+    } else if (seenIds.has(record.id)) {
+      issues.push({
+        severity: "error",
+        code: ValidationCodes.DUPLICATE_ID,
+        message: `Duplicate ID: ${record.id}`,
+        file: filePath,
+        objectId: record.id
+      });
+    } else {
+      seenIds.add(record.id);
+    }
+    if (record.slug) {
+      const context = record.context || "";
+      const slugKey = `${record.slug}:${context}`;
+      if (seenSlugContext.has(slugKey)) {
+        issues.push({
+          severity: "error",
+          code: ValidationCodes.DUPLICATE_SLUG_CONTEXT,
+          message: `Duplicate slug+context: '${record.slug}' in context '${context}'`,
+          file: filePath,
+          objectId
+        });
+      } else {
+        seenSlugContext.add(slugKey);
+      }
+    }
+    if (objectType) {
+      const tableStrategy = ObjectRegistry.getTableStrategy(objectType);
+      if (tableStrategy === "sti") {
+        issues.push(
+          ...this.validateSTIFields(record, objectType, filePath, objectId)
+        );
+      }
+    }
+    for (const [fieldName, fieldDef] of fields) {
+      issues.push(
+        ...this.validateField(
+          record,
+          fieldName,
+          fieldDef,
+          filePath,
+          objectId
+        )
+      );
+    }
+    return issues;
+  }
+  /**
+   * Validate STI-specific fields
+   */
+  validateSTIFields(record, objectType, filePath, objectId) {
+    const issues = [];
+    if (!record._meta_type) {
+      issues.push({
+        severity: "error",
+        code: ValidationCodes.MISSING_META_TYPE,
+        message: "STI record missing _meta_type discriminator",
+        file: filePath,
+        objectId,
+        objectType,
+        field: "_meta_type"
+      });
+    } else if (typeof record._meta_type !== "string") {
+      issues.push({
+        severity: "error",
+        code: ValidationCodes.INVALID_TYPE,
+        message: `_meta_type must be a string, got ${typeof record._meta_type}`,
+        file: filePath,
+        objectId,
+        objectType,
+        field: "_meta_type"
+      });
+    } else {
+      if (!ObjectRegistry.getClass(record._meta_type)) {
+        issues.push({
+          severity: "warning",
+          code: ValidationCodes.UNKNOWN_META_TYPE,
+          message: `Unknown _meta_type: '${record._meta_type}' (may be from unloaded package)`,
+          file: filePath,
+          objectId,
+          objectType,
+          field: "_meta_type",
+          actual: record._meta_type
+        });
+      }
+    }
+    if (record._meta_data !== void 0 && record._meta_data !== null) {
+      if (typeof record._meta_data !== "object" || Array.isArray(record._meta_data)) {
+        issues.push({
+          severity: "error",
+          code: ValidationCodes.INVALID_META_DATA,
+          message: "_meta_data must be an object",
+          file: filePath,
+          objectId,
+          objectType,
+          field: "_meta_data",
+          expected: "object",
+          actual: typeof record._meta_data
+        });
+      }
+    }
+    return issues;
+  }
+  /**
+   * Validate a single field against its definition.
+   *
+   * @remarks
+   * Null handling varies by field type:
+   * - Required fields: null triggers MISSING_REQUIRED_FIELD error
+   * - JSON type: null is valid (it's a valid JSON value)
+   * - Other types: null is treated as "no value" and skips validation
+   */
+  validateField(record, fieldName, fieldDef, filePath, objectId) {
+    const issues = [];
+    const snakeCaseFieldName = toSnakeCase(fieldName);
+    const value = record[snakeCaseFieldName];
+    const fieldType = fieldDef.type;
+    if (fieldDef.required && (value === void 0 || value === null)) {
+      issues.push({
+        severity: "error",
+        code: ValidationCodes.MISSING_REQUIRED_FIELD,
+        message: `Missing required field: ${fieldName}`,
+        file: filePath,
+        objectId,
+        field: fieldName,
+        fixable: fieldDef.default !== void 0
+      });
+      return issues;
+    }
+    if (value === void 0) {
+      return issues;
+    }
+    if (value === null && fieldType !== "json") {
+      return issues;
+    }
+    const typeIssue = this.validateFieldType(
+      value,
+      fieldType,
+      fieldName,
+      objectId,
+      filePath
+    );
+    if (typeIssue) {
+      issues.push(typeIssue);
+    }
+    if (value !== null) {
+      issues.push(
+        ...this.validateConstraints(
+          value,
+          fieldDef,
+          fieldName,
+          objectId,
+          filePath
+        )
+      );
+    }
+    return issues;
+  }
+  /**
+   * Validate field type
+   */
+  validateFieldType(value, expectedType, fieldName, objectId, filePath) {
+    switch (expectedType) {
+      case "text":
+        if (typeof value !== "string") {
+          return {
+            severity: "error",
+            code: ValidationCodes.INVALID_TYPE,
+            message: `Field '${fieldName}' expected string, got ${typeof value}`,
+            file: filePath,
+            objectId,
+            field: fieldName,
+            expected: "string",
+            actual: typeof value
+          };
+        }
+        break;
+      case "integer":
+        if (typeof value !== "number" || !Number.isInteger(value)) {
+          return {
+            severity: "error",
+            code: ValidationCodes.INVALID_INTEGER,
+            message: `Field '${fieldName}' expected integer, got ${typeof value}${typeof value === "number" ? " (decimal)" : ""}`,
+            file: filePath,
+            objectId,
+            field: fieldName,
+            expected: "integer",
+            actual: value
+          };
+        }
+        break;
+      case "decimal":
+        if (typeof value !== "number") {
+          return {
+            severity: "error",
+            code: ValidationCodes.INVALID_NUMBER,
+            message: `Field '${fieldName}' expected number, got ${typeof value}`,
+            file: filePath,
+            objectId,
+            field: fieldName,
+            expected: "number",
+            actual: typeof value
+          };
+        }
+        break;
+      case "boolean":
+        if (typeof value !== "boolean") {
+          return {
+            severity: "error",
+            code: ValidationCodes.INVALID_BOOLEAN,
+            message: `Field '${fieldName}' expected boolean, got ${typeof value}`,
+            file: filePath,
+            objectId,
+            field: fieldName,
+            expected: "boolean",
+            actual: typeof value
+          };
+        }
+        break;
+      case "datetime": {
+        const dateValue = typeof value === "string" ? new Date(value) : value;
+        if (!(dateValue instanceof Date) || Number.isNaN(dateValue.getTime())) {
+          return {
+            severity: "error",
+            code: ValidationCodes.INVALID_DATE,
+            message: `Field '${fieldName}' contains invalid date: ${String(value)}`,
+            file: filePath,
+            objectId,
+            field: fieldName,
+            expected: "ISO 8601 date string",
+            actual: value
+          };
+        }
+        break;
+      }
+      case "json":
+        if (value !== null && typeof value !== "object") {
+          return {
+            severity: "error",
+            code: ValidationCodes.INVALID_JSON_FIELD,
+            message: `Field '${fieldName}' expected JSON value (object, array, or null), got ${typeof value}`,
+            file: filePath,
+            objectId,
+            field: fieldName,
+            expected: "object, array, or null",
+            actual: typeof value
+          };
+        }
+        break;
+      case "foreignKey":
+        if (typeof value !== "string") {
+          return {
+            severity: "error",
+            code: ValidationCodes.INVALID_TYPE,
+            message: `Field '${fieldName}' (foreign key) expected string, got ${typeof value}`,
+            file: filePath,
+            objectId,
+            field: fieldName,
+            expected: "string",
+            actual: typeof value
+          };
+        }
+        break;
+    }
+    return null;
+  }
+  /**
+   * Validate field constraints
+   */
+  validateConstraints(value, fieldDef, fieldName, objectId, filePath) {
+    const issues = [];
+    if (typeof value === "number") {
+      if (fieldDef.min !== void 0 && value < fieldDef.min) {
+        issues.push({
+          severity: "error",
+          code: ValidationCodes.VALUE_OUT_OF_RANGE,
+          message: `Field '${fieldName}' value ${value} is below minimum ${fieldDef.min}`,
+          file: filePath,
+          objectId,
+          field: fieldName,
+          expected: `>= ${fieldDef.min}`,
+          actual: value
+        });
+      }
+      if (fieldDef.max !== void 0 && value > fieldDef.max) {
+        issues.push({
+          severity: "error",
+          code: ValidationCodes.VALUE_OUT_OF_RANGE,
+          message: `Field '${fieldName}' value ${value} is above maximum ${fieldDef.max}`,
+          file: filePath,
+          objectId,
+          field: fieldName,
+          expected: `<= ${fieldDef.max}`,
+          actual: value
+        });
+      }
+    }
+    if (typeof value === "string") {
+      if (fieldDef.minLength !== void 0 && value.length < fieldDef.minLength) {
+        issues.push({
+          severity: "error",
+          code: ValidationCodes.STRING_TOO_SHORT,
+          message: `Field '${fieldName}' length ${value.length} is below minimum ${fieldDef.minLength}`,
+          file: filePath,
+          objectId,
+          field: fieldName,
+          expected: `length >= ${fieldDef.minLength}`,
+          actual: value.length
+        });
+      }
+      if (fieldDef.maxLength !== void 0 && value.length > fieldDef.maxLength) {
+        issues.push({
+          severity: "error",
+          code: ValidationCodes.STRING_TOO_LONG,
+          message: `Field '${fieldName}' length ${value.length} is above maximum ${fieldDef.maxLength}`,
+          file: filePath,
+          objectId,
+          field: fieldName,
+          expected: `length <= ${fieldDef.maxLength}`,
+          actual: value.length
+        });
+      }
+      if (fieldDef.pattern) {
+        const regex = new RegExp(fieldDef.pattern);
+        if (!regex.test(value)) {
+          issues.push({
+            severity: "error",
+            code: ValidationCodes.PATTERN_MISMATCH,
+            message: `Field '${fieldName}' does not match required pattern`,
+            file: filePath,
+            objectId,
+            field: fieldName,
+            expected: fieldDef.pattern,
+            actual: value
+          });
+        }
+      }
+    }
+    return issues;
+  }
+  /**
+   * Validate foreign key references across files (full mode only).
+   *
+   * @remarks
+   * Uses Set-based lookup for target IDs (O(1) per lookup instead of O(n)),
+   * optimizing validation from O(n*m*k) to O(n*k + m) where:
+   * - n = number of records with FK fields
+   * - m = number of target records
+   * - k = number of FK fields per record
+   *
+   * Note: This method mutates the results to add FK validation issues.
+   * The validCount/invalidCount are updated to reflect records that
+   * failed FK validation (a record is counted as invalid if it has
+   * any FK errors).
+   */
+  async validateForeignKeys(results) {
+    const tableIdSets = /* @__PURE__ */ new Map();
+    for (const [tableName, records] of this.loadedData) {
+      const idSet = /* @__PURE__ */ new Set();
+      for (const record of records) {
+        const id = record.id;
+        if (typeof id === "string") {
+          idSet.add(id);
+        }
+      }
+      tableIdSets.set(tableName, idSet);
+    }
+    for (const result of results) {
+      if (!result.objectType) continue;
+      const fields = ObjectRegistry.getFields(result.objectType);
+      const fkFields = Array.from(fields.entries()).filter(
+        ([, def]) => def.type === "foreignKey"
+      );
+      if (fkFields.length === 0) continue;
+      const records = this.loadedData.get(result.tableName) || [];
+      const recordsWithFKErrors = /* @__PURE__ */ new Set();
+      for (const record of records) {
+        const rec = record;
+        const recordId = rec.id || `[unknown]`;
+        for (const [fieldName, fieldDef] of fkFields) {
+          const snakeCaseFieldName = toSnakeCase(fieldName);
+          const fkValue = rec[snakeCaseFieldName];
+          if (!fkValue) continue;
+          const def = fieldDef;
+          const targetClass = def.related;
+          if (!targetClass) continue;
+          const targetTable = ObjectRegistry.getTableName(targetClass);
+          if (!targetTable) {
+            result.issues.push({
+              severity: "warning",
+              code: ValidationCodes.MISSING_FK_TABLE,
+              message: `FK target class '${targetClass}' not registered`,
+              file: result.file,
+              objectId: recordId,
+              field: fieldName
+            });
+            continue;
+          }
+          const targetIdSet = tableIdSets.get(targetTable);
+          if (!targetIdSet) {
+            result.issues.push({
+              severity: "error",
+              code: ValidationCodes.MISSING_FK_TABLE,
+              message: `FK reference to missing table file: ${targetTable}.json`,
+              file: result.file,
+              objectId: recordId,
+              field: fieldName
+            });
+            recordsWithFKErrors.add(recordId);
+            continue;
+          }
+          if (!targetIdSet.has(fkValue)) {
+            result.issues.push({
+              severity: "error",
+              code: ValidationCodes.INVALID_FOREIGN_KEY,
+              message: `FK reference to non-existent record: ${fkValue} in ${targetTable}`,
+              file: result.file,
+              objectId: recordId,
+              field: fieldName,
+              actual: fkValue
+            });
+            recordsWithFKErrors.add(recordId);
+          }
+        }
+      }
+      const newInvalidCount = recordsWithFKErrors.size;
+      if (newInvalidCount > 0) {
+        const previouslyValid = result.validCount;
+        const newlyInvalid = Math.min(newInvalidCount, previouslyValid);
+        result.validCount -= newlyInvalid;
+        result.invalidCount += newlyInvalid;
+      }
+    }
+  }
+  /**
+   * Apply fixes to fixable issues.
+   *
+   * Currently supports auto-fixing:
+   * - MISSING_REQUIRED_FIELD: Applies default value from field definition
+   *
+   * @remarks
+   * Records are matched by ID. Records identified by index only (objectId = '[index:N]')
+   * require the ID to be present and are matched by array position as a fallback.
+   */
+  async applyFixes(fixableIssues) {
+    const fixesByFile = /* @__PURE__ */ new Map();
+    for (const issue of fixableIssues) {
+      if (!issue.file) continue;
+      const existing = fixesByFile.get(issue.file) || [];
+      existing.push(issue);
+      fixesByFile.set(issue.file, existing);
+    }
+    let fixedCount = 0;
+    for (const [filePath, issues] of fixesByFile) {
+      try {
+        const content = await readFile(filePath, "utf-8");
+        const records = JSON.parse(content);
+        for (const issue of issues) {
+          if (issue.code === ValidationCodes.MISSING_REQUIRED_FIELD && issue.field) {
+            let record;
+            if (issue.objectId?.startsWith("[index:")) {
+              const indexMatch = issue.objectId.match(/\[index:(\d+)\]/);
+              if (indexMatch) {
+                const index = parseInt(indexMatch[1], 10);
+                record = records[index];
+              }
+            } else {
+              record = records.find((r) => r.id === issue.objectId);
+            }
+            if (record && issue.objectType) {
+              const fields = ObjectRegistry.getFields(issue.objectType);
+              const fieldDef = fields.get(issue.field);
+              if (fieldDef?.default !== void 0) {
+                const snakeCaseField = toSnakeCase(issue.field);
+                record[snakeCaseField] = fieldDef.default;
+                fixedCount++;
+              }
+            }
+          }
+        }
+        await writeFile(filePath, `${JSON.stringify(records, null, 2)}
+`);
+      } catch (error) {
+        if (this.verbose) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          console.error(
+            `  [verbose] Failed to apply fixes to ${filePath}: ${errorMessage}`
+          );
+        }
+      }
+    }
+    return fixedCount;
+  }
+  /**
+   * Generate validation summary
+   */
+  generateSummary(results, duration, manifestPath = null) {
+    let totalRecords = 0;
+    let validRecords = 0;
+    let invalidRecords = 0;
+    let errors = 0;
+    let warnings = 0;
+    let info = 0;
+    for (const result of results.objectResults) {
+      totalRecords += result.recordCount;
+      validRecords += result.validCount;
+      invalidRecords += result.invalidCount;
+      for (const issue of result.issues) {
+        if (issue.severity === "error") errors++;
+        else if (issue.severity === "warning") warnings++;
+        else info++;
+      }
+    }
+    return {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      dataPath: this.dataPath,
+      manifestPath,
+      duration,
+      totalFiles: results.objectResults.length,
+      totalRecords,
+      validRecords,
+      invalidRecords,
+      issues: { errors, warnings, info },
+      objectResults: results.objectResults
+    };
+  }
+  /**
+   * Create an ObjectValidationResult
+   */
+  createResult(objectType, tableName, file, recordCount, issues, validCount) {
+    return {
+      objectType,
+      tableName,
+      file,
+      recordCount,
+      validCount,
+      invalidCount: recordCount - validCount,
+      issues
+    };
+  }
+}
+function displayValidationResults(summary, verbose) {
+  console.log("\n🔍 SMRT Database Validation Report\n");
+  console.log(`  Data path: ${summary.dataPath}`);
+  if (summary.manifestPath) {
+    console.log(`  Manifest:  ${summary.manifestPath}`);
+  }
+  console.log(`  Duration:  ${summary.duration}ms
+`);
+  console.log("━".repeat(60));
+  console.log("\n📊 Summary\n");
+  console.log(`  Files validated:    ${summary.totalFiles}`);
+  console.log(`  Total records:      ${summary.totalRecords}`);
+  console.log(`  Valid records:      ${summary.validRecords}`);
+  console.log(`  Invalid records:    ${summary.invalidRecords}`);
+  console.log();
+  console.log(`  ❌ Errors:   ${summary.issues.errors}`);
+  console.log(`  ⚠️  Warnings: ${summary.issues.warnings}`);
+  console.log(`  ℹ️  Info:     ${summary.issues.info}`);
+  console.log();
+  if (summary.issues.errors === 0 && summary.issues.warnings === 0) {
+    console.log("✅ All validations passed!\n");
+    return;
+  }
+  console.log("━".repeat(60));
+  console.log("\n🔧 Issues by Object Type\n");
+  for (const result of summary.objectResults) {
+    if (result.issues.length === 0) continue;
+    console.log(`  ${result.objectType || result.tableName}`);
+    console.log(`    File: ${result.file}`);
+    console.log(
+      `    Records: ${result.recordCount} (${result.validCount} valid, ${result.invalidCount} invalid)`
+    );
+    const errors = result.issues.filter((i) => i.severity === "error");
+    const warnings = result.issues.filter((i) => i.severity === "warning");
+    if (errors.length > 0) {
+      console.log(`
+    ❌ Errors (${errors.length}):`);
+      const displayErrors = verbose ? errors : errors.slice(0, 5);
+      for (const issue of displayErrors) {
+        console.log(`       [${issue.code}] ${issue.message}`);
+        if (issue.objectId && issue.objectId !== "[index:0]") {
+          console.log(`         Record: ${issue.objectId}`);
+        }
+      }
+      if (!verbose && errors.length > 5) {
+        console.log(`       ... and ${errors.length - 5} more errors`);
+      }
+    }
+    if (warnings.length > 0) {
+      console.log(`
+    ⚠️  Warnings (${warnings.length}):`);
+      const displayWarnings = verbose ? warnings : warnings.slice(0, 3);
+      for (const issue of displayWarnings) {
+        console.log(`       [${issue.code}] ${issue.message}`);
+      }
+      if (!verbose && warnings.length > 3) {
+        console.log(`       ... and ${warnings.length - 3} more warnings`);
+      }
+    }
+    console.log();
+  }
+  console.log("━".repeat(60));
+  console.log("\n💡 Next steps:\n");
+  console.log("  - Run with --verbose for detailed issue information");
+  console.log("  - Run with --fix to auto-correct fixable issues");
+  console.log("  - Run with --json for CI-friendly output\n");
+}
+export {
+  JsonDatabaseValidator,
+  discoverJsonFiles,
+  displayValidationResults,
+  resolveDataPath
+};