binder: snapshot

crates/brk_binder/src/javascript.rs

@@ -9,8 +9,8 @@ use serde_json::Value;
 
 use crate::{
     ClientMetadata, Endpoint, FieldNamePosition, IndexSetPattern, PatternField, StructuralPattern,
-    TypeSchemas, get_first_leaf_name, get_node_fields, get_pattern_instance_base, to_camel_case,
-    to_pascal_case,
+    TypeSchemas, extract_inner_type, get_first_leaf_name, get_node_fields,
+    get_pattern_instance_base, to_camel_case, to_pascal_case,
 };
 
 /// Generate JavaScript + JSDoc client from metadata and OpenAPI endpoints
@@ -364,7 +364,11 @@ fn generate_structural_patterns(
         writeln!(output, " * @returns {{{}}}", pattern.name).unwrap();
         writeln!(output, " */").unwrap();
 
-        let param_name = if is_parameterizable { "acc" } else { "basePath" };
+        let param_name = if is_parameterizable {
+            "acc"
+        } else {
+            "basePath"
+        };
         writeln!(
             output,
             "function create{}(client, {}) {{",
@@ -510,18 +514,19 @@ fn field_to_js_type_with_generic_value(
     generic_value_type: Option<&str>,
 ) -> String {
     // For generic patterns, use T instead of concrete value type
+    // Also extract inner type from wrappers like Close<Dollars> -> Dollars
     let value_type = if is_generic && field.rust_type == "T" {
         "T".to_string()
     } else {
-        field.rust_type.clone()
+        extract_inner_type(&field.rust_type)
     };
 
     if metadata.is_pattern_type(&field.rust_type) {
         // Check if this pattern is generic and we have a value type
-        if metadata.is_pattern_generic(&field.rust_type) {
-            if let Some(vt) = generic_value_type {
-                return format!("{}<{}>", field.rust_type, vt);
-            }
+        if metadata.is_pattern_generic(&field.rust_type)
+            && let Some(vt) = generic_value_type
+        {
+            return format!("{}<{}>", field.rust_type, vt);
         }
         field.rust_type.clone()
     } else if let Some(accessor) = metadata.find_index_set_pattern(&field.indexes) {
@@ -571,7 +576,11 @@ fn generate_tree_typedef(
                 let (rust_type, json_type, indexes, child_fields) = match child_node {
                     TreeNode::Leaf(leaf) => (
                         leaf.value_type().to_string(),
-                        leaf.schema.get("type").and_then(|v| v.as_str()).unwrap_or("object").to_string(),
+                        leaf.schema
+                            .get("type")
+                            .and_then(|v| v.as_str())
+                            .unwrap_or("object")
+                            .to_string(),
                         leaf.indexes().clone(),
                         None,
                     ),
@@ -581,19 +590,30 @@ fn generate_tree_typedef(
                             .get(&child_fields)
                             .cloned()
                             .unwrap_or_else(|| format!("{}_{}", name, to_pascal_case(child_name)));
-                        (pattern_name.clone(), pattern_name, std::collections::BTreeSet::new(), Some(child_fields))
+                        (
+                            pattern_name.clone(),
+                            pattern_name,
+                            std::collections::BTreeSet::new(),
+                            Some(child_fields),
+                        )
                     }
                 };
-                (PatternField {
-                    name: child_name.clone(),
-                    rust_type,
-                    json_type,
-                    indexes,
-                }, child_fields)
+                (
+                    PatternField {
+                        name: child_name.clone(),
+                        rust_type,
+                        json_type,
+                        indexes,
+                    },
+                    child_fields,
+                )
             })
             .collect();
 
-        let fields: Vec<PatternField> = fields_with_child_info.iter().map(|(f, _)| f.clone()).collect();
+        let fields: Vec<PatternField> = fields_with_child_info
+            .iter()
+            .map(|(f, _)| f.clone())
+            .collect();
 
         // Skip if this matches a pattern (already generated)
         if pattern_lookup.contains_key(&fields)
@@ -612,10 +632,15 @@ fn generate_tree_typedef(
 
         for (field, child_fields) in &fields_with_child_info {
             // For generic patterns, extract the value type from child fields
-            let generic_value_type = child_fields.as_ref().and_then(|cf| {
-                metadata.get_generic_value_type(&field.rust_type, cf)
-            });
-            let js_type = field_to_js_type_with_generic_value(field, metadata, false, generic_value_type.as_deref());
+            let generic_value_type = child_fields
+                .as_ref()
+                .and_then(|cf| metadata.get_generic_value_type(&field.rust_type, cf));
+            let js_type = field_to_js_type_with_generic_value(
+                field,
+                metadata,
+                false,
+                generic_value_type.as_deref(),
+            );
             writeln!(
                 output,
                 " * @property {{{}}} {}",
@@ -766,11 +791,8 @@ fn generate_tree_initializer(
                         .unwrap();
                     } else {
                         // Not a pattern - recurse with accumulated name
-                        let child_acc = infer_child_accumulated_name(
-                            child_node,
-                            accumulated_name,
-                            child_name,
-                        );
+                        let child_acc =
+                            infer_child_accumulated_name(child_node, accumulated_name, child_name);
                         writeln!(output, "{}{}: {{", indent_str, field_name).unwrap();
                         generate_tree_initializer(
                             output,