structurize 2.20.2__tar.gz → 2.20.4__tar.gz

{structurize-2.20.2/structurize.egg-info → structurize-2.20.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structurize
-Version: 2.20.2
+Version: 2.20.4
 Summary: Tools to convert from and to JSON Structure from various other schema languages.
 Author-email: Clemens Vasters <clemensv@microsoft.com>
 Classifier: Programming Language :: Python :: 3

{structurize-2.20.2 → structurize-2.20.4}/avrotize/__init__.py

@@ -56,6 +56,8 @@ _mappings = {
     "convert_avro_to_rust": (f"{mod}.avrotorust", "convert_avro_to_rust"),
     "convert_avro_schema_to_rust": (f"{mod}.avrotorust", "convert_avro_schema_to_rust"),
     "convert_avro_to_datapackage": (f"{mod}.avrotodatapackage", "convert_avro_to_datapackage"),
+    "convert_structure_to_javascript": (f"{mod}.structuretojs", "convert_structure_to_javascript"),
+    "convert_structure_schema_to_javascript": (f"{mod}.structuretojs", "convert_structure_schema_to_javascript"),
 }
 
 _lazy_loader = LazyLoader(_mappings)

{structurize-2.20.2 → structurize-2.20.4}/avrotize/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.20.2'
-__version_tuple__ = version_tuple = (2, 20, 2)
+__version__ = version = '2.20.4'
+__version_tuple__ = version_tuple = (2, 20, 4)
 
-__commit_id__ = commit_id = 'g1d3ea7c00'
+__commit_id__ = commit_id = 'gadd3e447a'

{structurize-2.20.2 → structurize-2.20.4}/avrotize/avrotocsharp.py

@@ -14,9 +14,12 @@ from avrotize.constants import (
     NEWTONSOFT_JSON_VERSION,
     SYSTEM_TEXT_JSON_VERSION,
     SYSTEM_MEMORY_DATA_VERSION,
+    PROTOBUF_NET_VERSION,
+    MSGPACK_VERSION,
     NUNIT_VERSION,
     NUNIT_ADAPTER_VERSION,
     MSTEST_SDK_VERSION,
+    COVERLET_VERSION,
 )
 import glob
 
@@ -49,7 +52,9 @@ class AvroToCSharp:
         self.system_text_json_annotation = False
         self.newtonsoft_json_annotation = False
         self.system_xml_annotation = False
+        self.msgpack_annotation = False
         self.avro_annotation = False
+        self.protobuf_net_annotation = False
         self.generated_types: Dict[str,str] = {}
         self.generated_avro_types: Dict[str, Dict[str, Union[str, Dict, List]]] = {}
         self.type_dict: Dict[str, Dict] = {}
@@ -177,7 +182,14 @@ class AvroToCSharp:
             else:
                 class_definition += f"[XmlRoot(\"{class_name}\")]\n"
 
-        fields_str = [self.generate_property(field, class_name, avro_namespace) for field in avro_schema.get('fields', [])]
+        if self.protobuf_net_annotation:
+            class_definition += "[ProtoContract]\n"
+
+        # Add MessagePack serialization attribute for the class if enabled
+        if self.msgpack_annotation:
+            class_definition += "[MessagePackObject]\n"
+
+        fields_str = [self.generate_property(index + 1, field, class_name, avro_namespace) for index, field in enumerate(avro_schema.get('fields', []))]
         class_body = "\n".join(fields_str)
         class_definition += f"public partial class {class_name}"
         if self.avro_annotation:
@@ -250,9 +262,11 @@ class AvroToCSharp:
             "avrotocsharp/dataclass_core.jinja",
             class_name=class_name,
             avro_annotation=self.avro_annotation,
+            protobuf_net_annotation=self.protobuf_net_annotation,
             system_text_json_annotation=self.system_text_json_annotation,
             newtonsoft_json_annotation=self.newtonsoft_json_annotation,
-            system_xml_annotation=self.system_xml_annotation, 
+            system_xml_annotation=self.system_xml_annotation,
+            msgpack_annotation=self.msgpack_annotation,
             json_match_clauses=self.create_is_json_match_clauses(avro_schema, avro_namespace, class_name)
         )
 
@@ -516,14 +530,19 @@ class AvroToCSharp:
                 union_type_name = union_type.rsplit('.', 1)[-1]
             if self.is_csharp_reserved_word(union_type_name):
                 union_type_name = f"@{union_type_name}"
+            proto_member_name = union_type_name[1:] if union_type_name.startswith("@") else union_type_name
             class_definition_objctr += f"{INDENT*3}if (obj is {union_type})\n{INDENT*3}{{\n{INDENT*4}self.{union_type_name} = ({union_type})obj;\n{INDENT*4}return self;\n{INDENT*3}}}\n"
             if union_type in self.generated_types and self.generated_types[union_type] == "class":
                 class_definition_genericrecordctor += f"{INDENT*3}if (obj.Schema.Fullname == {union_type}.AvroSchema.Fullname)\n{INDENT*3}{{\n{INDENT*4}this.{union_type_name} = new {union_type}(obj);\n{INDENT*4}return;\n{INDENT*3}}}\n"
             class_definition_ctors += \
                 f"{INDENT*2}/// <summary>\n{INDENT*2}/// Constructor for {union_type_name} values\n{INDENT*2}/// </summary>\n" + \
                 f"{INDENT*2}public {union_class_name}({union_type}? {union_type_name})\n{INDENT*2}{{\n{INDENT*3}this.{union_type_name} = {union_type_name};\n{INDENT*2}}}\n"
+            # Add Key attribute for MessagePack serialization if enabled
+            msgpack_key_attr = f"{INDENT*2}[Key({i})]\n" if self.msgpack_annotation else ""
             class_definition_decls += \
                 f"{INDENT*2}/// <summary>\n{INDENT*2}/// Gets the {union_type_name} value\n{INDENT*2}/// </summary>\n" + \
+                (f"{INDENT*2}[ProtoMember({i+1}, Name=\"{proto_member_name}\")]\n" if self.protobuf_net_annotation else "") + \
+                msgpack_key_attr + \
                 f"{INDENT*2}public {union_type}? {union_type_name} {{ get; set; }} = null;\n"
             class_definition_toobject += f"{INDENT*3}if ({union_type_name} != null) {{\n{INDENT*4}return {union_type_name};\n{INDENT*3}}}\n"
 
@@ -570,9 +589,14 @@ class AvroToCSharp:
         if self.system_xml_annotation:
             class_definition += \
                 f"{INDENT}[XmlRoot(\"{union_class_name}\")]\n"
+        if self.msgpack_annotation:
+            class_definition += \
+                f"{INDENT}[MessagePackObject]\n"
         if self.system_text_json_annotation:
             class_definition += \
                 f"{INDENT}[System.Text.Json.Serialization.JsonConverter(typeof({union_class_name}))]\n"
+        if self.protobuf_net_annotation:
+            class_definition += f"{INDENT}[ProtoContract]\n"
         class_definition += \
             f"{INDENT}public sealed class {union_class_name}"
         if self.system_text_json_annotation:
@@ -697,6 +721,8 @@ class AvroToCSharp:
     def is_enum_type(self, avro_type: Union[str, Dict, List]) -> bool:
         """ Checks if a type is an enum (including nullable enums) """
         if isinstance(avro_type, str):
+            if avro_type in ('null', 'boolean', 'int', 'long', 'float', 'double', 'bytes', 'string'):
+                return False
             schema = self.schema_doc
             name = avro_type.split('.')[-1]
             namespace = ".".join(avro_type.split('.')[:-1])
@@ -711,7 +737,7 @@ class AvroToCSharp:
             return avro_type.get('type') == 'enum'
         return False
 
-    def generate_property(self, field: Dict, class_name: str, parent_namespace: str) -> str:
+    def generate_property(self, field_index: int, field: Dict, class_name: str, parent_namespace: str) -> str:
         """ Generates a property """
         is_enum_type = self.is_enum_type(field['type'])
         field_type = self.convert_avro_type_to_csharp(
@@ -727,6 +753,9 @@ class AvroToCSharp:
         prop = ''
         prop += f"{INDENT}/// <summary>\n{INDENT}/// { field.get('doc', field_name) }\n{INDENT}/// </summary>\n"
         
+        if self.protobuf_net_annotation:
+            prop += f"{INDENT}[ProtoMember({field_index}, Name=\"{annotation_name}\")]\n"
+        
         # Add XML serialization attribute if enabled
         if self.system_xml_annotation:
             xmlkind = field.get('xmlkind', 'element')
@@ -735,6 +764,10 @@ class AvroToCSharp:
             elif xmlkind == 'attribute':
                 prop += f"{INDENT}[XmlAttribute(\"{annotation_name}\")]\n"
         
+        # Add MessagePack serialization attribute if enabled
+        if self.msgpack_annotation:
+            prop += f"{INDENT}[Key({field_index})]\n"
+
         if self.system_text_json_annotation:
             prop += f"{INDENT}[System.Text.Json.Serialization.JsonPropertyName(\"{annotation_name}\")]\n"
             if is_enum_type:
@@ -743,6 +776,8 @@ class AvroToCSharp:
                 prop += f"{INDENT}[System.Text.Json.Serialization.JsonConverter(typeof({field_type}))]\n"
         if self.newtonsoft_json_annotation:
             prop += f"{INDENT}[Newtonsoft.Json.JsonProperty(\"{annotation_name}\")]\n"
+            if is_enum_type:
+                prop += f"{INDENT}[Newtonsoft.Json.JsonConverter(typeof(Newtonsoft.Json.Converters.StringEnumConverter))]\n"
         
         # Determine initialization value
         initialization = ""
@@ -785,6 +820,8 @@ class AvroToCSharp:
             # Common using statements (add more as needed)
             file_content = "using System;\nusing System.Collections.Generic;\n"
             file_content += "using System.Linq;\n"
+            if self.protobuf_net_annotation:
+                file_content += "using ProtoBuf;\n"
             if self.system_text_json_annotation:
                 file_content += "using System.Text.Json;\n"
                 file_content += "using System.Text.Json.Serialization;\n"
@@ -792,6 +829,8 @@ class AvroToCSharp:
                 file_content += "using Newtonsoft.Json;\n"
             if self.system_xml_annotation:  # Add XML serialization using directive
                 file_content += "using System.Xml.Serialization;\n"
+            if self.msgpack_annotation:  # Add MessagePack serialization using directive
+                file_content += "using MessagePack;\n"
 
             if namespace:
                 # Namespace declaration with correct indentation for the definition
@@ -833,7 +872,9 @@ class AvroToCSharp:
                 avro_annotation=self.avro_annotation,
                 system_xml_annotation=self.system_xml_annotation,
                 system_text_json_annotation=self.system_text_json_annotation,
-                newtonsoft_json_annotation=self.newtonsoft_json_annotation
+                newtonsoft_json_annotation=self.newtonsoft_json_annotation,
+                protobuf_net_annotation=self.protobuf_net_annotation,
+                msgpack_annotation=self.msgpack_annotation
             )
         elif type_kind == "enum":
             test_class_definition = process_template(
@@ -845,7 +886,8 @@ class AvroToCSharp:
                 avro_annotation=self.avro_annotation,
                 system_xml_annotation=self.system_xml_annotation,
                 system_text_json_annotation=self.system_text_json_annotation,
-                newtonsoft_json_annotation=self.newtonsoft_json_annotation
+                newtonsoft_json_annotation=self.newtonsoft_json_annotation,
+                protobuf_net_annotation=self.protobuf_net_annotation
             )
 
         test_file_path = os.path.join(test_directory_path, f"{test_class_name}.cs")
@@ -856,13 +898,14 @@ class AvroToCSharp:
         """ Retrieves fields for a given class name """
 
         class Field:
-            def __init__(self, fn: str, ft:str, tv:Any, ct: bool, pm: bool, ie: bool):
+            def __init__(self, fn: str, ft:str, tv:Any, ct: bool, pm: bool, ie: bool, iu: bool):
                 self.field_name = fn
                 self.field_type = ft
                 self.test_value = tv
                 self.is_const = ct
                 self.is_primitive = pm
                 self.is_enum = ie
+                self.is_union = iu
 
         fields: List[Field] = []
         if avro_schema and 'fields' in avro_schema:
@@ -877,16 +920,19 @@ class AvroToCSharp:
                 field_type = self.convert_avro_type_to_csharp(class_name, field_name, field['type'], str(avro_schema.get('namespace', '')))
                 is_class = field_type in self.generated_types and self.generated_types[field_type] == "class"
                 is_enum = self.is_enum_type(field['type'])
+                is_union = field_type in self.generated_types and self.generated_types[field_type] == "union"
+                test_value = self.get_test_value(field_type, field['type'], str(avro_schema.get('namespace', ''))) if not "const" in field else '\"'+str(field["const"])+'\"'
                 f = Field(field_name,
                           field_type,
-                          (self.get_test_value(field_type) if not "const" in field else '\"'+str(field["const"])+'\"'),
+                          test_value,
                           "const" in field and field["const"] is not None,
                           not is_class,
-                          is_enum)
+                          is_enum,
+                          is_union)
                 fields.append(f)
         return cast(List[Any], fields)
 
-    def get_test_value(self, csharp_type: str) -> str:
+    def get_test_value(self, csharp_type: str, avro_type: JsonNode = None, parent_namespace: str = '') -> str:
         """Returns a default test value based on the Avro type"""
         # For nullable object types, return typed null to avoid var issues
         if csharp_type == "object?":
@@ -908,6 +954,19 @@ class AvroToCSharp:
         }
         if csharp_type.endswith('?'):
             csharp_type = csharp_type[:-1]
+        
+        # Check if this is a union type (either by generated_types lookup or by type structure)
+        if csharp_type in self.generated_types and self.generated_types[csharp_type] == "union":
+            # For union types, we need to initialize with one of the valid options
+            # Find the first non-null type in the union and create a value for it
+            if isinstance(avro_type, list):
+                non_null_types = [t for t in avro_type if t != 'null']
+                if non_null_types:
+                    first_option = non_null_types[0]
+                    first_option_csharp = self.convert_avro_type_to_csharp('', 'Option0', first_option, parent_namespace)
+                    first_option_value = self.get_test_value(first_option_csharp, first_option, parent_namespace)
+                    return f'new {csharp_type}({first_option_value})'
+        
         return test_values.get(csharp_type, f'new {csharp_type}()')
 
     def convert_schema(self, schema: JsonNode, output_dir: str):
@@ -967,10 +1026,14 @@ class AvroToCSharp:
                         system_xml_annotation=self.system_xml_annotation,
                         system_text_json_annotation=self.system_text_json_annotation,
                         newtonsoft_json_annotation=self.newtonsoft_json_annotation,
+                        protobuf_net_annotation=self.protobuf_net_annotation,
+                        msgpack_annotation=self.msgpack_annotation,
                         CSHARP_AVRO_VERSION=CSHARP_AVRO_VERSION,
                         NEWTONSOFT_JSON_VERSION=NEWTONSOFT_JSON_VERSION,
                         SYSTEM_TEXT_JSON_VERSION=SYSTEM_TEXT_JSON_VERSION,
                         SYSTEM_MEMORY_DATA_VERSION=SYSTEM_MEMORY_DATA_VERSION,
+                        PROTOBUF_NET_VERSION=PROTOBUF_NET_VERSION,
+                        MSGPACK_VERSION=MSGPACK_VERSION,
                         NUNIT_VERSION=NUNIT_VERSION,
                         NUNIT_ADAPTER_VERSION=NUNIT_ADAPTER_VERSION,
                         MSTEST_SDK_VERSION=MSTEST_SDK_VERSION))
@@ -988,9 +1051,39 @@ class AvroToCSharp:
                         system_xml_annotation=self.system_xml_annotation,
                         system_text_json_annotation=self.system_text_json_annotation,
                         newtonsoft_json_annotation=self.newtonsoft_json_annotation,
+                        protobuf_net_annotation=self.protobuf_net_annotation,
                         NUNIT_VERSION=NUNIT_VERSION,
                         NUNIT_ADAPTER_VERSION=NUNIT_ADAPTER_VERSION,
-                        MSTEST_SDK_VERSION=MSTEST_SDK_VERSION))
+                        MSTEST_SDK_VERSION=MSTEST_SDK_VERSION,
+                        COVERLET_VERSION=COVERLET_VERSION))
+
+        # Generate coverage scripts
+        if not os.path.exists(os.path.join(output_dir, "run_coverage.ps1")):
+            coverage_ps1_file = os.path.join(output_dir, "run_coverage.ps1")
+            with open(coverage_ps1_file, 'w', encoding='utf-8') as file:
+                file.write(process_template(
+                    "avrotocsharp/run_coverage.ps1.jinja", 
+                    project_name=project_name))
+        
+        if not os.path.exists(os.path.join(output_dir, "run_coverage.sh")):
+            coverage_sh_file = os.path.join(output_dir, "run_coverage.sh")
+            with open(coverage_sh_file, 'w', encoding='utf-8') as file:
+                file.write(process_template(
+                    "avrotocsharp/run_coverage.sh.jinja", 
+                    project_name=project_name))
+            # Make the shell script executable on Unix-like systems
+            try:
+                os.chmod(coverage_sh_file, 0o755)
+            except:
+                pass  # Ignore on Windows
+        
+        # Generate README with coverage documentation
+        if not os.path.exists(os.path.join(output_dir, "README.md")):
+            readme_file = os.path.join(output_dir, "README.md")
+            with open(readme_file, 'w', encoding='utf-8') as file:
+                file.write(process_template(
+                    "avrotocsharp/README.md.jinja", 
+                    project_name=project_name))
 
         self.output_dir = output_dir
         for avro_schema in (avs for avs in schema if isinstance(avs, dict)):
@@ -1012,8 +1105,10 @@ def convert_avro_to_csharp(
     pascal_properties=False, 
     system_text_json_annotation=False, 
     newtonsoft_json_annotation=False, 
-    system_xml_annotation=False,  # New parameter
-    avro_annotation=False
+    system_xml_annotation=False,
+    msgpack_annotation=False,
+    avro_annotation=False,
+    protobuf_net_annotation=False
 ):
     """Converts Avro schema to C# classes
 
@@ -1026,7 +1121,9 @@ def convert_avro_to_csharp(
         system_text_json_annotation (bool, optional): Use System.Text.Json annotations. Defaults to False.
         newtonsoft_json_annotation (bool, optional): Use Newtonsoft.Json annotations. Defaults to False.
         system_xml_annotation (bool, optional): Use System.Xml.Serialization annotations. Defaults to False.
+        msgpack_annotation (bool, optional): Use MessagePack annotations. Defaults to False.
         avro_annotation (bool, optional): Use Avro annotations. Defaults to False.
+        protobuf_net_annotation (bool, optional): Use protobuf-net annotations. Defaults to False.
     """
 
     if not base_namespace:
@@ -1036,8 +1133,10 @@ def convert_avro_to_csharp(
     avrotocs.pascal_properties = pascal_properties
     avrotocs.system_text_json_annotation = system_text_json_annotation
     avrotocs.newtonsoft_json_annotation = newtonsoft_json_annotation
-    avrotocs.system_xml_annotation = system_xml_annotation  # Set the flag
+    avrotocs.system_xml_annotation = system_xml_annotation
+    avrotocs.msgpack_annotation = msgpack_annotation
     avrotocs.avro_annotation = avro_annotation
+    avrotocs.protobuf_net_annotation = protobuf_net_annotation
     avrotocs.convert(avro_schema_path, cs_file_path)
 
 
@@ -1049,8 +1148,10 @@ def convert_avro_schema_to_csharp(
     pascal_properties: bool = False, 
     system_text_json_annotation: bool = False, 
     newtonsoft_json_annotation: bool = False, 
-    system_xml_annotation: bool = False,  # New parameter
-    avro_annotation: bool = False
+    system_xml_annotation: bool = False,
+    msgpack_annotation: bool = False,
+    avro_annotation: bool = False,
+    protobuf_net_annotation: bool = False
 ):
     """Converts Avro schema to C# classes
 
@@ -1063,13 +1164,17 @@ def convert_avro_schema_to_csharp(
         system_text_json_annotation (bool, optional): Use System.Text.Json annotations. Defaults to False.
         newtonsoft_json_annotation (bool, optional): Use Newtonsoft.Json annotations. Defaults to False.
         system_xml_annotation (bool, optional): Use System.Xml.Serialization annotations. Defaults to False.
+        msgpack_annotation (bool, optional): Use MessagePack annotations. Defaults to False.
         avro_annotation (bool, optional): Use Avro annotations. Defaults to False.
+        protobuf_net_annotation (bool, optional): Use protobuf-net annotations. Defaults to False.
     """
     avrotocs = AvroToCSharp(base_namespace)
     avrotocs.project_name = project_name
     avrotocs.pascal_properties = pascal_properties
     avrotocs.system_text_json_annotation = system_text_json_annotation
     avrotocs.newtonsoft_json_annotation = newtonsoft_json_annotation
-    avrotocs.system_xml_annotation = system_xml_annotation  # Set the flag
+    avrotocs.system_xml_annotation = system_xml_annotation
+    avrotocs.msgpack_annotation = msgpack_annotation
     avrotocs.avro_annotation = avro_annotation
+    avrotocs.protobuf_net_annotation = protobuf_net_annotation
     avrotocs.convert_schema(avro_schema, output_dir)

{structurize-2.20.2 → structurize-2.20.4}/avrotize/avrotots.py

@@ -266,9 +266,9 @@ class AvroToTypeScript:
             first_type = field_type.split('|')[0].strip()
             return self.generate_test_value(first_type, is_enum)
         
-        # Handle enums - use first value (will be set via template)
+        # Handle enums - use first value with Object.values()
         if is_enum:
-            return f'{field_type}.values()[0]'
+            return f'Object.values({field_type})[0] as {field_type}'
         
         # Handle primitive types
         primitive_values = {

{structurize-2.20.2 → structurize-2.20.4}/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
+      }
+    ]
   }
 ]