fix: Fail on unknown PostgreSQL types instead of defaulting to string (fixes #30) (#72)

Changes:
- Added explicit support for UUID, INET, CIDR, MACADDR, XML, MONEY, TSVECTOR, TSQUERY
- Unknown PostgreSQL types now return found=false instead of silently becoming strings
- Prevents silent type mismatches and incorrect SQL generation
- Added comprehensive tests for all newly supported types
- Updated CLAUDE.md with complete PostgreSQL type mapping documentation

Breaking Change: Code using unsupported PostgreSQL types will now fail at type
provider creation instead of silently converting to string. This provides better
type safety and prevents hard-to-debug SQL generation issues.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude <noreply@anthropic.com>

Author: richardwooding

CLAUDE.md

@@ -77,15 +77,36 @@ go test -v -run TestFunctionName ./...
 
 The library uses CEL's protobuf-based type system (`exprpb.Type`, `exprpb.Expr`). PostgreSQL types are mapped to CEL types through `pg.TypeProvider`:
 
-- `text` → `decls.String`
-- `bigint` / `integer` → `decls.Int`
-- `boolean` → `decls.Bool`
-- `double precision` → `decls.Double`
-- `timestamp with time zone` → `decls.Timestamp`
-- `json` / `jsonb` → `decls.String` (with automatic JSON path support)
+**Text and String Types:**
+- `text`, `varchar`, `char`, `character varying`, `character` → `decls.String`
+- `xml` → `decls.String`
+- `inet`, `cidr` → `decls.String` (network addresses)
+- `macaddr`, `macaddr8` → `decls.String` (MAC addresses)
+- `tsvector`, `tsquery` → `decls.String` (full-text search)
+
+**Numeric Types:**
+- `bigint`, `integer`, `int`, `int4`, `int8`, `smallint`, `int2` → `decls.Int`
+- `double precision`, `real`, `float4`, `float8`, `numeric`, `decimal` → `decls.Double`
+- `money` → `decls.Double`
+
+**Boolean and Binary:**
+- `boolean`, `bool` → `decls.Bool`
+- `bytea` → `decls.Bytes`
+- `uuid` → `decls.Bytes`
+
+**Temporal Types:**
+- `timestamp`, `timestamptz`, `timestamp with time zone`, `timestamp without time zone` → `decls.Timestamp`
+- `date` → `sqltypes.Date`
+- `time`, `timetz`, `time with time zone`, `time without time zone` → `sqltypes.Time`
+
+**Structured Types:**
+- `json`, `jsonb` → `decls.Dyn` (with automatic JSON path support)
 - Arrays: Set `Repeated: true` in schema
 - Composite types: Use nested `Schema` fields
 
+**Unsupported Types:**
+Unknown PostgreSQL types (e.g., `point`, `polygon`, `box`, custom enums) will cause `FindStructFieldType()` to return `found=false`. This prevents silent type mismatches. Add explicit support for custom types or use composite type definitions.
+
 ### JSON/JSONB Support
 
 CEL field access on JSON/JSONB columns automatically converts to PostgreSQL JSON path operations:

pg/provider.go

@@ -265,13 +265,33 @@ func (p *typeProvider) FindStructFieldType(structType, fieldName string) (*types
 	case "json", "jsonb":
 		// JSON and JSONB types are treated as dynamic objects in CEL
 		exprType = decls.Dyn
+	case "uuid":
+		// UUID is represented as bytes for proper type handling
+		exprType = decls.Bytes
+	case "inet", "cidr":
+		// Network address types are represented as strings
+		// Note: Limited CEL operations available (equality, comparison)
+		exprType = decls.String
+	case "macaddr", "macaddr8":
+		// MAC address types are represented as strings
+		exprType = decls.String
+	case "xml":
+		// XML data is represented as string
+		exprType = decls.String
+	case "money":
+		// Money type is represented as double for numeric operations
+		exprType = decls.Double
+	case "tsvector", "tsquery":
+		// Full-text search types are represented as strings
+		exprType = decls.String
 	default:
 		// Handle composite types
 		if strings.Contains(field.Type, "composite") || len(field.Schema) > 0 {
 			exprType = decls.NewObjectType(strings.Join([]string{structType, fieldName}, "."))
 		} else {
-			// Default to string for unknown types
-			exprType = decls.String
+			// Unknown type - return not found instead of defaulting to string
+			// This prevents silent type mismatches and incorrect SQL generation
+			return nil, false
 		}
 	}
 

pg/provider_test.go

@@ -236,3 +236,110 @@ func Test_typeProvider_FindStructFieldType(t *testing.T) {
 		})
 	}
 }
+
+func Test_typeProvider_PostgreSQLTypes(t *testing.T) {
+	tests := []struct {
+		name      string
+		pgType    string
+		repeated  bool
+		wantType  *types.Type
+		wantFound bool
+	}{
+		{
+			name:      "uuid",
+			pgType:    "uuid",
+			wantType:  types.BytesType,
+			wantFound: true,
+		},
+		{
+			name:      "uuid array",
+			pgType:    "uuid",
+			repeated:  true,
+			wantType:  types.NewListType(types.BytesType),
+			wantFound: true,
+		},
+		{
+			name:      "inet",
+			pgType:    "inet",
+			wantType:  types.StringType,
+			wantFound: true,
+		},
+		{
+			name:      "cidr",
+			pgType:    "cidr",
+			wantType:  types.StringType,
+			wantFound: true,
+		},
+		{
+			name:      "macaddr",
+			pgType:    "macaddr",
+			wantType:  types.StringType,
+			wantFound: true,
+		},
+		{
+			name:      "macaddr8",
+			pgType:    "macaddr8",
+			wantType:  types.StringType,
+			wantFound: true,
+		},
+		{
+			name:      "xml",
+			pgType:    "xml",
+			wantType:  types.StringType,
+			wantFound: true,
+		},
+		{
+			name:      "money",
+			pgType:    "money",
+			wantType:  types.DoubleType,
+			wantFound: true,
+		},
+		{
+			name:      "tsvector",
+			pgType:    "tsvector",
+			wantType:  types.StringType,
+			wantFound: true,
+		},
+		{
+			name:      "tsquery",
+			pgType:    "tsquery",
+			wantType:  types.StringType,
+			wantFound: true,
+		},
+		{
+			name:      "unknown_type returns false",
+			pgType:    "unknown_custom_type",
+			wantFound: false,
+		},
+		{
+			name:      "point returns false",
+			pgType:    "point",
+			wantFound: false,
+		},
+		{
+			name:      "polygon returns false",
+			pgType:    "polygon",
+			wantFound: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			schema := pg.Schema{
+				{Name: "test_field", Type: tt.pgType, Repeated: tt.repeated},
+			}
+			typeProvider := pg.NewTypeProvider(map[string]pg.Schema{
+				"test_table": schema,
+			})
+
+			got, gotFound := typeProvider.FindStructFieldType("test_table", "test_field")
+			assert.Equal(t, tt.wantFound, gotFound)
+			if tt.wantFound {
+				assert.NotNil(t, got)
+				assert.Equal(t, tt.wantType, got.Type)
+			} else {
+				assert.Nil(t, got)
+			}
+		})
+	}
+}