Add a way to skip wait for R53 sync on delete; documentation update

Author: AndrianBdn

BREAKING.md

@@ -1,6 +1,6 @@
 # Breaking Changes
 
-## Version 1.6 (Upcoming)
+## Version 1.6
 
 ### libdns 1.0 Compatibility
 
@@ -82,33 +82,38 @@ provider := &route53.Provider{
 
 **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
+### Removed Deprecated Fields
 
-If you're using JSON configuration, update your field names:
+Two deprecated fields have been removed in v1.6:
 
-**Old (pre-v1.6):**
-```json
-{
-  "max_wait_dur": 60,
-  "wait_for_propagation": true
+- **`AWSProfile`** → Use `Profile` instead
+- **`Token`** → Use `SessionToken` instead
+
+These fields were deprecated several versions ago and have identical functionality to their replacements.
+
+```go
+// Old (removed in v1.6)
+provider := &route53.Provider{
+    AWSProfile: "my-profile",
+    Token:      "my-session-token",
 }
-```
 
-**New (v1.6+):**
-```json
-{
-  "route53_max_wait": "2m",
-  "wait_for_route53_sync": true
+// New (v1.6+)
+provider := &route53.Provider{
+    Profile:      "my-profile",
+    SessionToken: "my-session-token",
 }
 ```
 
-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.
+**JSON Configuration:** If using JSON config, update field names: `aws_profile` → `profile`, `token` → `session_token`
 
 ## 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
+- [ ] Replace `AWSProfile` with `Profile` (if using)
+- [ ] Replace `Token` with `SessionToken` (if using)
 - [ ] Update JSON/YAML configuration files with new field names
 - [ ] Test your code thoroughly after migration

README.md

@@ -111,6 +111,19 @@ When you update records in AWS Route53, changes first propagate internally acros
 
 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).
 
+### Performance optimization for delete operations
+
+By default, when `WaitForRoute53Sync` is enabled, the provider waits for synchronization on all operations, including deletes. For bulk delete operations where immediate consistency is not required, you can skip the wait on deletes by setting `SkipRoute53SyncOnDelete` to `true`:
+
+```go
+provider := &route53.Provider{
+    WaitForRoute53Sync:       true,  // Wait for sync on create/update
+    SkipRoute53SyncOnDelete:  true,  // Skip wait on delete for better performance
+}
+```
+
+This can significantly speed up bulk delete operations while still maintaining consistency guarantees for create and update operations.
+
 ## Contributing
 
 Contributions are welcome! Please ensure that:

client.go

@@ -17,6 +17,12 @@ import (
 	"github.com/libdns/libdns"
 )
 
+type contextKey int
+
+const (
+	contextKeyIsDeleteOperation contextKey = iota
+)
+
 const (
 	// defaultTTL is the default TTL for DNS records in seconds.
 	defaultTTL = 300
@@ -392,8 +398,17 @@ func (p *Provider) applyChange(ctx context.Context, input *r53.ChangeResourceRec
 		return err
 	}
 
-	// Waiting for propagation if it's set in the provider config.
-	if p.WaitForRoute53Sync {
+	// Check if we should skip waiting for synchronization
+	shouldWait := p.WaitForRoute53Sync
+	if shouldWait && p.SkipRoute53SyncOnDelete {
+		// Check if this is a delete operation
+		if isDelete, ok := ctx.Value(contextKeyIsDeleteOperation).(bool); ok && isDelete {
+			shouldWait = false
+		}
+	}
+
+	// Wait for propagation if enabled and not skipped
+	if shouldWait {
 		changeInput := &r53.GetChangeInput{
 			Id: changeResult.ChangeInfo.Id,
 		}

libdnstest/route53_test.go

@@ -1,24 +1,28 @@
 package route53_libdnstest_test
 
 import (
+	"context"
+	"net/netip"
 	"os"
 	"strings"
 	"testing"
+	"time"
 
+	"github.com/libdns/libdns"
 	"github.com/libdns/libdns/libdnstest"
 	"github.com/libdns/route53"
 )
 
 func TestRoute53Provider(t *testing.T) {
-	// Get credentials from environment
+	// get credentials from environment
 	accessKeyId := os.Getenv("AWS_ACCESS_KEY_ID")
 	secretAccessKey := os.Getenv("AWS_SECRET_ACCESS_KEY")
 	sessionToken := os.Getenv("AWS_SESSION_TOKEN")
 	region := os.Getenv("AWS_REGION")
 	profile := os.Getenv("AWS_PROFILE")
 	testZone := os.Getenv("ROUTE53_TEST_ZONE")
 
-	// Check required environment variables
+	// check required environment variables
 	if testZone == "" {
 		t.Skip("Skipping Route53 provider tests: ROUTE53_TEST_ZONE environment variable must be set")
 	}
@@ -27,7 +31,7 @@ func TestRoute53Provider(t *testing.T) {
 		t.Fatal("We expect the test zone to have trailing dot")
 	}
 
-	// Create provider with available credentials
+	// create provider with available credentials
 	provider := &route53.Provider{
 		Region:          region,
 		Profile:         profile,
@@ -38,4 +42,75 @@ func TestRoute53Provider(t *testing.T) {
 
 	suite := libdnstest.NewTestSuite(libdnstest.WrapNoZoneLister(provider), testZone)
 	suite.RunTests(t)
-}
+}
+
+func TestSkipRoute53SyncOnDelete_Performance(t *testing.T) {
+	// get credentials from environment
+	accessKeyId := os.Getenv("AWS_ACCESS_KEY_ID")
+	secretAccessKey := os.Getenv("AWS_SECRET_ACCESS_KEY")
+	sessionToken := os.Getenv("AWS_SESSION_TOKEN")
+	region := os.Getenv("AWS_REGION")
+	profile := os.Getenv("AWS_PROFILE")
+	testZone := os.Getenv("ROUTE53_TEST_ZONE")
+
+	// check required environment variables
+	if testZone == "" {
+		t.Skip("Skipping Route53 provider tests: ROUTE53_TEST_ZONE environment variable must be set")
+	}
+
+	if !strings.HasSuffix(testZone, ".") {
+		t.Fatal("We expect the test zone to have trailing dot")
+	}
+
+	// create provider with waiting enabled but skip on delete operations
+	provider := &route53.Provider{
+		Region:                  region,
+		Profile:                 profile,
+		AccessKeyId:             accessKeyId,
+		SecretAccessKey:         secretAccessKey,
+		SessionToken:            sessionToken,
+		WaitForRoute53Sync:      true,
+		SkipRoute53SyncOnDelete: true,
+	}
+
+	ctx := context.Background()
+	testRecord := &libdns.Address{
+		Name: "test-append-record-r53-sync",
+		TTL:  300 * time.Second,
+		IP:   netip.MustParseAddr("192.0.2.1"),
+	}
+
+	// clean up first - delete the record if it exists (fast because we skip sync on delete)
+	t.Log("Cleaning up any existing test record...")
+	_, _ = provider.DeleteRecords(ctx, testZone, []libdns.Record{testRecord})
+
+	// append the record - this should take longer because we wait for sync
+	t.Log("Appending record with WaitForRoute53Sync=true (should be slow)...")
+	appendStart := time.Now()
+	_, err := provider.AppendRecords(ctx, testZone, []libdns.Record{testRecord})
+	appendDuration := time.Since(appendStart)
+	if err != nil {
+		t.Fatalf("Failed to append record: %v", err)
+	}
+	t.Logf("Append took %v", appendDuration)
+
+	// delete the record - this should be fast because we skip sync on delete
+	t.Log("Deleting record with SkipRoute53SyncOnDelete=true (should be fast)...")
+	deleteStart := time.Now()
+	_, err = provider.DeleteRecords(ctx, testZone, []libdns.Record{testRecord})
+	deleteDuration := time.Since(deleteStart)
+	if err != nil {
+		t.Fatalf("Failed to delete record: %v", err)
+	}
+	t.Logf("Delete took %v", deleteDuration)
+
+	// verify that delete was significantly faster than append
+	// append should wait for sync (typically 5-60 seconds)
+	// delete should skip sync (typically <2 seconds)
+	t.Logf("Performance comparison: append=%v, delete=%v, ratio=%.2fx",
+		appendDuration, deleteDuration, float64(appendDuration)/float64(deleteDuration))
+
+	if deleteDuration >= appendDuration {
+		t.Errorf("Delete operation took longer than append, expected delete to be faster due to SkipRoute53SyncOnDelete")
+	}
+}

provider.go

@@ -48,6 +48,11 @@ type Provider struct {
 	// to DNS propagation, that could take much longer.
 	WaitForRoute53Sync bool `json:"wait_for_route53_sync,omitempty"`
 
+	// SkipRoute53SyncOnDelete if set to true, it will skip waiting for Route53
+	// synchronization when deleting records, even if WaitForRoute53Sync is true.
+	// This can speed up bulk delete operations where waiting is not necessary.
+	SkipRoute53SyncOnDelete bool `json:"skip_route53_sync_on_delete,omitempty"`
+
 	// HostedZoneID is the ID of the hosted zone to use. If not set, it will
 	// be discovered from the zone name.
 	//
@@ -161,6 +166,9 @@ type recordSetKey struct {
 func (p *Provider) DeleteRecords(ctx context.Context, zone string, records []libdns.Record) ([]libdns.Record, error) {
 	p.init(ctx)
 
+	// mark this context as a delete operation
+	ctx = context.WithValue(ctx, contextKeyIsDeleteOperation, true)
+
 	zoneID, err := p.getZoneID(ctx, zone)
 	if err != nil {
 		return nil, err