Rename field to reflect their meaning, document breaking changes

Author: AndrianBdn

BREAKING.md

@@ -0,0 +1,114 @@
+# Breaking Changes
+
+## Version 1.6 (Upcoming)
+
+### libdns 1.0 Compatibility
+
+Version 1.6 requires **libdns v1.0** or later. The libdns v1.0 release introduced typed record structs that replace the generic `libdns.Record` type. This is a fundamental change to the libdns API.
+
+#### What Changed in libdns 1.0
+
+- **Typed Records**: Instead of using generic `libdns.Record` structs, libdns v1.0 introduced typed record implementations like `libdns.Address`, `libdns.TXT`, `libdns.SRV`, etc.
+- **Parse() Method**: The new `Record` interface includes a `Parse()` method that returns typed structs
+- **RR() Method**: All record types implement `RR()` to get the underlying resource record data
+
+#### Migration for libdns 1.0
+
+See the [libdns documentation](https://pkg.go.dev/github.com/libdns/libdns) for complete details on migrating to typed records.
+
+Example of the new API:
+```go
+// Old (libdns <1.0)
+records := []libdns.Record{
+    {
+        Type:  "A",
+        Name:  "www",
+        Value: "1.2.3.4",
+        TTL:   300 * time.Second,
+    },
+}
+
+// New (libdns >=1.0)
+records := []libdns.Record{
+    libdns.Address{
+        Name:  "www",
+        Value: netip.MustParseAddr("1.2.3.4"),
+        TTL:   300 * time.Second,
+    },
+}
+```
+
+### Field Renames
+
+Two provider configuration fields have been renamed for clarity:
+
+#### 1. `MaxWaitDur` → `Route53MaxWait`
+
+**Old (pre-v1.6):**
+```go
+provider := &route53.Provider{
+    MaxWaitDur: 60,  // Was treated as seconds (multiplied by time.Second internally)
+}
+```
+
+**New (v1.6+):**
+```go
+provider := &route53.Provider{
+    Route53MaxWait: 60 * time.Second,  // Use proper time.Duration
+}
+```
+
+**Important:** In versions before v1.6, `MaxWaitDur` was silently multiplied by `time.Second` in the provider's init function. This was non-idiomatic Go and has been fixed. You must now provide a proper `time.Duration` value (like `60 * time.Second` or `2 * time.Minute`), as is standard in Go.
+
+**Failure to multiply by `time.Second` will result in a 60-nanosecond timeout instead of 60 seconds!**
+
+**Rationale:** The new name clearly indicates this is a Route53-specific timeout for AWS internal propagation, not general DNS propagation.
+
+#### 2. `WaitForPropagation` → `WaitForRoute53Sync`
+
+**Old (pre-v1.6):**
+```go
+provider := &route53.Provider{
+    WaitForPropagation: true,
+}
+```
+
+**New (v1.6+):**
+```go
+provider := &route53.Provider{
+    WaitForRoute53Sync: true,
+}
+```
+
+**Rationale:** The new name clearly indicates this waits for Route53's internal synchronization, not worldwide DNS propagation (which can take hours depending on TTL values).
+
+### JSON Configuration
+
+If you're using JSON configuration, update your field names:
+
+**Old (pre-v1.6):**
+```json
+{
+  "max_wait_dur": 60,
+  "wait_for_propagation": true
+}
+```
+
+**New (v1.6+):**
+```json
+{
+  "route53_max_wait": "2m",
+  "wait_for_route53_sync": true
+}
+```
+
+Note: The old `max_wait_dur` field accepted a numeric value (seconds), while the new `route53_max_wait` field uses standard Go duration strings like `"2m"`, `"120s"`, etc.
+
+## Migration Checklist
+
+- [ ] Update to libdns v1.0+ (see libdns documentation for typed records)
+- [ ] Rename `MaxWaitDur` to `Route53MaxWait` in your code
+- [ ] Change from plain integer (e.g., `60`) to proper `time.Duration` (e.g., `60 * time.Second`)
+- [ ] Rename `WaitForPropagation` to `WaitForRoute53Sync` in your code
+- [ ] Update JSON/YAML configuration files with new field names
+- [ ] Test your code thoroughly after migration

README.md

@@ -3,6 +3,9 @@ Route53 for `libdns`
 
 [![godoc reference](https://img.shields.io/badge/godoc-reference-blue.svg)](https://pkg.go.dev/github.com/libdns/route53)
 
+> [!WARNING]
+> **Breaking changes in v1.6:** Field names have changed. See [BREAKING.md](BREAKING.md) for migration guide.
+
 This package implements the [libdns interfaces](https://github.com/libdns/libdns) for AWS [Route53](https://aws.amazon.com/route53/).
 
 ## Example
@@ -104,7 +107,7 @@ For more information, see the [AWS EC2 Instance Metadata Options documentation](
 
 ## Note on propagation-related fields
 
-When you update records in AWS Route53, changes first propagate internally across AWS’s DNS servers before becoming visible to the public. This internal step usually finishes within seconds, but may take more in rare cases, and can be waited on when `WaitForPropagation` is enabled. *It is different from normal DNS propagation, which depends on TTL and external caching.*
+When you update records in AWS Route53, changes first propagate internally across AWS's DNS servers before becoming visible to the public. This internal step usually finishes within seconds, but may take more in rare cases, and can be waited on when `WaitForRoute53Sync` is enabled. *It is different from normal DNS propagation, which depends on TTL and external caching.*
 
 See [Change Propagation to Route 53 DNS Servers](https://docs.aws.amazon.com/Route53/latest/APIReference/API_ChangeResourceRecordSets.html#API_ChangeResourceRecordSets_RequestSyntax:~:text=Change%20Propagation%20to%20Route%2053%20DNS%20Servers).
 

client.go

@@ -92,8 +92,8 @@ func (p *Provider) init(ctx context.Context) {
 		p.MaxRetries = 5
 	}
 
-	if p.MaxWaitDuration == 0 {
-		p.MaxWaitDuration = time.Minute
+	if p.Route53MaxWait == 0 {
+		p.Route53MaxWait = time.Minute
 	}
 
 	opts := make([]func(*config.LoadOptions) error, 0)
@@ -393,14 +393,14 @@ func (p *Provider) applyChange(ctx context.Context, input *r53.ChangeResourceRec
 	}
 
 	// Waiting for propagation if it's set in the provider config.
-	if p.WaitForPropagation {
+	if p.WaitForRoute53Sync {
 		changeInput := &r53.GetChangeInput{
 			Id: changeResult.ChangeInfo.Id,
 		}
 
 		// Wait for the RecordSetChange status to be "INSYNC"
 		waiter := r53.NewResourceRecordSetsChangedWaiter(p.client)
-		err = waiter.Wait(ctx, changeInput, p.MaxWaitDuration)
+		err = waiter.Wait(ctx, changeInput, p.Route53MaxWait)
 		if err != nil {
 			return err
 		}

client_test.go

@@ -362,7 +362,7 @@ func TestMarshalRecord(t *testing.T) {
 	}
 }
 
-func TestMaxWaitDur(t *testing.T) {
+func TestRoute53MaxWait(t *testing.T) {
 	cases := []struct {
 		name     string
 		input    time.Duration
@@ -382,9 +382,9 @@ func TestMaxWaitDur(t *testing.T) {
 
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {
-			provider := Provider{MaxWaitDuration: c.input}
+			provider := Provider{Route53MaxWait: c.input}
 			provider.init(context.TODO())
-			actual := provider.MaxWaitDuration
+			actual := provider.Route53MaxWait
 			if actual != c.expected {
 				t.Errorf("expected %d, got %d", c.expected, actual)
 			}

provider.go

@@ -39,14 +39,14 @@ type Provider struct {
 	// fails. If not set, it will use 5 retries.
 	MaxRetries int `json:"max_retries,omitempty"`
 
-	// MaxWaitDuration is the maximum amount of time to wait for a record
+	// Route53MaxWait is the maximum amount of time to wait for a record
 	// to be propagated within AWS infrastructure. Default is 1 minute.
-	MaxWaitDuration time.Duration `json:"max_wait_duration,omitempty"`
+	Route53MaxWait time.Duration `json:"route53_max_wait,omitempty"`
 
-	// WaitForPropagation if set to true, it will wait for the record to be
+	// WaitForRoute53Sync if set to true, it will wait for the record to be
 	// propagated within AWS infrastructure before returning. This is not related
 	// to DNS propagation, that could take much longer.
-	WaitForPropagation bool `json:"wait_for_propagation,omitempty"`
+	WaitForRoute53Sync bool `json:"wait_for_route53_sync,omitempty"`
 
 	// HostedZoneID is the ID of the hosted zone to use. If not set, it will
 	// be discovered from the zone name.