Add support for SDK native types in dyn conversion (#4385)

## Changes

Implements conversion support for SDK native types across the dyn
package conversion layer (FromTyped, ToTyped, Normalize). Supports three
SDK types that use custom JSON marshaling:

- duration.Duration: Protobuf duration format (e.g., "300s")
- time.Time: RFC3339 timestamp format (e.g., "2023-12-25T10:30:00Z")
- fieldmask.FieldMask: Comma-separated paths (e.g., "name,age,email")

The implementation uses a generic approach with all SDK-specific code in
sdk_native_types.go and sdk_native_types_test.go.

## Why

The new Postgres APIs use these types and need the to/from conversion to
work.

Also see databricks/databricks-sdk-go#1271.

---------

Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: pietern

libs/dyn/convert/from_typed.go

@@ -59,7 +59,12 @@ func fromTyped(src any, ref dyn.Value, options ...fromTypedOptions) (dyn.Value,
 	var err error
 	switch srcv.Kind() {
 	case reflect.Struct:
-		v, err = fromTypedStruct(srcv, ref, options...)
+		// Handle SDK native types using JSON marshaling.
+		if slices.Contains(sdkNativeTypes, srcv.Type()) {
+			v, err = fromTypedSDKNative(srcv, ref, options...)
+		} else {
+			v, err = fromTypedStruct(srcv, ref, options...)
+		}
 	case reflect.Map:
 		v, err = fromTypedMap(srcv, ref)
 	case reflect.Slice:

libs/dyn/convert/normalize.go

@@ -43,6 +43,10 @@ func (n normalizeOptions) normalizeType(typ reflect.Type, src dyn.Value, seen []
 
 	switch typ.Kind() {
 	case reflect.Struct:
+		// Handle SDK native types as strings since they use custom JSON marshaling.
+		if slices.Contains(sdkNativeTypes, typ) {
+			return n.normalizeString(reflect.TypeOf(""), src, path)
+		}
 		return n.normalizeStruct(typ, src, append(seen, typ), path)
 	case reflect.Map:
 		return n.normalizeMap(typ, src, append(seen, typ), path)

libs/dyn/convert/sdk_native_types.go

@@ -0,0 +1,97 @@
+package convert
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"slices"
+
+	"github.com/databricks/cli/libs/dyn"
+	"github.com/databricks/cli/libs/dyn/dynvar"
+	sdkduration "github.com/databricks/databricks-sdk-go/common/types/duration"
+	sdkfieldmask "github.com/databricks/databricks-sdk-go/common/types/fieldmask"
+	sdktime "github.com/databricks/databricks-sdk-go/common/types/time"
+)
+
+// sdkNativeTypes is a list of SDK native types that use custom JSON marshaling
+// and should be treated as strings in dyn.Value. These types all implement
+// json.Marshaler and json.Unmarshaler interfaces.
+var sdkNativeTypes = []reflect.Type{
+	reflect.TypeFor[sdkduration.Duration](),   // Protobuf duration format (e.g., "300s")
+	reflect.TypeFor[sdktime.Time](),           // RFC3339 timestamp format (e.g., "2023-12-25T10:30:00Z")
+	reflect.TypeFor[sdkfieldmask.FieldMask](), // Comma-separated paths (e.g., "name,age,email")
+}
+
+// fromTypedSDKNative converts SDK native types to dyn.Value.
+// SDK native types (duration.Duration, time.Time, fieldmask.FieldMask) use
+// custom JSON marshaling with string representations.
+func fromTypedSDKNative(src reflect.Value, ref dyn.Value, options ...fromTypedOptions) (dyn.Value, error) {
+	// Check that the reference value is compatible or nil.
+	switch ref.Kind() {
+	case dyn.KindString:
+		// Ignore pure variable references (e.g. ${var.foo}).
+		if dynvar.IsPureVariableReference(ref.MustString()) {
+			return ref, nil
+		}
+	case dyn.KindNil:
+		// Allow nil reference.
+	default:
+		return dyn.InvalidValue, fmt.Errorf("cannot convert SDK native type to dynamic type %#v", ref.Kind().String())
+	}
+
+	// Check for zero value first.
+	if src.IsZero() && !slices.Contains(options, includeZeroValues) {
+		return dyn.NilValue, nil
+	}
+
+	// Use JSON marshaling since SDK native types implement json.Marshaler.
+	jsonBytes, err := json.Marshal(src.Interface())
+	if err != nil {
+		return dyn.InvalidValue, err
+	}
+
+	// All SDK native types marshal to JSON strings. Unmarshal to get the raw string value.
+	// For example: duration.Duration(300s) -> JSON "300s" -> string "300s"
+	var str string
+	if err := json.Unmarshal(jsonBytes, &str); err != nil {
+		return dyn.InvalidValue, err
+	}
+
+	// Handle empty string as zero value.
+	if str == "" && !slices.Contains(options, includeZeroValues) {
+		return dyn.NilValue, nil
+	}
+
+	return dyn.V(str), nil
+}
+
+// toTypedSDKNative converts a dyn.Value to an SDK native type.
+// SDK native types (duration.Duration, time.Time, fieldmask.FieldMask) use
+// custom JSON marshaling with string representations.
+func toTypedSDKNative(dst reflect.Value, src dyn.Value) error {
+	switch src.Kind() {
+	case dyn.KindString:
+		// Ignore pure variable references (e.g. ${var.foo}).
+		if dynvar.IsPureVariableReference(src.MustString()) {
+			dst.SetZero()
+			return nil
+		}
+		// Use JSON unmarshaling since SDK native types implement json.Unmarshaler.
+		// Marshal the string to create a valid JSON string literal for unmarshaling.
+		jsonBytes, err := json.Marshal(src.MustString())
+		if err != nil {
+			return err
+		}
+		return json.Unmarshal(jsonBytes, dst.Addr().Interface())
+	case dyn.KindNil:
+		dst.SetZero()
+		return nil
+	default:
+		// Fall through to the error case.
+	}
+
+	return TypeError{
+		value: src,
+		msg:   fmt.Sprintf("expected a string, found a %s", src.Kind()),
+	}
+}