feat: add AfterScanError for partial failure in List/ListPaged

Returns all records even when some AfterScan calls fail.
AfterScanError carries a map[int]error keyed by index and
implements Unwrap() []error for errors.Is transitivity.

Refs #43

Author: klaidliadon

table.go

@@ -17,14 +17,36 @@ type AfterScanner interface {
 	AfterScan() error
 }
 
+// AfterScanError is returned when one or more records fail AfterScan.
+// The Errors map is keyed by the record's index in the returned slice.
+type AfterScanError struct {
+	Errors map[int]error
+}
+
+func (e *AfterScanError) Error() string {
+	return fmt.Sprintf("after scan: %d error(s)", len(e.Errors))
+}
+
+func (e *AfterScanError) Unwrap() []error {
+	errs := make([]error, 0, len(e.Errors))
+	for _, err := range e.Errors {
+		errs = append(errs, err)
+	}
+	return errs
+}
+
 func afterScanAll[T any](records []T) error {
+	errs := make(map[int]error)
 	for i := range records {
 		if as, ok := any(records[i]).(AfterScanner); ok {
 			if err := as.AfterScan(); err != nil {
-				return fmt.Errorf("after scan: %w", err)
+				errs[i] = err
 			}
 		}
 	}
+	if len(errs) > 0 {
+		return &AfterScanError{Errors: errs}
+	}
 	return nil
 }
 
@@ -403,11 +425,7 @@ func (t *Table[T, P, I]) List(ctx context.Context, where sq.Sqlizer, orderBy []s
 	if err := t.Query.GetAll(ctx, q, &records); err != nil {
 		return nil, err
 	}
-	if err := afterScanAll(records); err != nil {
-		return nil, err
-	}
-
-	return records, nil
+	return records, afterScanAll(records)
 }
 
 // ListPaged returns paginated records matching the condition.
@@ -426,10 +444,7 @@ func (t *Table[T, P, I]) ListPaged(ctx context.Context, where sq.Sqlizer, page *
 		return nil, nil, err
 	}
 	result = t.Paginator.PrepareResult(result, page)
-	if err := afterScanAll(result); err != nil {
-		return nil, nil, err
-	}
-	return result, page, nil
+	return result, page, afterScanAll(result)
 }
 
 // Iter returns an iterator for records matching the condition.

tests/pgkit_test.go

@@ -4,6 +4,7 @@ import (
 	"bufio"
 	"bytes"
 	"context"
+	"errors"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -1154,9 +1155,10 @@ func TestAfterScan(t *testing.T) {
 	failTable := pgkit.Table[AccountWithFailingHook, *AccountWithFailingHook, int64]{DB: DB, Name: "accounts", IDColumn: "id"}
 	plainTable := pgkit.Table[Account, *Account, int64]{DB: DB, Name: "accounts", IDColumn: "id"}
 
-	// Seed data.
+	// Seed data: "alice" and "bob" succeed AfterScan, "fail" triggers error.
 	require.NoError(t, hookTable.Save(ctx, &AccountWithHook{Account: Account{Name: "alice"}}))
 	require.NoError(t, hookTable.Save(ctx, &AccountWithHook{Account: Account{Name: "bob"}}))
+	require.NoError(t, hookTable.Save(ctx, &AccountWithHook{Account: Account{Name: "fail"}}))
 
 	t.Run("Get", func(t *testing.T) {
 		acc, err := hookTable.Get(ctx, sq.Eq{"name": "alice"}, nil)
@@ -1167,9 +1169,10 @@ func TestAfterScan(t *testing.T) {
 	t.Run("List", func(t *testing.T) {
 		accs, err := hookTable.List(ctx, nil, []string{"name"})
 		require.NoError(t, err)
-		require.Len(t, accs, 2)
+		require.Len(t, accs, 3)
 		assert.Equal(t, "ALICE", accs[0].UpperName)
 		assert.Equal(t, "BOB", accs[1].UpperName)
+		assert.Equal(t, "FAIL", accs[2].UpperName)
 	})
 
 	t.Run("NoHook", func(t *testing.T) {
@@ -1179,12 +1182,32 @@ func TestAfterScan(t *testing.T) {
 		assert.Equal(t, "alice", acc.Name)
 	})
 
-	t.Run("ErrorPropagation", func(t *testing.T) {
-		_, err := failTable.Get(ctx, sq.Eq{"name": "alice"}, nil)
+	t.Run("GetErrorPropagation", func(t *testing.T) {
+		_, err := failTable.Get(ctx, sq.Eq{"name": "fail"}, nil)
 		require.ErrorContains(t, err, "after scan boom")
+	})
 
-		_, err = failTable.List(ctx, nil, nil)
-		require.ErrorContains(t, err, "after scan boom")
+	t.Run("ListPartialFailure", func(t *testing.T) {
+		// "alice" and "bob" succeed, "fail" fails — all three returned.
+		accs, err := failTable.List(ctx, nil, []string{"name"})
+		require.Error(t, err)
+		require.Len(t, accs, 3, "all records returned despite error")
+
+		var scanErr *pgkit.AfterScanError
+		require.True(t, errors.As(err, &scanErr))
+		require.Len(t, scanErr.Errors, 1)
+
+		// "fail" sorts to index 1 (alice=0, fail=1, bob would be... let me order: alice, bob, fail → index 2)
+		_, ok := scanErr.Errors[2]
+		assert.True(t, ok, "error keyed by index of failing record")
+	})
+
+	t.Run("UnwrapTransitive", func(t *testing.T) {
+		_, err := failTable.List(ctx, nil, []string{"name"})
+		require.Error(t, err)
+
+		// errors.Is works transitively via Unwrap() []error.
+		assert.True(t, errors.Is(err, errAfterScanBoom))
 	})
 }
 

tests/schema_test.go

@@ -131,12 +131,17 @@ func (a *AccountWithHook) AfterScan() error {
 
 func (a *AccountWithHook) DBTableName() string { return "accounts" }
 
+var errAfterScanBoom = fmt.Errorf("after scan boom")
+
 type AccountWithFailingHook struct {
 	Account
 }
 
 func (a *AccountWithFailingHook) AfterScan() error {
-	return fmt.Errorf("after scan boom")
+	if a.Name == "fail" {
+		return errAfterScanBoom
+	}
+	return nil
 }
 
 func (a *AccountWithFailingHook) DBTableName() string { return "accounts" }