export site/lib/log-generation/sorbet-enums.json and site/lib/log-generation/sorbet-log-structs.json

Author: ndbroadbent

site/.gitignore

@@ -44,6 +44,8 @@ next-env.d.ts
 # Exported log types and keys (generated by ./scripts/export_typescript_types.rb)
 lib/log-generation/log-types.ts
 lib/log-generation/log-keys.json
+lib/log-generation/sorbet-enums.json
+lib/log-generation/sorbet-log-structs.json
 
 # Generated HTML - YARD docs, coverage reports, etc.
 public/yard/

test/tools/log_types_exporter_test.rb

@@ -40,6 +40,14 @@ def test_generates_typescript_types
 
     # Test that it includes the union type
     assert_includes content, "export type Log =", "Should export Log union type"
+    
+    # Check if the enums JSON file was created
+    enums_json_file = File.join(File.dirname(@output_ts_file), "sorbet-enums.json")
+    assert_path_exists enums_json_file, "Enums JSON file should have been created"
+    
+    # Check if the log structs JSON file was created
+    structs_json_file = File.join(File.dirname(@output_ts_file), "sorbet-log-structs.json")
+    assert_path_exists structs_json_file, "Log structs JSON file should have been created"
   end
 
   def test_generate_typescript_definitions
@@ -322,4 +330,87 @@ def test_exports_all_log_types_array
       assert_includes all_types_content, log_type, "AllLogTypes array should contain #{log_type}"
     end
   end
+  
+  def test_exports_enums_to_json
+    # Get the temp directory for output
+    enums_json_file = File.join(@temp_dir, "sorbet-enums.json")
+    
+    # Get the data
+    data = @exporter.send(:generate_data)
+    
+    # Export enums to JSON
+    @exporter.export_enums_to_json(data[:enums], enums_json_file)
+    
+    # Verify file exists
+    assert_path_exists enums_json_file, "Enums JSON file should have been created"
+    
+    # Read and parse the JSON
+    json_data = JSON.parse(File.read(enums_json_file))
+    
+    # Verify structure
+    assert json_data.is_a?(Hash), "JSON data should be a hash"
+    
+    # Check for specific enums
+    assert json_data.key?("LogStruct::LogLevel"), "Should include LogStruct::LogLevel"
+    assert json_data.key?("LogStruct::Source"), "Should include LogStruct::Source"
+    assert json_data.key?("LogStruct::LogEvent"), "Should include LogStruct::LogEvent"
+    
+    # Check that values are properly structured
+    log_level_values = json_data["LogStruct::LogLevel"]
+    assert log_level_values.is_a?(Array), "Values should be an array"
+    assert log_level_values.first.is_a?(Hash), "Each value should be a hash"
+    assert log_level_values.first.key?("name"), "Each value should have a name"
+    assert log_level_values.first.key?("value"), "Each value should have a value"
+    
+    # Check for specific enum values
+    log_level_values.each do |value|
+      if value["name"] == "Info"
+        assert_equal "info", value["value"], "Info enum should serialize as 'info'"
+      end
+    end
+  end
+  
+  def test_exports_log_structs_to_json
+    # Get the temp directory for output
+    structs_json_file = File.join(@temp_dir, "sorbet-log-structs.json")
+    
+    # Get the data
+    data = @exporter.send(:generate_data)
+    
+    # Export log structs to JSON
+    @exporter.export_log_structs_to_json(data[:logs], structs_json_file)
+    
+    # Verify file exists
+    assert_path_exists structs_json_file, "Log structs JSON file should have been created"
+    
+    # Read and parse the JSON
+    json_data = JSON.parse(File.read(structs_json_file))
+    
+    # Verify structure
+    assert json_data.is_a?(Hash), "JSON data should be a hash"
+    
+    # Check for specific structs
+    assert json_data.key?("LogStruct::Log::Request"), "Should include LogStruct::Log::Request"
+    assert json_data.key?("LogStruct::Log::Error"), "Should include LogStruct::Log::Error"
+    assert json_data.key?("LogStruct::Log::Plain"), "Should include LogStruct::Log::Plain"
+    
+    # Check struct structure
+    request_struct = json_data["LogStruct::Log::Request"]
+    assert_equal "Request", request_struct["name"], "Should have correct name"
+    assert request_struct.key?("fields"), "Should have fields"
+    
+    # Check field structure
+    fields = request_struct["fields"]
+    assert fields.is_a?(Hash), "Fields should be a hash"
+    
+    # Check specific fields
+    assert fields.key?("path"), "Should have path field"
+    assert fields.key?("status"), "Should have status field"
+    assert fields.key?("duration"), "Should have duration field"
+    
+    # Check field types
+    assert_equal "string", fields["path"]["type"], "Path should be a string"
+    assert_equal "integer", fields["status"]["type"], "Status should be an integer"
+    assert_equal "number", fields["duration"]["type"], "Duration should be a number"
+  end
 end

tools/log_types_exporter.rb

@@ -28,6 +28,9 @@ def initialize(output_ts_file = DEFAULT_OUTPUT_TS_FILE, log_struct_classes = nil
       # Public method to export TypeScript definitions and JSON key mappings to files
       sig { void }
       def export
+        # Get the data once and reuse for all exports
+        data = generate_data
+
         # Export TypeScript definitions
         puts "Exporting LogStruct types to TypeScript..."
         puts "Output file: #{@output_ts_file}"
@@ -36,7 +39,7 @@ def export
         FileUtils.mkdir_p(File.dirname(@output_ts_file))
 
         # Generate the TypeScript content
-        content = generate_typescript_definitions
+        content = generate_typescript(data)
 
         # Write to file
         File.write(@output_ts_file, content)
@@ -45,6 +48,9 @@ def export
 
         # Export LOG_KEYS mapping to JSON
         export_keys_to_json
+
+        # Export enums and log structs to JSON
+        export_data_to_json(data)
       end
 
       # Export LOG_KEYS mapping to a JSON file
@@ -70,15 +76,108 @@ def export_keys_to_json(output_json_file = nil)
         puts "Exported key mappings to #{output_json_file}"
       end
 
+      # Export both enums and log structs to JSON files
+      sig { params(data: T::Hash[Symbol, T.untyped]).void }
+      def export_data_to_json(data)
+        # Export enums to JSON
+        export_enums_to_json(data[:enums])
+        
+        # Export log structs to JSON
+        export_log_structs_to_json(data[:logs])
+      end
+      
+      # Export Sorbet enums to a JSON file
+      sig { params(enums_data: T::Hash[Symbol, T::Array[String]], output_json_file: T.nilable(String)).void }
+      def export_enums_to_json(enums_data, output_json_file = nil)
+        # Default to the same directory as the TypeScript file
+        output_json_file ||= File.join(File.dirname(@output_ts_file), "sorbet-enums.json")
+
+        puts "Exporting Sorbet enums to JSON..."
+        puts "Output file: #{output_json_file}"
+
+        # Create output directory if needed
+        FileUtils.mkdir_p(File.dirname(output_json_file))
+
+        # Format enum data for JSON
+        json_enum_data = {}
+        
+        # For each enum, get the full class name and values
+        T::Enum.subclasses
+          .select { |klass| klass.name.to_s.start_with?("LogStruct::") }
+          .each do |enum_class|
+            # Get the full enum name (e.g., "LogStruct::LogLevel")
+            full_name = enum_class.name.to_s
+            
+            # Get the simple name (e.g., "LogLevel")
+            simple_name = full_name.split("::").last
+            
+            # Skip if we don't have data for this enum
+            next unless enums_data.key?(simple_name.to_sym)
+            
+            # Map enum values to their constant names
+            values_with_names = enum_class.values.map do |value|
+              constant_name = enum_class.constants.find { |const_name| enum_class.const_get(const_name) == value }&.to_s
+              serialized = value.serialize
+              
+              # Return a hash with name and value
+              {
+                name: constant_name,
+                value: serialized
+              }
+            end
+            
+            # Add to the JSON data
+            json_enum_data[full_name] = values_with_names
+          end
+
+        # Write to file with pretty formatting
+        File.write(output_json_file, JSON.pretty_generate(json_enum_data))
+
+        puts "Exported Sorbet enums to #{output_json_file}"
+      end
+
+      # Export LogStruct log structs to a JSON file
+      sig { params(logs_data: T::Hash[String, T::Hash[Symbol, T.untyped]], output_json_file: T.nilable(String)).void }
+      def export_log_structs_to_json(logs_data, output_json_file = nil)
+        # Default to the same directory as the TypeScript file
+        output_json_file ||= File.join(File.dirname(@output_ts_file), "sorbet-log-structs.json")
+
+        puts "Exporting LogStruct log structs to JSON..."
+        puts "Output file: #{output_json_file}"
+
+        # Create output directory if needed
+        FileUtils.mkdir_p(File.dirname(output_json_file))
+
+        # Format structs data for JSON
+        json_structs_data = {}
+        
+        # Process each log struct class
+        logs_data.each do |struct_name, struct_info|
+          # Get the full class name
+          full_name = "LogStruct::Log::#{struct_name}"
+          
+          # Add to the structs data
+          json_structs_data[full_name] = {
+            name: struct_name,
+            fields: struct_info[:fields].transform_keys(&:to_s)
+          }
+        end
+
+        # Write to file with pretty formatting
+        File.write(output_json_file, JSON.pretty_generate(json_structs_data))
+
+        puts "Exported LogStruct log structs to #{output_json_file}"
+      end
+
       # Public method to generate TypeScript definitions as a string
       # This is the method we can test easily without file I/O
       sig { returns(String) }
       def generate_typescript_definitions
         # Get the data
-        log_types_data = generate_data
+        data = generate_data
 
         # Transform data to TypeScript
-        generate_typescript(log_types_data)
+        generate_typescript(data)
       end
 
       sig { returns(T::Hash[Symbol, T.untyped]) }