data_validation_manager.gd

Go to the documentation of this file.

extends RefCounted
 
 
 
 
 
func load_json(file_path:String) -> Dictionary:
    var file = FileAccess.open(file_path, FileAccess.READ)
    if file == null:
        return {"ok": false, "data": {}, "issues": [_issue("missing_file", file_path, "Unable to open JSON file.")]}
    var parsed = JSON.parse_string(file.get_as_text())
    if not parsed is Dictionary:
        return {"ok": false, "data": {}, "issues": [_issue("invalid_json", file_path, "JSON root must be an object.")]}
    return {"ok": true, "data": parsed, "issues": []}
 
 
 
func validate_records(records:Array, schema:Dictionary = {}, path:String = "records") -> Array:
    var issues := []
    var id_field = str(schema.get("id_field", "id"))
    var required = schema.get("required", []) if schema.get("required", []) is Array else []
    var seen_ids := {}
    for index in range(records.size()):
        var record = records[index]
        var record_path = "%s[%d]" % [path, index]
        if not record is Dictionary:
            issues.append(_issue("invalid_record", record_path, "Record must be an object."))
            continue
        for field in required:
            if not record.has(str(field)) or str(record.get(str(field), "")).strip_edges() == "":
                issues.append(_issue("missing_field", "%s.%s" % [record_path, str(field)], "Required field is missing."))
        var id = str(record.get(id_field, ""))
        if id != "":
            if seen_ids.has(id):
                issues.append(_issue("duplicate_id", record_path, "Duplicate %s '%s'." % [id_field, id]))
            seen_ids[id] = true
        _validate_references(record, schema.get("references", []), record_path, issues)
    return issues
 
 
 
func validate_section(data:Dictionary, section:String, schema:Dictionary = {}) -> Array:
    var records = data.get(section, [])
    if not records is Array:
        return [_issue("invalid_section", section, "Section must be an array.")]
    return validate_records(records, schema, section)
 
 
 
func summarize(issues:Array) -> Dictionary:
    var by_type := {}
    for issue in issues:
        if issue is Dictionary:
            var type = str(issue.get("type", "unknown"))
            by_type[type] = int(by_type.get(type, 0)) + 1
    return {
        "ok": issues.is_empty(),
        "count": issues.size(),
        "by_type": by_type
    }
 
 
 
func validate_bundle(bundle:Dictionary) -> Dictionary:
    var all_issues := []
    for file_config in bundle.get("files", []):
        if not file_config is Dictionary:
            continue
        var path = str(file_config.get("path", ""))
        var loaded = load_json(path)
        all_issues.append_array(loaded.get("issues", []))
        if not bool(loaded.get("ok", false)):
            continue
        var data = loaded.get("data", {})
        for section_config in file_config.get("sections", []):
            if not section_config is Dictionary:
                continue
            var section = str(section_config.get("name", ""))
            all_issues.append_array(validate_section(data, section, section_config.get("schema", {})))
    var summary = summarize(all_issues)
    summary["issues"] = all_issues
    return summary
 
 
func _validate_references(record:Dictionary, references, record_path:String, issues:Array) -> void:
    if not references is Array:
        return
    for reference in references:
        if not reference is Dictionary:
            continue
        var field = str(reference.get("field", ""))
        if field == "" or not record.has(field):
            continue
        var allowed = reference.get("allowed", [])
        if not allowed is Array:
            continue
        var values = record.get(field)
        var list = values if values is Array else [values]
        for value in list:
            var id = str(value)
            if id != "" and not allowed.has(id):
                issues.append(_issue("bad_reference", "%s.%s" % [record_path, field], "Unknown reference '%s'." % id))
 
 
func _issue(type:String, path:String, message:String) -> Dictionary:
    return {
        "type": type,
        "path": path,
        "message": message
    }