feat: enhance JSON Structure validator with strict object properties validation

- Add validation for object schemas: properties MUST have at least one entry when present
- Allow empty properties for schemas using  (properties inherited from base)
- Fix  property merging to properly combine base and derived properties
- Add clarifying comment for map key validation (any valid JSON string allowed)
- Add comprehensive tests for empty properties validation
- Add tests for map keys with various valid JSON string formats
- Fix test_extends_valid by improving inheritance property merging

BREAKING CHANGE: Object schemas with empty properties are now rejected unless using

Author: clemensv

samples/py/json_structure_instance_validator.py

@@ -209,9 +209,7 @@ def validate_instance(self, instance, schema=None, path="#", meta=None):
 
         if not isinstance(schema_type, str):
             self.errors.append(f"Schema at {path} has invalid 'type'")
-            return self.errors
-
-        # Process $extends. [Metaschema: $extends in ObjectType/TupleType]
+            return self.errors        # Process $extends. [Metaschema: $extends in ObjectType/TupleType]
         if schema_type != "choice" and "$extends" in schema:
             base = self._resolve_ref(schema["$extends"])
             if base is None:
@@ -225,6 +223,11 @@ def validate_instance(self, instance, schema=None, path="#", meta=None):
                         f"Property '{key}' is inherited via $extends and must not be redefined at {path}")
             merged = dict(base)
             merged.update(schema)
+            # Properly merge properties: base properties + derived properties
+            if "properties" in base or "properties" in schema:
+                merged_props = dict(base_props)
+                merged_props.update(derived_props)
+                merged["properties"] = merged_props
             merged.pop("$extends", None)
             merged.pop("abstract", None)
             schema = merged
@@ -331,6 +334,14 @@ def validate_instance(self, instance, schema=None, path="#", meta=None):
                 self.errors.append(f"Expected JSON pointer format at {path}")
         # Compound types.
         elif schema_type == "object":
+            # Validate schema: properties MUST have at least one entry if present,
+            # unless the schema uses $extends (properties may be inherited)
+            if "properties" in schema:
+                props_def = schema["properties"]
+                if not isinstance(props_def, dict) or (len(props_def) == 0 and "$extends" not in schema):
+                    self.errors.append(f"Object schema at {path} has 'properties' but it is empty - properties MUST have at least one entry")
+                    return self.errors
+            
             if not isinstance(instance, dict):
                 self.errors.append(f"Expected object at {path}, got {type(instance).__name__}")
             else:
@@ -390,6 +401,7 @@ def validate_instance(self, instance, schema=None, path="#", meta=None):
             if not isinstance(instance, dict):
                 self.errors.append(f"Expected map (object) at {path}, got {type(instance).__name__}")
             else:
+                # Map keys MAY be any valid JSON string (no restrictions on key format)
                 values_schema = schema.get("values")
                 if values_schema:
                     for key, val in instance.items():

samples/py/test_json_structure_instance_validator.py

@@ -484,6 +484,36 @@ def test_object_additional_properties_false():
     assert any("Additional property 'b'" in err for err in errors)
 
 
+def test_object_empty_properties_invalid():
+    """Test that object schema with empty properties is invalid"""
+    schema = {
+        "type": "object",
+        "$schema": "https://json-structure.org/meta/core/v0/#",
+        "$id": "dummy",
+        "name": "objSchema",
+        "properties": {}  # Empty properties should be invalid
+    }
+    instance = {"a": "value"}
+    validator = JSONStructureInstanceValidator(schema)
+    errors = validator.validate_instance(instance)
+    assert any("properties MUST have at least one entry" in err for err in errors)
+
+
+def test_object_properties_none_invalid():
+    """Test that object schema with properties set to None is invalid"""
+    schema = {
+        "type": "object",
+        "$schema": "https://json-structure.org/meta/core/v0/#",
+        "$id": "dummy",
+        "name": "objSchema",
+        "properties": None  # None properties should be invalid
+    }
+    instance = {"a": "value"}
+    validator = JSONStructureInstanceValidator(schema)
+    errors = validator.validate_instance(instance)
+    assert any("properties MUST have at least one entry" in err for err in errors)
+
+
 def test_array_valid():
     schema = {
         "type": "array",
@@ -554,6 +584,39 @@ def test_map_valid():
     assert errors == []
 
 
+def test_map_keys_any_valid_json_string():
+    """Test that map keys MAY be any valid JSON string (lifted restriction)"""
+    schema = {
+        "type": "map",
+        "$schema": "https://json-structure.org/meta/core/v0/#",
+        "$id": "dummy",
+        "name": "mapSchema",
+        "values": {"type": "string"}
+    }
+    
+    # Test various valid JSON strings as keys
+    instance = {
+        "simple_key": "value1",
+        "key-with-hyphens": "value2",
+        "key.with.dots": "value3",
+        "key with spaces": "value4",
+        "key/with/slashes": "value5",
+        "key:with:colons": "value6",
+        "key@with@symbols": "value7",
+        "123numeric_start": "value8",
+        "_underscore_start": "value9",
+        "UPPERCASE_KEY": "value10",
+        "CamelCaseKey": "value11",
+        "key_with_unicode_café": "value12",
+        "empty": "",
+        "very_long_key_name_that_exceeds_normal_length_expectations_but_is_still_valid": "value13"
+    }
+    
+    validator = JSONStructureInstanceValidator(schema)
+    errors = validator.validate_instance(instance)
+    assert errors == [], f"Unexpected validation errors: {errors}"
+
+
 def test_tuple_valid():
     schema = {
         "type": "tuple",
@@ -1429,7 +1492,7 @@ def test_import_circular_reference_prevention():
 
     schema = {
         "$schema": "https://json-structure.org/meta/core/v0/#",
-        "$id": "https://example.com/schema/test",
+        "$id": "dummy",
         "name": "TestSchema",
         "type": "object",
         "properties": {