HYPERFLEET-1152 - feat: separate resource_conditions table for generic resources

pkg/api/presenters/resource.go

@@ -71,7 +71,7 @@ func PresentResource(r *api.Resource) openapi.Resource {
 		UpdatedBy:   openapi_types.Email(r.UpdatedBy),
 		DeletedTime: r.DeletedTime,
 		Status: openapi.ResourceStatus{
-			Conditions: []openapi.ResourceCondition{},
+			Conditions: presentResourceConditions(r.Conditions),
 		},
 	}
 
@@ -109,6 +109,26 @@ func PresentResourceList(resources api.ResourceList, paging *api.PagingMeta) ope
 	}
 }
 
+func presentResourceConditions(conditions []api.ResourceCondition) []openapi.ResourceCondition {
+	if len(conditions) == 0 {
+		return []openapi.ResourceCondition{}
+	}
+	result := make([]openapi.ResourceCondition, len(conditions))
+	for i, c := range conditions {
+		result[i] = openapi.ResourceCondition{
+			Type:               c.Type,
+			Status:             openapi.ResourceConditionStatus(c.Status),
+			Reason:             c.Reason,
+			Message:            c.Message,
+			ObservedGeneration: c.ObservedGeneration,
+			CreatedTime:        c.CreatedTime,
+			LastUpdatedTime:    c.LastUpdatedTime,
+			LastTransitionTime: c.LastTransitionTime,
+		}
+	}
+	return result
+}
+
 func marshalLabels(labels *map[string]string) (datatypes.JSON, error) {
 	if labels == nil {
 		return datatypes.JSON("{}"), nil

pkg/api/presenters/resource_test.go

@@ -155,6 +155,68 @@ func TestPresentResource_EmptySpec(t *testing.T) {
 	Expect(resp.Spec).To(BeEmpty())
 }
 
+func TestPresentResource_WithConditions(t *testing.T) {
+	RegisterTestingT(t)
+
+	now := time.Now().Truncate(time.Microsecond)
+	reason := "AllAdaptersReporting"
+	message := "All adapters are available"
+	resource := &api.Resource{
+		Meta:      api.Meta{ID: "cond-id", CreatedTime: now, UpdatedTime: now},
+		Kind:      "Channel",
+		Name:      "test",
+		Spec:      datatypes.JSON(`{}`),
+		CreatedBy: "user@test.com",
+		UpdatedBy: "user@test.com",
+		Conditions: []api.ResourceCondition{
+			{
+				Type:               "Available",
+				Status:             api.ConditionTrue,
+				Reason:             &reason,
+				Message:            &message,
+				ObservedGeneration: 3,
+				CreatedTime:        now,
+				LastUpdatedTime:    now,
+				LastTransitionTime: now,
+			},
+		},
+	}
+
+	resp := PresentResource(resource)
+	Expect(resp.Status.Conditions).To(HaveLen(1))
+
+	cond := resp.Status.Conditions[0]
+	Expect(cond.Type).To(Equal("Available"))
+	Expect(cond.Status).To(Equal(openapi.ResourceConditionStatusTrue))
+	Expect(*cond.Reason).To(Equal("AllAdaptersReporting"))
+	Expect(*cond.Message).To(Equal("All adapters are available"))
+	Expect(cond.ObservedGeneration).To(Equal(int32(3)))
+	Expect(cond.CreatedTime).To(BeTemporally("==", now))
+	Expect(cond.LastTransitionTime).To(BeTemporally("==", now))
+}
+
+func TestPresentResource_WithEmptyConditions(t *testing.T) {
+	RegisterTestingT(t)
+
+	now := time.Now()
+	resource := &api.Resource{
+		Meta:       api.Meta{ID: "empty-cond-id", CreatedTime: now, UpdatedTime: now},
+		Kind:       "Channel",
+		Name:       "test",
+		Spec:       datatypes.JSON(`{}`),
+		CreatedBy:  "user@test.com",
+		UpdatedBy:  "user@test.com",
+		Conditions: []api.ResourceCondition{},
+	}
+
+	resp := PresentResource(resource)
+	body, err := json.Marshal(resp)
+	Expect(err).NotTo(HaveOccurred())
+	Expect(resp.Status.Conditions).NotTo(BeNil())
+	Expect(resp.Status.Conditions).To(BeEmpty())
+	Expect(string(body)).To(ContainSubstring(`"status":{"conditions":[]}`))
+}
+
 func TestPresentResourceList(t *testing.T) {
 	RegisterTestingT(t)
 

pkg/api/resource.go

@@ -16,20 +16,21 @@ import (
 // differentiated by the Kind field. Existing Cluster and NodePool types
 // are NOT migrated to this model.
 type Resource struct {
+	OwnerID     *string    `json:"owner_id,omitempty" gorm:"size:255"`
+	OwnerHref   *string    `json:"owner_href,omitempty" gorm:"size:500"`
+	OwnerKind   *string    `json:"owner_kind,omitempty" gorm:"size:100"`
+	DeletedBy   *string    `json:"deleted_by,omitempty" gorm:"size:255"`
+	DeletedTime *time.Time `json:"deleted_time,omitempty"`
 	Meta
-	Kind        string         `json:"kind" gorm:"size:100;not null"`
-	Name        string         `json:"name" gorm:"size:100;not null"`
-	Href        string         `json:"href,omitempty" gorm:"size:500"`
-	CreatedBy   string         `json:"created_by" gorm:"size:255;not null"`
-	UpdatedBy   string         `json:"updated_by" gorm:"size:255;not null"`
-	DeletedBy   *string        `json:"deleted_by,omitempty" gorm:"size:255"`
-	DeletedTime *time.Time     `json:"deleted_time,omitempty"`
-	OwnerID     *string        `json:"owner_id,omitempty" gorm:"size:255"`
-	OwnerKind   *string        `json:"owner_kind,omitempty" gorm:"size:100"`
-	OwnerHref   *string        `json:"owner_href,omitempty" gorm:"size:500"`
-	Spec        datatypes.JSON `json:"spec" gorm:"type:jsonb;not null"`
-	Labels      datatypes.JSON `json:"labels,omitempty" gorm:"type:jsonb"`
-	Generation  int32          `json:"generation" gorm:"default:1;not null"`
+	Kind       string              `json:"kind" gorm:"size:100;not null"`
+	Name       string              `json:"name" gorm:"size:100;not null"`
+	Href       string              `json:"href,omitempty" gorm:"size:500"`
+	CreatedBy  string              `json:"created_by" gorm:"size:255;not null"`
+	UpdatedBy  string              `json:"updated_by" gorm:"size:255;not null"`
+	Labels     datatypes.JSON      `json:"labels,omitempty" gorm:"type:jsonb"`
+	Spec       datatypes.JSON      `json:"spec" gorm:"type:jsonb;not null"`
+	Conditions []ResourceCondition `json:"-" gorm:"foreignKey:ResourceID;references:ID"`
+	Generation int32               `json:"generation" gorm:"default:1;not null"`
 }
 
 type ResourcePatch struct {

pkg/api/status_types.go

@@ -50,18 +50,24 @@ const (
 	ResourceConditionTypeLastKnownReconciled = "LastKnownReconciled"
 )
 
-// ResourceCondition represents a condition of a resource
-// Domain equivalent of openapi.ResourceCondition
-// JSON tags match database JSONB structure
+// ResourceCondition represents a condition of a resource.
+// Dual-use: GORM model for the resource_conditions table (generic resources)
+// and JSON-deserializable struct for JSONB columns (clusters/node pools).
+// ResourceID is excluded from JSON (json:"-") to preserve JSONB backward compat.
 type ResourceCondition struct {
-	CreatedTime        time.Time               `json:"created_time"`
-	LastUpdatedTime    time.Time               `json:"last_updated_time"`
-	LastTransitionTime time.Time               `json:"last_transition_time"`
-	Reason             *string                 `json:"reason,omitempty"`
-	Message            *string                 `json:"message,omitempty"`
-	Type               string                  `json:"type"`
-	Status             ResourceConditionStatus `json:"status"`
-	ObservedGeneration int32                   `json:"observed_generation"`
+	CreatedTime        time.Time               `json:"created_time" gorm:"not null"`
+	LastUpdatedTime    time.Time               `json:"last_updated_time" gorm:"not null"`
+	LastTransitionTime time.Time               `json:"last_transition_time" gorm:"not null"`
+	Reason             *string                 `json:"reason,omitempty" gorm:"type:text"`
+	Message            *string                 `json:"message,omitempty" gorm:"type:text"`
+	ResourceID         string                  `json:"-" gorm:"primaryKey;size:255;not null"`
+	Type               string                  `json:"type" gorm:"primaryKey;size:100;not null"`
+	Status             ResourceConditionStatus `json:"status" gorm:"size:10;not null"`
+	ObservedGeneration int32                   `json:"observed_generation" gorm:"default:0;not null"`
+}
+
+func (ResourceCondition) TableName() string {
+	return "resource_conditions"
 }
 
 // AdapterCondition represents a condition of an adapter

pkg/dao/resource.go

@@ -36,7 +36,7 @@ func NewResourceDao(sessionFactory db.SessionFactory) ResourceDao {
 func (d *sqlResourceDao) Get(ctx context.Context, kind, id string) (*api.Resource, error) {
 	g2 := d.sessionFactory.New(ctx)
 	var resource api.Resource
-	if err := g2.Take(&resource, "kind = ? AND id = ?", kind, id).Error; err != nil {
+	if err := g2.Preload("Conditions").Take(&resource, "kind = ? AND id = ?", kind, id).Error; err != nil {
 		return nil, err
 	}
 	return &resource, nil
@@ -55,7 +55,8 @@ func (d *sqlResourceDao) GetForUpdate(ctx context.Context, kind, id string) (*ap
 func (d *sqlResourceDao) GetByOwner(ctx context.Context, kind, id, ownerID string) (*api.Resource, error) {
 	g2 := d.sessionFactory.New(ctx)
 	var resource api.Resource
-	if err := g2.Take(&resource, "kind = ? AND id = ? AND owner_id = ?", kind, id, ownerID).Error; err != nil {
+	if err := g2.Preload("Conditions").
+		Take(&resource, "kind = ? AND id = ? AND owner_id = ?", kind, id, ownerID).Error; err != nil {
 		return nil, err
 	}
 	return &resource, nil

pkg/dao/resource_condition.go

@@ -0,0 +1,66 @@
+package dao
+
+import (
+	"context"
+
+	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/api"
+	"github.com/openshift-hyperfleet/hyperfleet-api/pkg/db"
+)
+
+type ResourceConditionDao interface {
+	// UpdateConditions must be called within a write transaction — it performs
+	// delete+insert which is not atomic without one. Per ADR-0008, this is called
+	// from the adapter status upsert path (PUT), which has a transaction from
+	// TransactionMiddleware.
+	UpdateConditions(ctx context.Context, resourceID string, conditions []api.ResourceCondition) error
+}
+
+var _ ResourceConditionDao = &sqlResourceConditionDao{}
+
+type sqlResourceConditionDao struct {
+	sessionFactory db.SessionFactory
+}
+
+func NewResourceConditionDao(sessionFactory db.SessionFactory) ResourceConditionDao {
+	return &sqlResourceConditionDao{sessionFactory: sessionFactory}
+}
+
+func (d *sqlResourceConditionDao) UpdateConditions(
+	ctx context.Context, resourceID string, conditions []api.ResourceCondition,
+) error {
+	g2 := d.sessionFactory.New(ctx)
+
+	var existing []api.ResourceCondition
+	if err := g2.Where("resource_id = ?", resourceID).Find(&existing).Error; err != nil {
+		return err
+	}
+
+	prevByType := make(map[string]api.ResourceCondition, len(existing))
+	for _, c := range existing {
+		prevByType[c.Type] = c
+	}
+
+	for i := range conditions {
+		conditions[i].ResourceID = resourceID
+		if prev, ok := prevByType[conditions[i].Type]; ok {
+			if prev.Status == conditions[i].Status {
+				conditions[i].LastTransitionTime = prev.LastTransitionTime
+			}
+			conditions[i].CreatedTime = prev.CreatedTime
+		}
+	}
+
+	if err := g2.Where("resource_id = ?", resourceID).Delete(&api.ResourceCondition{}).Error; err != nil {
+		db.MarkForRollback(ctx, err)
+		return err
+	}
+
+	if len(conditions) > 0 {
+		if err := g2.Create(&conditions).Error; err != nil {
+			db.MarkForRollback(ctx, err)
+			return err
+		}
+	}
+
+	return nil
+}

pkg/db/migrations/202606290001_add_resource_conditions.go

@@ -0,0 +1,38 @@
+package migrations
+
+import (
+	"github.com/go-gormigrate/gormigrate/v2"
+	"gorm.io/gorm"
+)
+
+func addResourceConditions() *gormigrate.Migration {
+	return &gormigrate.Migration{
+		ID: "202606290001",
+		Migrate: func(tx *gorm.DB) error {
+			if err := tx.Exec(`CREATE TABLE IF NOT EXISTS resource_conditions (
+				resource_id			VARCHAR(255) NOT NULL,
+				type				VARCHAR(100) NOT NULL,
+				status				VARCHAR(10) NOT NULL,
+				reason				TEXT,
+				message				TEXT,
+				observed_generation	INTEGER NOT NULL DEFAULT 0,
+				created_time		TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+				last_updated_time	TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+				last_transition_time TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+				PRIMARY KEY (resource_id, type),
+				FOREIGN KEY (resource_id) REFERENCES resources(id) ON DELETE CASCADE
+			);`).Error; err != nil {
+				return err
+			}
+
+			if err := tx.Exec(
+				"CREATE INDEX IF NOT EXISTS idx_resource_conditions_resource_id " +
+					"ON resource_conditions (resource_id);",
+			).Error; err != nil {
+				return err
+			}
+
+			return nil
+		},
+	}
+}

pkg/db/migrations/migration_structs.go

@@ -37,6 +37,7 @@ var MigrationList = []*gormigrate.Migration{
 	addDeletedTimeIndexes(),
 	addResources(),
 	removeReadyCondition(),
+	addResourceConditions(),
 }
 
 // Model represents the base model struct. All entities will have this struct embedded.