feat: add IsSchemaQualified method to skip hint for schema-qualified types

Author: 7ttp

pkg/migration/file.go

@@ -26,7 +26,10 @@ type MigrationFile struct {
 	Statements []string
 }
 
-var migrateFilePattern = regexp.MustCompile(`^([0-9]+)_(.*)\.sql$`)
+var (
+	migrateFilePattern = regexp.MustCompile(`^([0-9]+)_(.*)\.sql$`)
+	typeNamePattern    = regexp.MustCompile(`type "([^"]+)" does not exist`)
+)
 
 func NewMigrationFromFile(path string, fsys fs.FS) (*MigrationFile, error) {
 	lines, err := parseFile(path, fsys)
@@ -97,17 +100,11 @@ func (m *MigrationFile) ExecBatch(ctx context.Context, conn *pgx.Conn) error {
 				msg = append(msg, pgErr.Detail)
 			}
 			// Provide helpful hint for extension type errors (SQLSTATE 42704: undefined_object)
-			if pgErr.Code == "42704" && strings.Contains(pgErr.Message, "type") && strings.Contains(pgErr.Message, "does not exist") {
-				// Extract type name from error message (e.g., 'type "ltree" does not exist')
-				typeName := extractTypeName(pgErr.Message)
+			if typeName := extractTypeName(pgErr.Message); len(typeName) > 0 && pgErr.Code == "42704" && !IsSchemaQualified(typeName) {
 				msg = append(msg, "")
 				msg = append(msg, "Hint: This type may be defined in a schema that's not in your search_path.")
 				msg = append(msg, "      Use schema-qualified type references to avoid this error:")
-				if typeName != "" {
-					msg = append(msg, fmt.Sprintf("        CREATE TABLE example (col extensions.%s);", typeName))
-				} else {
-					msg = append(msg, "        CREATE TABLE example (col extensions.<type_name>);")
-				}
+				msg = append(msg, fmt.Sprintf("        CREATE TABLE example (col extensions.%s);", typeName))
 				msg = append(msg, "      Learn more: supabase migration new --help")
 			}
 		}
@@ -137,15 +134,18 @@ func markError(stat string, pos int) string {
 // extractTypeName extracts the type name from PostgreSQL error messages like:
 // 'type "ltree" does not exist' -> "ltree"
 func extractTypeName(errMsg string) string {
-	// Match pattern: type "typename" does not exist
-	re := regexp.MustCompile(`type "([^"]+)" does not exist`)
-	matches := re.FindStringSubmatch(errMsg)
+	matches := typeNamePattern.FindStringSubmatch(errMsg)
 	if len(matches) > 1 {
 		return matches[1]
 	}
 	return ""
 }
 
+// IsSchemaQualified checks if a type name already contains a schema qualifier (e.g., "extensions.ltree")
+func IsSchemaQualified(typeName string) bool {
+	return strings.Contains(typeName, ".")
+}
+
 func (m *MigrationFile) insertVersionSQL(conn *pgx.Conn, batch *pgconn.Batch) error {
 	value := pgtype.TextArray{}
 	if err := value.Set(m.Statements); err != nil {

pkg/migration/file_test.go

@@ -100,24 +100,29 @@ func TestMigrationFile(t *testing.T) {
 		assert.ErrorContains(t, err, "At statement: 0")
 	})
 
-	t.Run("provides generic hint when type name cannot be extracted", func(t *testing.T) {
+	t.Run("skips hint for schema-qualified type errors", func(t *testing.T) {
 		migration := MigrationFile{
-			Statements: []string{"CREATE TABLE test (id custom_type)"},
+			Statements: []string{"CREATE TABLE test (path extensions.ltree NOT NULL)"},
 			Version:    "0",
 		}
 		// Setup mock postgres
 		conn := pgtest.NewConn()
 		defer conn.Close(t)
 		conn.Query(migration.Statements[0]).
-			ReplyError("42704", `type does not exist`).
+			ReplyError("42704", `type "extensions.ltree" does not exist`).
 			Query(INSERT_MIGRATION_VERSION, "0", "", migration.Statements).
 			Reply("INSERT 0 1")
 		// Run test
 		err := migration.ExecBatch(context.Background(), conn.MockClient(t))
-		// Check error
-		assert.ErrorContains(t, err, "type does not exist")
-		assert.ErrorContains(t, err, "Hint: This type may be defined in a schema")
-		assert.ErrorContains(t, err, "extensions.<type_name>")
-		assert.ErrorContains(t, err, "supabase migration new --help")
+		// Check error - should NOT contain hint since type is already schema-qualified
+		assert.ErrorContains(t, err, `type "extensions.ltree" does not exist`)
+		assert.NotContains(t, err.Error(), "Hint: This type may be defined in a schema")
 	})
 }
+
+func TestIsSchemaQualified(t *testing.T) {
+	assert.True(t, IsSchemaQualified("extensions.ltree"))
+	assert.True(t, IsSchemaQualified("public.my_type"))
+	assert.False(t, IsSchemaQualified("ltree"))
+	assert.False(t, IsSchemaQualified(""))
+}