fix(persistence): return errors instead of silently skipping bad specs

Addressing review feedback on schema.go. driverTableSchema returned nil
(and UpdateDBSchema then skipped the table) when a spec had no schema, was
missing the driver's schema block, or the driver was unrecognized. Those
are all malformed inputs that should fail loudly rather than be silently
skipped.

- driverTableSchema now returns an error for a nil schema, a missing
  per-driver schema block, and an unsupported driver.
- UpdateDBSchema propagates that error, errors on a table spec with no
  name, and guards against a nil connection.
- Add unit tests covering the error paths.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: kriscoleman

pkg/persistence/schema.go

@@ -22,6 +22,9 @@ func UpdateDBSchema(driver string, uri string, schemaDir string) error {
 	if err != nil {
 		return errors.Wrapf(err, "failed to connect to %s", driver)
 	}
+	if conn == nil {
+		return errors.Errorf("no database connection returned for driver %q", driver)
+	}
 	defer conn.Close()
 
 	statements := []string{}
@@ -49,9 +52,13 @@ func UpdateDBSchema(driver string, uri string, schemaDir string) error {
 			return errors.Wrapf(err, "failed to unmarshal %s", path)
 		}
 
-		schema := driverTableSchema(driver, table.Spec.Schema)
-		if schema == nil {
-			return nil
+		if table.Spec.Name == "" {
+			return errors.Errorf("table spec %s has no name", path)
+		}
+
+		schema, err := driverTableSchema(driver, table.Spec.Schema)
+		if err != nil {
+			return errors.Wrapf(err, "failed to resolve %s schema for %s", driver, path)
 		}
 
 		stmnts, err := conn.PlanTableSchema(table.Spec.Name, schema, nil)
@@ -84,23 +91,23 @@ func connectSchemahero(driver string, uri string) (interfaces.SchemaHeroDatabase
 	}
 }
 
-func driverTableSchema(driver string, schema *schemasv1alpha4.TableSchema) any {
+func driverTableSchema(driver string, schema *schemasv1alpha4.TableSchema) (any, error) {
 	if schema == nil {
-		return nil
+		return nil, errors.New("table spec has no schema")
 	}
 
 	switch driver {
 	case "postgres":
 		if schema.Postgres == nil {
-			return nil
+			return nil, errors.New("table spec has no postgres schema")
 		}
-		return schema.Postgres
+		return schema.Postgres, nil
 	case "rqlite":
 		if schema.RQLite == nil {
-			return nil
+			return nil, errors.New("table spec has no rqlite schema")
 		}
-		return schema.RQLite
+		return schema.RQLite, nil
 	default:
-		return nil
+		return nil, errors.Errorf("unsupported schemahero driver %q", driver)
 	}
 }

pkg/persistence/schema_test.go

@@ -0,0 +1,80 @@
+package persistence
+
+import (
+	"testing"
+
+	schemasv1alpha4 "github.com/schemahero/schemahero/pkg/apis/schemas/v1alpha4"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_driverTableSchema(t *testing.T) {
+	pg := &schemasv1alpha4.PostgresqlTableSchema{}
+	rq := &schemasv1alpha4.RqliteTableSchema{}
+
+	tests := []struct {
+		name    string
+		driver  string
+		schema  *schemasv1alpha4.TableSchema
+		want    any
+		wantErr string
+	}{
+		{
+			name:   "postgres schema present",
+			driver: "postgres",
+			schema: &schemasv1alpha4.TableSchema{Postgres: pg},
+			want:   pg,
+		},
+		{
+			name:   "rqlite schema present",
+			driver: "rqlite",
+			schema: &schemasv1alpha4.TableSchema{RQLite: rq},
+			want:   rq,
+		},
+		{
+			name:    "nil schema is an error",
+			driver:  "rqlite",
+			schema:  nil,
+			wantErr: "no schema",
+		},
+		{
+			name:    "postgres driver without a postgres schema is an error",
+			driver:  "postgres",
+			schema:  &schemasv1alpha4.TableSchema{RQLite: rq},
+			wantErr: "no postgres schema",
+		},
+		{
+			name:    "rqlite driver without an rqlite schema is an error",
+			driver:  "rqlite",
+			schema:  &schemasv1alpha4.TableSchema{Postgres: pg},
+			wantErr: "no rqlite schema",
+		},
+		{
+			name:    "unsupported driver is an error",
+			driver:  "mysql",
+			schema:  &schemasv1alpha4.TableSchema{Postgres: pg},
+			wantErr: "unsupported schemahero driver",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := driverTableSchema(tt.driver, tt.schema)
+			if tt.wantErr != "" {
+				require.Error(t, err)
+				assert.Contains(t, err.Error(), tt.wantErr)
+				assert.Nil(t, got)
+				return
+			}
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
+
+func Test_connectSchemahero_unsupportedDriver(t *testing.T) {
+	conn, err := connectSchemahero("mysql", "")
+	require.Error(t, err)
+	assert.Nil(t, conn)
+	assert.Contains(t, err.Error(), "unsupported schemahero driver")
+}