avrotize 2.20.3__py3-none-any.whl → 2.20.4__py3-none-any.whl

avrotize/commands.json

@@ -1070,7 +1070,10 @@
         "emit_cloudevents_columns": "args.emit_cloudevents_columns"
       }
     },
-    "extensions": [".struct.json", ".json"],
+    "extensions": [
+      ".struct.json",
+      ".json"
+    ],
     "args": [
       {
         "name": "input",
@@ -1248,6 +1251,7 @@
         "avro_schema_path": "input_file_path",
         "cs_file_path": "output_file_path",
         "avro_annotation": "args.avro_annotation",
+        "protobuf_net_annotation": "args.protobuf_net_annotation",
         "system_text_json_annotation": "args.system_text_json_annotation",
         "newtonsoft_json_annotation": "args.newtonsoft_json_annotation",
         "system_xml_annotation": "args.system_xml_annotation",
@@ -1291,6 +1295,13 @@
         "default": false,
         "required": false
       },
+      {
+        "name": "--protobuf-net-annotation",
+        "type": "bool",
+        "help": "Use protobuf-net annotations",
+        "default": false,
+        "required": false
+      },
       {
         "name": "--system_text_json_annotation",
         "type": "bool",
@@ -1704,7 +1715,10 @@
         "json_annotation": "args.json_annotation"
       }
     },
-    "extensions": [".struct.json", ".json"],
+    "extensions": [
+      ".struct.json",
+      ".json"
+    ],
     "args": [
       {
         "name": "input",
@@ -1754,7 +1768,10 @@
         "csv_schema_path": "output_file_path"
       }
     },
-    "extensions": [".struct.json", ".json"],
+    "extensions": [
+      ".struct.json",
+      ".json"
+    ],
     "args": [
       {
         "name": "input",
@@ -1786,7 +1803,10 @@
         "serde_annotation": "args.json_annotation"
       }
     },
-    "extensions": [".struct.json", ".json"],
+    "extensions": [
+      ".struct.json",
+      ".json"
+    ],
     "args": [
       {
         "name": "input",
@@ -1845,7 +1865,10 @@
         "avro_annotation": "args.avro_annotation"
       }
     },
-    "extensions": [".struct.json", ".json"],
+    "extensions": [
+      ".struct.json",
+      ".json"
+    ],
     "args": [
       {
         "name": "input",
@@ -1905,7 +1928,10 @@
         "jackson_annotation": "args.jackson_annotation"
       }
     },
-    "extensions": [".struct.json", ".json"],
+    "extensions": [
+      ".struct.json",
+      ".json"
+    ],
     "args": [
       {
         "name": "input",
@@ -1958,6 +1984,51 @@
       }
     ]
   },
+  {
+    "command": "s2js",
+    "description": "Convert JSON Structure to JavaScript classes",
+    "group": "2_ProgLanguages",
+    "function": {
+      "name": "avrotize.structuretojs.convert_structure_to_javascript",
+      "args": {
+        "structure_schema_path": "input_file_path",
+        "js_file_path": "output_file_path",
+        "package_name": "args.package",
+        "avro_annotation": "args.avro_annotation"
+      }
+    },
+    "extensions": [".struct.json", ".json"],
+    "args": [
+      {
+        "name": "input",
+        "type": "str",
+        "nargs": "?",
+        "help": "Path to the JSON Structure schema file (or read from stdin if omitted)",
+        "required": false
+      },
+      {
+        "name": "--out",
+        "type": "str",
+        "help": "Output path for the JavaScript classes",
+        "required": true
+      },
+      {
+        "name": "--package",
+        "type": "str",
+        "help": "JavaScript package name",
+        "required": false
+      },
+      {
+        "name": "--avro-annotation",
+        "type": "bool",
+        "help": "Add Avro binary serialization support",
+        "default": false,
+        "required": false
+      }
+    ],
+    "suggested_output_file_path": "{input_file_name}-js",
+    "prompts": []
+  },
   {
     "command": "s2go",
     "description": "Convert JSON Structure to Go structs",
@@ -1974,7 +2045,10 @@
         "package_username": "args.package_username"
       }
     },
-    "extensions": [".struct.json", ".json"],
+    "extensions": [
+      ".struct.json",
+      ".json"
+    ],
     "args": [
       {
         "name": "input",
@@ -3195,7 +3269,10 @@
         "target_namespace": "args.namespace"
       }
     },
-    "extensions": [".struct.json", ".json"],
+    "extensions": [
+      ".struct.json",
+      ".json"
+    ],
     "args": [
       {
         "name": "input",
@@ -3237,7 +3314,10 @@
         "cddl_file_path": "output_file_path"
       }
     },
-    "extensions": [".struct.json", ".json"],
+    "extensions": [
+      ".struct.json",
+      ".json"
+    ],
     "args": [
       {
         "name": "input",
@@ -3333,5 +3413,84 @@
         "required": false
       }
     ]
+  },
+  {
+    "command": "oas2s",
+    "description": "Convert OpenAPI 3.x document to JSON Structure",
+    "group": "1_Schemas",
+    "function": {
+      "name": "avrotize.openapitostructure.convert_openapi_to_structure_files",
+      "args": {
+        "openapi_file_path": "input_file_path",
+        "structure_schema_path": "output_file_path",
+        "root_namespace": "args.namespace",
+        "preserve_composition": "args.preserve_composition",
+        "detect_discriminators": "args.detect_discriminators",
+        "lift_inline_schemas": "args.lift_inline_schemas"
+      }
+    },
+    "extensions": [
+      ".yaml",
+      ".yml",
+      ".json"
+    ],
+    "args": [
+      {
+        "name": "input",
+        "type": "str",
+        "nargs": "?",
+        "help": "Path to the OpenAPI document (or read from stdin if omitted)",
+        "required": false
+      },
+      {
+        "name": "--out",
+        "type": "str",
+        "help": "Path to the JSON Structure output file",
+        "required": false
+      },
+      {
+        "name": "--namespace",
+        "type": "str",
+        "help": "Namespace for the JSON Structure schema",
+        "required": false
+      },
+      {
+        "name": "--preserve-composition",
+        "type": "bool",
+        "help": "Preserve composition keywords (allOf, oneOf, anyOf) - requires Conditional Composition extension",
+        "default": false,
+        "required": false
+      },
+      {
+        "name": "--detect-discriminators",
+        "type": "bool",
+        "help": "Detect OpenAPI discriminator patterns",
+        "default": true,
+        "required": false
+      },
+      {
+        "name": "--lift-inline-schemas",
+        "type": "bool",
+        "help": "Lift inline schemas from paths to named definitions",
+        "default": false,
+        "required": false
+      }
+    ],
+    "suggested_output_file_path": "{input_file_name}.struct.json",
+    "prompts": [
+      {
+        "name": "--namespace",
+        "message": "Enter the namespace for the JSON Structure schema",
+        "type": "str",
+        "required": false
+      },
+      {
+        "name": "--lift-inline-schemas",
+        "message": "Lift inline schemas from paths to definitions?",
+        "type": "bool",
+        "default": false,
+        "required": false
+      }
+    ]
   }
 ]

avrotize/constants.py

@@ -40,6 +40,11 @@ try:
 except ValueError:
     SYSTEM_MEMORY_DATA_VERSION = '9.0.3'
 
+try:
+    PROTOBUF_NET_VERSION = get_dependency_version('cs', 'net90', 'protobuf-net')
+except ValueError:
+    PROTOBUF_NET_VERSION = '3.2.30'
+
 try:
     NUNIT_VERSION = get_dependency_version('cs', 'net90', 'NUnit')
 except ValueError:
@@ -55,6 +60,16 @@ try:
 except ValueError:
     MSTEST_SDK_VERSION = '17.13.0'
 
+try:
+    COVERLET_VERSION = get_dependency_version('cs', 'net90', 'coverlet.collector')
+except ValueError:
+    COVERLET_VERSION = '6.0.4'
+
+try:
+    MSGPACK_VERSION = get_dependency_version('cs', 'net90', 'MessagePack')
+except ValueError:
+    MSGPACK_VERSION = '2.5.187'
+
 # Java test dependencies
 try:
     JUNIT_VERSION = get_dependency_version('java', 'jdk21', 'org.junit.jupiter:junit-jupiter-api')

avrotize/dependencies/cs/net90/dependencies.csproj

@@ -16,6 +16,8 @@
         <PackageReference Include="Newtonsoft.Json" Version="13.0.4" />
         <PackageReference Include="System.Text.Json" Version="9.0.3" />
         <PackageReference Include="System.Memory.Data" Version="9.0.3" />
+        <PackageReference Include="protobuf-net" Version="3.2.30" />
+        <PackageReference Include="MessagePack" Version="3.1.4" />
     </ItemGroup>
 
     <!-- Testing -->

avrotize/dependencies/java/jdk21/pom.xml

@@ -53,7 +53,7 @@
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-annotations</artifactId>
-            <version>2.18.2</version>
+            <version>2.20</version>
         </dependency>
 
         <!-- Testing - JUnit 5 -->

avrotize/jsonstostructure.py

@@ -388,10 +388,10 @@ class JsonToStructureConverter:
                 structure_type = 'string'
                 
         elif json_primitive == 'integer':
-            structure_type = self.detect_numeric_type({'type': 'integer', 'format': format, **schema})
+            structure_type = self.detect_numeric_type({**schema, 'type': 'integer', 'format': format})
             
         elif json_primitive == 'number':
-            structure_type = self.detect_numeric_type({'type': 'number', 'format': format, **schema})
+            structure_type = self.detect_numeric_type({**schema, 'type': 'number', 'format': format})
             
         elif json_primitive == 'boolean':
             structure_type = 'boolean'
@@ -773,21 +773,38 @@ class JsonToStructureConverter:
         Returns:
             dict: JSON Structure choice definition
         """
+        # Handle both 'property' and 'propertyName' keys for compatibility
+        discriminator_property = discriminator_info.get('property') or discriminator_info.get('propertyName')
+        mapping = discriminator_info.get('mapping', {})
+        
         choice_obj = {
             'type': 'choice',
-            'discriminator': discriminator_info['property'],
+            'selector': discriminator_property,
             'choices': {}
         }
         
         if record_name:
             choice_obj['name'] = avro_name(record_name)
+        
+        # Build reverse mapping from $ref to choice key
+        ref_to_key = {}
+        for key, ref in mapping.items():
+            ref_to_key[ref] = key
             
         # Process each choice option
         for i, option in enumerate(oneof_options):
             if '$ref' in option:
-                # Handle reference
-                choice_key = f"option_{i}"  # Default key, ideally extract from mapping
-                choice_obj['choices'][choice_key] = {'$ref': option['$ref']}
+                # Handle reference - use mapping to get the choice key
+                ref = option['$ref']
+                if ref in ref_to_key:
+                    choice_key = ref_to_key[ref]
+                else:
+                    # Extract name from reference
+                    if ref.startswith('#/definitions/'):
+                        choice_key = ref[14:]  # Remove '#/definitions/' prefix
+                    else:
+                        choice_key = f"option_{i}"
+                choice_obj['choices'][choice_key] = {'$ref': ref}
             else:
                 # Convert option to structure type
                 choice_key = f"option_{i}"
@@ -908,6 +925,77 @@ class JsonToStructureConverter:
             'items': items_type
         }
 
+    def _process_array_type(self, json_type: dict, record_name: str, field_name: str, namespace: str, 
+                            dependencies: list, json_schema: dict, base_uri: str, 
+                            structure_schema: dict, record_stack: list, recursion_depth: int) -> dict:
+        """
+        Process an array type schema into JSON Structure format.
+        
+        Args:
+            json_type: The JSON Schema with type: "array"
+            record_name: Name of the containing record
+            field_name: Name of the field
+            namespace: Namespace
+            dependencies: Dependencies list
+            json_schema: Full JSON schema
+            base_uri: Base URI
+            structure_schema: Structure schema being built
+            record_stack: Record stack for recursion detection
+            recursion_depth: Current recursion depth
+            
+        Returns:
+            dict: JSON Structure array definition
+        """
+        items_schema = json_type.get('items', {})
+        is_set = json_type.get('uniqueItems', False)
+        return self.create_structure_array_or_set(
+            items_schema, is_set, record_name, namespace, dependencies,
+            json_schema, base_uri, structure_schema, record_stack, recursion_depth + 1
+        )
+
+    def _process_object_type(self, json_type: dict, record_name: str, field_name: str, namespace: str,
+                             dependencies: list, json_schema: dict, base_uri: str,
+                             structure_schema: dict, record_stack: list, recursion_depth: int) -> dict:
+        """
+        Process an object type schema into JSON Structure format.
+        
+        Args:
+            json_type: The JSON Schema with type: "object"
+            record_name: Name of the containing record
+            field_name: Name of the field
+            namespace: Namespace
+            dependencies: Dependencies list
+            json_schema: Full JSON schema
+            base_uri: Base URI
+            structure_schema: Structure schema being built
+            record_stack: Record stack for recursion detection
+            recursion_depth: Current recursion depth
+            
+        Returns:
+            dict: JSON Structure object definition
+        """
+        properties = json_type.get('properties', {})
+        required = json_type.get('required', [])
+        
+        structure_properties = {}
+        for prop_name, prop_schema in properties.items():
+            prop_type = self.json_type_to_structure_type(
+                prop_schema, record_name, prop_name, namespace, dependencies,
+                json_schema, base_uri, structure_schema, record_stack, recursion_depth + 1
+            )
+            prop_type = self._ensure_schema_object(prop_type, structure_schema, prop_name)
+            structure_properties[prop_name] = prop_type
+        
+        result = {
+            'type': 'object',
+            'properties': structure_properties
+        }
+        
+        if required:
+            result['required'] = required
+            
+        return result
+
     def add_alternate_names(self, structure: dict, original_name: str) -> dict:
         """
         Add alternate names for different naming conventions.
@@ -1005,13 +1093,25 @@ class JsonToStructureConverter:
         """
         Flatten the list of types in a union into a single list.
 
+        JSON Structure Core requires union members to be either:
+        - Simple type strings (e.g., "string", "null", "boolean")
+        - References to definitions (e.g., {"$ref": "#/definitions/Foo"})
+        
+        Inline compound types or primitives with constraints must be hoisted to definitions.
+
         Args:
             type_list (list): The list of types in a union.
+            structure_schema: The structure schema for hoisting definitions.
+            name_hint: Hint for naming hoisted definitions.
 
         Returns:
             list: The flattened list of types.
         """
         flat_list = []
+        simple_primitives = {'string', 'boolean', 'integer', 'number', 'null', 'int8', 'int16', 
+                             'int32', 'int64', 'float', 'double', 'bytes', 'uuid', 'datetime',
+                             'date', 'time', 'duration', 'decimal'}
+        
         for idx, t in enumerate(type_list):
             if isinstance(t, list):
                 inner = self.flatten_union(t, structure_schema, name_hint)
@@ -1019,17 +1119,52 @@ class JsonToStructureConverter:
                     obj = self._ensure_schema_object(u, structure_schema, f"{name_hint}_option_{idx}" if name_hint else None, force_hoist_in_union=True)
                     if obj not in flat_list:
                         flat_list.append(obj)
-            else:
-                # For primitive types in unions, extract the type string directly
-                if isinstance(t, dict) and 'type' in t and t['type'] in ['string', 'boolean', 'integer', 'number', 'null'] and len(t) == 1:
-                    # This is a simple primitive type object like {"type": "boolean"} - extract the type string
+            elif isinstance(t, str):
+                # Simple type string - use directly
+                if t not in flat_list:
+                    flat_list.append(t)
+            elif isinstance(t, dict):
+                # Check if it's a simple primitive (type only, no constraints)
+                if '$ref' in t:
+                    # Reference - use directly
+                    if t not in flat_list:
+                        flat_list.append(t)
+                elif 'type' in t and t['type'] in simple_primitives and len(t) == 1:
+                    # Simple primitive type object like {"type": "boolean"} - extract the type string
                     if t['type'] not in flat_list:
                         flat_list.append(t['type'])
+                elif 'type' in t and t['type'] in simple_primitives:
+                    # Primitive with constraints (e.g., {type: "string", maxLength: 280})
+                    # This needs to be hoisted because inline constraints not allowed in union
+                    if structure_schema is not None:
+                        hoisted = self._hoist_definition(t, structure_schema, f"{name_hint or 'union'}_{t['type']}")
+                        if hoisted not in flat_list:
+                            flat_list.append(hoisted)
+                    else:
+                        # No structure schema for hoisting - fallback to just the type
+                        if t['type'] not in flat_list:
+                            flat_list.append(t['type'])
+                elif 'type' in t and t['type'] in ('array', 'object', 'set', 'map', 'choice'):
+                    # Compound type - must be hoisted
+                    if structure_schema is not None:
+                        hoisted = self._hoist_definition(t, structure_schema, f"{name_hint or 'union'}_{t['type']}")
+                        if hoisted not in flat_list:
+                            flat_list.append(hoisted)
+                    else:
+                        # No structure schema - use as is (will likely fail validation)
+                        obj = self._ensure_schema_object(t, structure_schema, f"{name_hint}_option_{idx}" if name_hint else None, force_hoist_in_union=True)
+                        if obj not in flat_list:
+                            flat_list.append(obj)
                 else:
-                    # For complex types, use the normal processing
+                    # Other dict structure - use normal processing
                     obj = self._ensure_schema_object(t, structure_schema, f"{name_hint}_option_{idx}" if name_hint else None, force_hoist_in_union=True)
                     if obj not in flat_list:
                         flat_list.append(obj)
+            else:
+                # Unknown type - use normal processing
+                obj = self._ensure_schema_object(t, structure_schema, f"{name_hint}_option_{idx}" if name_hint else None, force_hoist_in_union=True)
+                if obj not in flat_list:
+                    flat_list.append(obj)
         return flat_list
 
     def merge_structure_schemas(self, schemas: list, structure_schemas: list, type_name: str | None = None, deps: List[str] = []) -> str | list | dict:
@@ -1244,6 +1379,61 @@ class JsonToStructureConverter:
                             'type': 'object',
                             'properties': {}                        }
                 
+                # Handle type arrays (e.g., ["integer", "null"] for nullable in JSON Schema 2020-12/OpenAPI 3.1)
+                if json_type.get('type') and isinstance(json_type['type'], list):
+                    type_list = json_type['type']
+                    format_hint = json_type.get('format')
+                    enum_values = json_type.get('enum')
+                    
+                    # Check if any type in the list is a compound type (array, object)
+                    compound_types = {'array', 'object'}
+                    has_compound = any(t in compound_types for t in type_list if isinstance(t, str))
+                    
+                    if has_compound:
+                        # For compound types, we need to process each variant separately
+                        # and create a proper union. Compound types must be hoisted to definitions
+                        # because JSON Structure Core doesn't allow inline compound types in unions.
+                        union_members = []
+                        for t in type_list:
+                            if t == 'null':
+                                union_members.append('null')
+                            elif t == 'array':
+                                # Process array with the full schema context (items, etc.)
+                                array_schema = {**json_type, 'type': 'array'}
+                                array_type = self._process_array_type(
+                                    array_schema, record_name, field_name, namespace, dependencies,
+                                    json_schema, base_uri, structure_schema, record_stack, recursion_depth
+                                )
+                                # Hoist to definitions - inline compound types not allowed in union
+                                hoisted = self._hoist_definition(array_type, structure_schema, f"{field_name or record_name}_array")
+                                union_members.append(hoisted)
+                            elif t == 'object':
+                                # Process object with the full schema context (properties, etc.)
+                                object_schema = {**json_type, 'type': 'object'}
+                                object_type = self._process_object_type(
+                                    object_schema, record_name, field_name, namespace, dependencies,
+                                    json_schema, base_uri, structure_schema, record_stack, recursion_depth
+                                )
+                                # Hoist to definitions - inline compound types not allowed in union
+                                hoisted = self._hoist_definition(object_type, structure_schema, f"{field_name or record_name}_object")
+                                union_members.append(hoisted)
+                            elif isinstance(t, str):
+                                # Primitive type
+                                prim_type = self.json_schema_primitive_to_structure_type(
+                                    t, format_hint, enum_values, record_name, field_name, namespace, dependencies, json_type
+                                )
+                                union_members.append(prim_type)
+                        
+                        return {'type': self.flatten_union(union_members, structure_schema, field_name)}
+                    else:
+                        # All primitives, use the existing logic
+                        structure_type = self.json_schema_primitive_to_structure_type(
+                            type_list, format_hint, enum_values, record_name, field_name, namespace, dependencies, json_type
+                        )
+                        if isinstance(structure_type, dict):
+                            structure_type = self.add_validation_constraints(structure_type, json_type)
+                        return structure_type
+                
                 if json_type.get('type') and isinstance(json_type['type'], str):
                     # Check if this schema also has composition keywords that should be preserved
                     if self.preserve_composition and self.has_composition_keywords(json_type):
@@ -2160,12 +2350,20 @@ class JsonToStructureConverter:
             if 'allOf' in json_type:
                 # Merge all schemas in allOf
                 merged = {}
+                has_ref = False
+                ref_value = None
+                
                 for schema in json_type['allOf']:
                     converted = self.json_type_to_structure_type(
                         schema, record_name, field_name, namespace, dependencies,
                         json_schema, base_uri, structure_schema, record_stack, recursion_depth + 1
                     )
                     if isinstance(converted, dict):
+                        # Track if we have a $ref
+                        if '$ref' in converted:
+                            has_ref = True
+                            ref_value = converted['$ref']
+                        
                         # Simple merge - in real scenarios this would be more complex
                         for key, value in converted.items():
                             if key == 'properties' and key in merged:
@@ -2174,6 +2372,28 @@ class JsonToStructureConverter:
                                 merged[key] = list(set(merged[key] + value))
                             else:
                                 merged[key] = value
+                
+                # JSON Structure doesn't allow both $ref and type
+                # If we have a $ref and type with no meaningful properties, just use $ref
+                if has_ref and 'type' in merged:
+                    has_meaningful_properties = (
+                        'properties' in merged and merged['properties'] or
+                        'required' in merged and merged['required'] or
+                        'items' in merged
+                    )
+                    if not has_meaningful_properties:
+                        # Just return the reference
+                        result = {'$ref': ref_value}
+                        # Copy metadata fields if present
+                        for meta_key in ['description', 'title', 'doc']:
+                            if meta_key in merged:
+                                result[meta_key] = merged[meta_key]
+                        return result
+                    else:
+                        # Has meaningful extensions - need to create a proper extension
+                        # Remove the $ref and keep the merged type
+                        del merged['$ref']
+                
                 return merged
                 
             elif 'anyOf' in json_type:
@@ -2186,8 +2406,10 @@ class JsonToStructureConverter:
                     )
                     anyof_schemas.append(converted)
                 
+                # Use flatten_union to properly hoist compound types
+                flattened = self.flatten_union(anyof_schemas, structure_schema, field_name or record_name)
                 return {
-                    'type': anyof_schemas
+                    'type': flattened
                 }
                     
             elif 'oneOf' in json_type: