Document plain config fields

Go SDK docs now show ordinary config structs, Defaults(), and
Constraints() instead of cfg value field types.

Author: rjosephwright

docs/go-sdk/configuration.md

@@ -4,52 +4,65 @@ A Go library can declare configuration that applies to every node under an impor
 
 ```go
 type Configuration struct {
-    Region cfg.String
-    Prefix *cfg.String
+    Region      string
+    Prefix      string
+    MaxAttempts int64 `ub:"max-attempts"`
+}
+
+func (c Configuration) Defaults() []defaults.Default {
+    return []defaults.Default{
+        defaults.Value(c.Prefix, ""),
+        defaults.Value(c.MaxAttempts, int64(3)),
+    }
+}
+
+func (c Configuration) Constraints() []constraint.Constraint {
+    return []constraint.Constraint{
+        constraint.Must(constraint.NotEmpty(c.Region)).Message("region is required"),
+        constraint.Must(constraint.AtLeast(c.MaxAttempts, 1)).
+            Message("max-attempts must be positive"),
+    }
 }
 
 func Library() *runtime.Library {
     return &runtime.Library{
         Name: "cloud",
         Configuration: &cfg.ConfigurationType[*Configuration]{
             Description: "Cloud connection settings.",
-            New: func() *Configuration {
-                return &Configuration{
-                    Prefix: &cfg.String{Default: ""},
-                }
-            },
+            New:         func() *Configuration { return &Configuration{} },
         },
     }
 }
 ```
 
 Use `runtime.NoConfig` as the config type parameter when a library has no configuration.
 
-## Wrapper types
+## Field model
 
-Configuration structs use wrapper types from `pkg/sdk/cfg`:
+Configuration structs use the same ordinary Go field model as resource, data source,
+and action input structs:
 
-- `cfg.String`
-- `cfg.Integer`
-- `cfg.Number`
-- `cfg.Boolean`
-- `cfg.Null`
-- `cfg.Any`
-- `cfg.List[T]`
-- `cfg.Map[T]`
-- `cfg.Object[T]`
+- `string`, `bool`, `int64`, `float64`, and `any` map to UB scalar types.
+- `[]T` maps to `list(T)`.
+- `map[string]T` maps to `map(T)`.
+- Nested structs map to UB objects.
+- `*T` makes a field optional.
+- `ub:"name"` changes the UB field name.
+- `ub:"-"` omits a Go field from the UB schema.
 
-A pointer field makes a nested value optional. Wrapper fields can set descriptions, defaults, and validators.
+Use `Defaults()` for non-pointer fields that may be omitted. Use `Constraints()`
+for config validation. Defaults are applied before constraints and before the
+decoded config reaches resources, data sources, actions, or functions.
 
 ## Source use
 
 A factory input can use the configuration schema:
 
-```
+```ub
 inputs: {
   cloud: {
     type: library-config('github.com/example/cloud')
-    default: {}
+    default: { region: 'us-west-2' }
   }
 }
 
@@ -60,4 +73,5 @@ library-configs: {
 }
 ```
 
-Every resource, data source, action, and function under the `cloud` alias receives that config type at runtime.
+Every resource, data source, action, and function under the `cloud` alias receives
+that config type at runtime.

docs/go-sdk/schemas-constraints-defaults.md

@@ -1,10 +1,12 @@
 # Schemas, constraints, defaults
 
-The compiler reads Go library source to derive input schemas, output fields, constraints, and defaults.
+The compiler reads Go library source to derive input schemas, configuration schemas,
+output fields, constraints, and defaults.
 
 ## Struct fields
 
-Input structs become UB object fields. Field names use kebab case by default, and `ub` tags can set the UB name:
+Input and configuration structs become UB object fields. Field names use kebab case by
+default, and `ub` tags can set the UB name:
 
 ```go
 type File struct {
@@ -14,7 +16,9 @@ type File struct {
 }
 ```
 
-Pointer fields are optional. Output structs use the same field naming rules. An output field can be marked sensitive:
+Pointer fields are optional. For non-pointer fields that may be omitted, declare
+`Defaults()` with `defaults.Value` or `defaults.Optional`. Output structs use the same
+field naming rules. An output field can be marked sensitive:
 
 ```go
 type SecretOutput struct {
@@ -36,7 +40,9 @@ func (f File) Defaults() []defaults.Default {
 }
 ```
 
-`defaults.Value` fills a value before the type's runtime method runs. `defaults.Optional` says the field may be omitted and the zero value is acceptable.
+`defaults.Value` fills a value before the type's runtime method runs.
+`defaults.Optional` says the field may be omitted and the zero value is acceptable.
+The same defaults method model applies to library configuration structs.
 
 ## Constraints
 
@@ -51,10 +57,16 @@ func (f File) Constraints() []constraint.Constraint {
 }
 ```
 
-Set constraints include `ExactlyOneOf`, `AtLeastOneOf`, `AtMostOneOf`, `RequiredTogether`, `RequiredWith`, and `ForbiddenWith`. Predicate constraints use `Must` or `When(...).Require(...)`.
+Set constraints include `ExactlyOneOf`, `AtLeastOneOf`, `AtMostOneOf`,
+`RequiredTogether`, `RequiredWith`, and `ForbiddenWith`. Predicate constraints use
+`Must` or `When(...).Require(...)`. Library configuration structs use the same
+constraints method model.
 
 ## Check timing
 
-Deep schema and constraint checks happen at compile time when the source and selected libraries are known. The compiled factory trusts those checks and decodes runtime values into the registered Go types.
+Deep schema and constraint checks happen at compile time when the source and selected
+libraries are known. The compiled factory trusts those checks and decodes runtime
+values into the registered Go types.
 
-For checks that need live configuration or external state, a resource can also implement `runtime.InputValidator`; see [Resources](resources.md#apply-time-input-validation).
+For checks that need live configuration or external state, a resource can also implement
+`runtime.InputValidator`; see [Resources](resources.md#apply-time-input-validation).