fix(ruby): implement convertObjectToHashEntries for samePropertiesAsObject discriminated unions

Co-Authored-By: [email protected] <[email protected]>

Author: devin-ai-integration[bot]

generators/ruby-v2/dynamic-snippets/src/__test__/__snapshots__/DynamicSnippetsGenerator.test.ts.snap

@@ -46,6 +46,14 @@ client.service.create_big_entity(
     metadata: {},
     revenue: 1000000
   },
+  event_info: {
+    id: 'event-12345',
+    data: {
+      key1: 'val1',
+      key2: 'val2'
+    },
+    json_string: 'abc'
+  },
   migration: {
     name: 'Migration 31 Aug',
     status: 'RUNNING'

generators/ruby-v2/dynamic-snippets/src/context/DynamicToLiteralMapper.ts

@@ -227,10 +227,19 @@ export class DynamicTypeLiteralMapper {
                 if (named == null) {
                     return undefined;
                 }
-                const converted = this.convertNamed({ named, value: discriminatedUnionTypeInstance.value });
-                // For Ruby, we expect a hash back from convertNamed for objects
-                // We need to extract the entries from the hash
-                return this.extractHashEntries(converted);
+                // For samePropertiesAsObject, the named type should be an object
+                // We convert it directly to hash entries instead of going through convertNamed
+                if (named.type !== "object") {
+                    this.context.errors.add({
+                        severity: Severity.Critical,
+                        message: "Internal error; expected union value to be an object"
+                    });
+                    return undefined;
+                }
+                return this.convertObjectToHashEntries({
+                    object: named,
+                    value: discriminatedUnionTypeInstance.value
+                });
             }
             case "singleProperty": {
                 try {
@@ -271,19 +280,6 @@ export class DynamicTypeLiteralMapper {
         }
     }
 
-    private extractHashEntries(node: ruby.AstNode): ruby.HashEntry[] | undefined {
-        // This is a workaround to extract hash entries from a TypeLiteral
-        // We need to check if the node is a hash and extract its entries
-        // For now, we'll return an empty array if we can't extract entries
-        // The node should be a hash created by convertObject
-        if (node instanceof ruby.TypeLiteral) {
-            // TypeLiteral doesn't expose internal type, so we need to work around this
-            // by re-converting the value as an object
-            return undefined;
-        }
-        return undefined;
-    }
-
     private convertEnum({ enum_, value }: { enum_: FernIr.dynamic.EnumType; value: unknown }): ruby.AstNode {
         const name = this.getEnumValueName({ enum_, value });
         if (name == null) {
@@ -426,29 +422,48 @@ export class DynamicTypeLiteralMapper {
     }
 
     private convertObject({ object, value }: { object: FernIr.dynamic.ObjectType; value: unknown }): ruby.AstNode {
+        const entries = this.convertObjectToHashEntries({ object, value });
+        if (entries == null) {
+            return ruby.TypeLiteral.nop();
+        }
+        return ruby.TypeLiteral.hash(entries);
+    }
+
+    private convertObjectToHashEntries({
+        object,
+        value
+    }: {
+        object: FernIr.dynamic.ObjectType;
+        value: unknown;
+    }): ruby.HashEntry[] | undefined {
         if (typeof value !== "object" || value == null) {
             this.context.errors.add({
                 severity: Severity.Critical,
                 message: `Expected object but got: ${value == null ? "null" : typeof value}`
             });
-            return ruby.TypeLiteral.nop();
+            return undefined;
         }
 
-        return ruby.TypeLiteral.hash(
-            Object.entries(value as Record<string, unknown>).map(([key, val]) => {
-                this.context.errors.scope(key);
+        const entries: ruby.HashEntry[] = [];
+
+        for (const [key, val] of Object.entries(value as Record<string, unknown>)) {
+            this.context.errors.scope(key);
+            try {
                 const property = object.properties.find((p) => p.name.wireValue === key);
-                const typeReference = property?.typeReference ?? { type: "unknown" };
+                const typeReference = property?.typeReference ?? { type: "unknown" as const };
                 // Use snake_case property name for Ruby, falling back to wire value if not found
                 const propertyName = property?.name.name.snakeCase.safeName ?? key;
-                const astNode = {
+
+                entries.push({
                     key: ruby.TypeLiteral.string(propertyName),
                     value: this.convert({ typeReference, value: val })
-                };
+                });
+            } finally {
                 this.context.errors.unscope();
-                return astNode;
-            })
-        );
+            }
+        }
+
+        return entries;
     }
 
     private getValueAsNumber({