feat: add support for trigger comments, trigger enabled/disabled state, and sequence comments (#479)

* feat: detect and emit trigger comments, trigger enabled/disabled state, and sequence comments

- Trigger comments: inspect COMMENT ON TRIGGER via pg_description, emit COMMENT ON TRIGGER DDL on diff
- Trigger state: inspect trigger enabled flag (pg_trigger.tgenabled), emit ALTER TABLE ENABLE/DISABLE TRIGGER on diff
- Sequence comments: inspect COMMENT ON SEQUENCE via pg_description, emit COMMENT ON SEQUENCE DDL on diff
- Test fixtures: add_trigger_comment, add_sequence_comment, disable_trigger (all passing)

* fix: emit COMMENT ON SEQUENCE for SERIAL-owned sequences created via CREATE TABLE

When a table with BIGSERIAL/SERIAL columns was created for the first time,
pgschema skipped the sequence from addedSequences (correctly, since CREATE TABLE
creates it implicitly), but this also skipped emitting any COMMENT ON SEQUENCE
declared in the model. On the second run, the sequence existed in the live DB
and the comment diff fired, re-applying all sequence comments indefinitely.

Fix: track skipped-but-commented SERIAL sequences in addedSerialSeqComments and
emit their COMMENT ON SEQUENCE statements after all CREATE TABLE calls complete.

Test: add_serial_sequence_comment_on_create fixture verifies COMMENT is emitted
on first deploy alongside CREATE TABLE, not deferred to a subsequent run.

* fix: address Greptile review findings and add missing plan test files

Greptile fixes:
- ir/ir.go: rename Enabled bool → Disabled bool (omitempty) so zero-value means
  enabled, matching Postgres default; avoids spurious DISABLE TRIGGER on triggers
  that omit the field
- ir/inspector.go: set Disabled=true only when tgenabled='D'
- internal/diff/trigger.go: update all !trigger.Enabled → trigger.Disabled;
  add DISABLE TRIGGER emission to view trigger create path (was missing)
- internal/diff/table.go: update Enabled → Disabled in trigger diff detection
- internal/diff/view.go: emit trigger comment and disabled state in both
  constraint-recreate and non-constraint modify paths for view triggers

CI fix:
- Add plan.sql, plan.json, plan.txt for all 4 new fixtures so TestPlanAndApply passes

* fix: address Copilot review comments on trigger comment/state handling

- Re-apply trigger comment and disabled state after structural recreation
  in table diff to avoid losing them on DROP+CREATE
- Use old/new comparison in view trigger modification branches to handle
  comment removal and disabled->enabled transitions correctly
- Pass diffType to generateTriggerEnabledState so view trigger enable/disable
  steps are correctly labeled as DiffTypeViewTrigger in plan output

Author: ayusssmaan

internal/diff/diff.go

@@ -288,6 +288,7 @@ type ddlDiff struct {
 	droppedTypes              []*ir.Type
 	modifiedTypes             []*typeDiff
 	addedSequences            []*ir.Sequence
+	addedSerialSeqComments    []*ir.Sequence // SERIAL-owned sequences skipped from addedSequences but with comments to emit
 	droppedSequences          []*ir.Sequence
 	modifiedSequences         []*sequenceDiff
 	addedDefaultPrivileges    []*ir.DefaultPrivilege
@@ -478,6 +479,7 @@ func GenerateMigration(oldIR, newIR *ir.IR, targetSchema string) []Diff {
 		droppedTypes:               []*ir.Type{},
 		modifiedTypes:              []*typeDiff{},
 		addedSequences:             []*ir.Sequence{},
+		addedSerialSeqComments:     []*ir.Sequence{},
 		droppedSequences:           []*ir.Sequence{},
 		modifiedSequences:          []*sequenceDiff{},
 		addedDefaultPrivileges:     []*ir.DefaultPrivilege{},
@@ -1041,6 +1043,11 @@ func GenerateMigration(oldIR, newIR *ir.IR, targetSchema string) []Diff {
 			// (created by SERIAL in CREATE TABLE). If the column already exists,
 			// we need to create the sequence explicitly for ALTER COLUMN to use.
 			if seq.OwnedByTable != "" && seq.OwnedByColumn != "" && !columnExistsInTables(oldTables, seq.Schema, seq.OwnedByTable, seq.OwnedByColumn) {
+				// Sequence is created implicitly by CREATE TABLE (SERIAL). Emit its
+				// comment separately after all tables are created.
+				if seq.Comment != "" {
+					diff.addedSerialSeqComments = append(diff.addedSerialSeqComments, seq)
+				}
 				continue
 			}
 			diff.addedSequences = append(diff.addedSequences, seq)
@@ -1064,12 +1071,20 @@ func GenerateMigration(oldIR, newIR *ir.IR, targetSchema string) []Diff {
 	for _, key := range seqKeys {
 		newSeq := newSequences[key]
 		if oldSeq, exists := oldSequences[key]; exists {
-			// Skip sequences owned by table columns (created by SERIAL)
-			if (oldSeq.OwnedByTable != "" && oldSeq.OwnedByColumn != "") ||
-				(newSeq.OwnedByTable != "" && newSeq.OwnedByColumn != "") {
+			// Skip sequences owned by table columns (created by SERIAL) for structural changes,
+			// but allow comment-only changes through so COMMENT ON SEQUENCE can be deployed.
+			isOwned := (oldSeq.OwnedByTable != "" && oldSeq.OwnedByColumn != "") ||
+				(newSeq.OwnedByTable != "" && newSeq.OwnedByColumn != "")
+			if isOwned {
+				if oldSeq.Comment != newSeq.Comment {
+					diff.modifiedSequences = append(diff.modifiedSequences, &sequenceDiff{
+						Old: oldSeq,
+						New: newSeq,
+					})
+				}
 				continue
 			}
-			if !sequencesEqual(oldSeq, newSeq) {
+			if !sequencesEqual(oldSeq, newSeq) || oldSeq.Comment != newSeq.Comment {
 				diff.modifiedSequences = append(diff.modifiedSequences, &sequenceDiff{
 					Old: oldSeq,
 					New: newSeq,
@@ -1818,6 +1833,12 @@ func (d *ddlDiff) generateCreateSQL(targetSchema string, collector *diffCollecto
 	// Create tables WITH function/domain dependencies (now that functions and deferred domains exist)
 	deferredPolicies2, deferredConstraints2 := generateCreateTablesSQL(tablesWithDeps, targetSchema, collector, existingTables, shouldDeferPolicy, d.suppressedInlineFKs)
 
+	// Emit COMMENT ON SEQUENCE for sequences created implicitly via CREATE TABLE (SERIAL/BIGSERIAL).
+	// These were skipped from addedSequences but their comments must still be deployed.
+	for _, seq := range d.addedSerialSeqComments {
+		generateSequenceComment(seq, targetSchema, DiffOperationCreate, collector)
+	}
+
 	// Add deferred foreign key constraints from BOTH batches AFTER all tables are created
 	// This ensures FK references to tables in the second batch (function-dependent tables) work correctly
 	allDeferredConstraints := append(deferredConstraints1, deferredConstraints2...)

internal/diff/sequence.go

@@ -31,9 +31,33 @@ func generateCreateSequencesSQL(sequences []*ir.Sequence, targetSchema string, c
 		}
 
 		collector.collect(context, sql)
+
+		// Emit COMMENT ON SEQUENCE if present
+		if seq.Comment != "" {
+			generateSequenceComment(seq, targetSchema, DiffOperationCreate, collector)
+		}
 	}
 }
 
+// generateSequenceComment emits a COMMENT ON SEQUENCE statement
+func generateSequenceComment(seq *ir.Sequence, targetSchema string, operation DiffOperation, collector *diffCollector) {
+	seqName := qualifyEntityName(seq.Schema, seq.Name, targetSchema)
+	var sql string
+	if seq.Comment == "" {
+		sql = fmt.Sprintf("COMMENT ON SEQUENCE %s IS NULL;", seqName)
+	} else {
+		sql = fmt.Sprintf("COMMENT ON SEQUENCE %s IS %s;", seqName, quoteString(seq.Comment))
+	}
+	context := &diffContext{
+		Type:                DiffTypeSequence,
+		Operation:           operation,
+		Path:                fmt.Sprintf("%s.%s", seq.Schema, seq.Name),
+		Source:              seq,
+		CanRunInTransaction: true,
+	}
+	collector.collect(context, sql)
+}
+
 // generateDropSequencesSQL generates DROP SEQUENCE statements
 func generateDropSequencesSQL(sequences []*ir.Sequence, targetSchema string, collector *diffCollector) {
 	// Process sequences in reverse order (already sorted)
@@ -71,6 +95,11 @@ func generateModifySequencesSQL(diffs []*sequenceDiff, targetSchema string, coll
 
 			collector.collect(context, stmt)
 		}
+
+		// Emit COMMENT ON SEQUENCE if comment changed
+		if diff.Old.Comment != diff.New.Comment {
+			generateSequenceComment(diff.New, targetSchema, DiffOperationAlter, collector)
+		}
 	}
 }
 

internal/diff/table.go

@@ -98,10 +98,13 @@ func diffTriggers(oldTable, newTable *ir.Table, diff *tableDiff) {
 		}
 	}
 
-	// Find modified triggers
+	// Find modified triggers (structural changes, comment-only, or enabled-state-only)
 	for name, newTrigger := range newTriggers {
 		if oldTrigger, exists := oldTriggers[name]; exists {
-			if !triggersEqual(oldTrigger, newTrigger) {
+			structurallyEqual := triggersEqual(oldTrigger, newTrigger)
+			commentChanged := oldTrigger.Comment != newTrigger.Comment
+			enabledChanged := oldTrigger.Disabled != newTrigger.Disabled
+			if !structurallyEqual || commentChanged || enabledChanged {
 				diff.ModifiedTriggers = append(diff.ModifiedTriggers, &triggerDiff{
 					Old: oldTrigger,
 					New: newTrigger,
@@ -1383,43 +1386,61 @@ func (td *tableDiff) generateAlterTableStatements(targetSchema string, collector
 
 	// Modify triggers - already sorted by the Diff operation
 	for _, triggerDiff := range td.ModifiedTriggers {
-		// Constraint triggers don't support CREATE OR REPLACE, so we need to DROP and CREATE
-		if triggerDiff.New.IsConstraint {
-			tableName := getTableNameWithSchema(td.Table.Schema, td.Table.Name, targetSchema)
+		structurallyEqual := triggersEqual(triggerDiff.Old, triggerDiff.New)
+		commentChanged := triggerDiff.Old.Comment != triggerDiff.New.Comment
+		enabledChanged := triggerDiff.Old.Disabled != triggerDiff.New.Disabled
+
+		if !structurallyEqual {
+			// Constraint triggers don't support CREATE OR REPLACE, so we need to DROP and CREATE
+			if triggerDiff.New.IsConstraint {
+				tableName := getTableNameWithSchema(td.Table.Schema, td.Table.Name, targetSchema)
+
+				// Step 1: DROP the old trigger
+				dropSQL := fmt.Sprintf("DROP TRIGGER IF EXISTS %s ON %s;", ir.QuoteIdentifier(triggerDiff.Old.Name), tableName)
+				dropContext := &diffContext{
+					Type:                DiffTypeTableTrigger,
+					Operation:           DiffOperationDrop,
+					Path:                fmt.Sprintf("%s.%s.%s", td.Table.Schema, td.Table.Name, triggerDiff.Old.Name),
+					Source:              triggerDiff.Old,
+					CanRunInTransaction: true,
+				}
+				collector.collect(dropContext, dropSQL)
 
-			// Step 1: DROP the old trigger
-			dropSQL := fmt.Sprintf("DROP TRIGGER IF EXISTS %s ON %s;", ir.QuoteIdentifier(triggerDiff.Old.Name), tableName)
-			dropContext := &diffContext{
-				Type:                DiffTypeTableTrigger,
-				Operation:           DiffOperationDrop,
-				Path:                fmt.Sprintf("%s.%s.%s", td.Table.Schema, td.Table.Name, triggerDiff.Old.Name),
-				Source:              triggerDiff.Old,
-				CanRunInTransaction: true,
-			}
-			collector.collect(dropContext, dropSQL)
+				// Step 2: CREATE the new constraint trigger
+				createSQL := generateTriggerSQLWithMode(triggerDiff.New, targetSchema)
+				createContext := &diffContext{
+					Type:                DiffTypeTableTrigger,
+					Operation:           DiffOperationCreate,
+					Path:                fmt.Sprintf("%s.%s.%s", td.Table.Schema, td.Table.Name, triggerDiff.New.Name),
+					Source:              triggerDiff.New,
+					CanRunInTransaction: true,
+				}
+				collector.collect(createContext, createSQL)
+			} else {
+				// Use CREATE OR REPLACE for regular triggers
+				sql := generateTriggerSQLWithMode(triggerDiff.New, targetSchema)
 
-			// Step 2: CREATE the new constraint trigger
-			createSQL := generateTriggerSQLWithMode(triggerDiff.New, targetSchema)
-			createContext := &diffContext{
-				Type:                DiffTypeTableTrigger,
-				Operation:           DiffOperationCreate,
-				Path:                fmt.Sprintf("%s.%s.%s", td.Table.Schema, td.Table.Name, triggerDiff.New.Name),
-				Source:              triggerDiff.New,
-				CanRunInTransaction: true,
+				context := &diffContext{
+					Type:                DiffTypeTableTrigger,
+					Operation:           DiffOperationAlter,
+					Path:                fmt.Sprintf("%s.%s.%s", td.Table.Schema, td.Table.Name, triggerDiff.New.Name),
+					Source:              triggerDiff,
+					CanRunInTransaction: true,
+				}
+				collector.collect(context, sql)
 			}
-			collector.collect(createContext, createSQL)
-		} else {
-			// Use CREATE OR REPLACE for regular triggers
-			sql := generateTriggerSQLWithMode(triggerDiff.New, targetSchema)
+		}
 
-			context := &diffContext{
-				Type:                DiffTypeTableTrigger,
-				Operation:           DiffOperationAlter,
-				Path:                fmt.Sprintf("%s.%s.%s", td.Table.Schema, td.Table.Name, triggerDiff.New.Name),
-				Source:              triggerDiff,
-				CanRunInTransaction: true,
-			}
-			collector.collect(context, sql)
+		// Emit COMMENT ON TRIGGER when the comment changed, or after structural recreation
+		// so the desired comment is preserved.
+		if commentChanged || (!structurallyEqual && triggerDiff.New.Comment != "") {
+			generateTriggerComment(triggerDiff.New, td.Table.Schema, td.Table.Name, targetSchema, DiffTypeTableTrigger, collector)
+		}
+
+		// Emit ENABLE/DISABLE TRIGGER when the state changed, or after structural recreation
+		// so disabled triggers stay disabled.
+		if enabledChanged || (!structurallyEqual && triggerDiff.New.Disabled) {
+			generateTriggerEnabledState(triggerDiff.New, td.Table.Schema, td.Table.Name, targetSchema, DiffTypeTableTrigger, collector)
 		}
 	}
 

internal/diff/trigger.go

@@ -148,6 +148,16 @@ func generateCreateTriggersSQL(triggers []*ir.Trigger, targetSchema string, coll
 		}
 
 		collector.collect(context, sql)
+
+		// Emit COMMENT ON TRIGGER if present
+		if trigger.Comment != "" {
+			generateTriggerComment(trigger, trigger.Schema, trigger.Table, targetSchema, DiffTypeTableTrigger, collector)
+		}
+
+		// Emit DISABLE TRIGGER if the trigger is disabled
+		if trigger.Disabled {
+			generateTriggerEnabledState(trigger, trigger.Schema, trigger.Table, targetSchema, DiffTypeTableTrigger, collector)
+		}
 	}
 }
 
@@ -319,7 +329,50 @@ func generateCreateViewTriggersSQL(triggers []*ir.Trigger, targetSchema string,
 		}
 
 		collector.collect(context, sql)
+
+		if trigger.Comment != "" {
+			generateTriggerComment(trigger, trigger.Schema, trigger.Table, targetSchema, DiffTypeViewTrigger, collector)
+		}
+
+		if trigger.Disabled {
+			generateTriggerEnabledState(trigger, trigger.Schema, trigger.Table, targetSchema, DiffTypeViewTrigger, collector)
+		}
 	}
 }
 
+// generateTriggerComment emits a COMMENT ON TRIGGER statement
+func generateTriggerComment(trigger *ir.Trigger, schema, table, targetSchema string, diffType DiffType, collector *diffCollector) {
+	tableName := getTableNameWithSchema(schema, table, targetSchema)
+	var sql string
+	if trigger.Comment == "" {
+		sql = fmt.Sprintf("COMMENT ON TRIGGER %s ON %s IS NULL;", ir.QuoteIdentifier(trigger.Name), tableName)
+	} else {
+		sql = fmt.Sprintf("COMMENT ON TRIGGER %s ON %s IS %s;", ir.QuoteIdentifier(trigger.Name), tableName, quoteString(trigger.Comment))
+	}
+	context := &diffContext{
+		Type:                diffType,
+		Operation:           DiffOperationAlter,
+		Path:                fmt.Sprintf("%s.%s.%s", schema, table, trigger.Name),
+		Source:              trigger,
+		CanRunInTransaction: true,
+	}
+	collector.collect(context, sql)
+}
 
+// generateTriggerEnabledState emits ALTER TABLE DISABLE/ENABLE TRIGGER
+func generateTriggerEnabledState(trigger *ir.Trigger, schema, table, targetSchema string, diffType DiffType, collector *diffCollector) {
+	tableName := getTableNameWithSchema(schema, table, targetSchema)
+	state := "ENABLE"
+	if trigger.Disabled {
+		state = "DISABLE"
+	}
+	sql := fmt.Sprintf("ALTER TABLE %s %s TRIGGER %s;", tableName, state, ir.QuoteIdentifier(trigger.Name))
+	context := &diffContext{
+		Type:                diffType,
+		Operation:           DiffOperationAlter,
+		Path:                fmt.Sprintf("%s.%s.%s", schema, table, trigger.Name),
+		Source:              trigger,
+		CanRunInTransaction: true,
+	}
+	collector.collect(context, sql)
+}

internal/diff/view.go

@@ -435,6 +435,14 @@ func generateModifyViewsSQL(diffs []*viewDiff, targetSchema string, collector *d
 					CanRunInTransaction: true,
 				}
 				collector.collect(createContext, createSQL)
+				commentChanged := triggerDiff.Old.Comment != triggerDiff.New.Comment
+				enabledChanged := triggerDiff.Old.Disabled != triggerDiff.New.Disabled
+				if commentChanged || triggerDiff.New.Comment != "" {
+					generateTriggerComment(triggerDiff.New, diff.New.Schema, diff.New.Name, targetSchema, DiffTypeViewTrigger, collector)
+				}
+				if enabledChanged || triggerDiff.New.Disabled {
+					generateTriggerEnabledState(triggerDiff.New, diff.New.Schema, diff.New.Name, targetSchema, DiffTypeViewTrigger, collector)
+				}
 			} else {
 				sql := generateTriggerSQLWithMode(triggerDiff.New, targetSchema)
 				context := &diffContext{
@@ -445,6 +453,14 @@ func generateModifyViewsSQL(diffs []*viewDiff, targetSchema string, collector *d
 					CanRunInTransaction: true,
 				}
 				collector.collect(context, sql)
+				commentChanged := triggerDiff.Old.Comment != triggerDiff.New.Comment
+				enabledChanged := triggerDiff.Old.Disabled != triggerDiff.New.Disabled
+				if commentChanged || triggerDiff.New.Comment != "" {
+					generateTriggerComment(triggerDiff.New, diff.New.Schema, diff.New.Name, targetSchema, DiffTypeViewTrigger, collector)
+				}
+				if enabledChanged || triggerDiff.New.Disabled {
+					generateTriggerEnabledState(triggerDiff.New, diff.New.Schema, diff.New.Name, targetSchema, DiffTypeViewTrigger, collector)
+				}
 			}
 		}
 	}

ir/inspector.go

@@ -881,13 +881,19 @@ func (i *Inspector) buildSequences(ctx context.Context, schema *IR, targetSchema
 			}
 		}
 
+		seqComment := ""
+		if seq.SequenceComment.Valid {
+			seqComment = seq.SequenceComment.String
+		}
+
 		sequence := &Sequence{
 			Schema:      schemaName,
 			Name:        sequenceName,
 			DataType:    dataType,
 			StartValue:  seq.StartValue.Int64,
 			Increment:   seq.Increment.Int64,
 			CycleOption: seq.CycleOption.Bool,
+			Comment:     seqComment,
 		}
 
 		// Set default values if not valid
@@ -1725,6 +1731,15 @@ func (i *Inspector) buildTriggers(ctx context.Context, schema *IR, targetSchema
 			comment = triggerRow.TriggerComment.String
 		}
 
+		// Extract disabled state: tgenabled 'D' = disabled, anything else = enabled (Postgres default)
+		disabled := false
+		switch v := triggerRow.TriggerEnabled.(type) {
+		case string:
+			disabled = v == "D"
+		case []byte:
+			disabled = string(v) == "D"
+		}
+
 		// Determine if this is a constraint trigger
 		oid, ok := triggerRow.TriggerConstraintOid.(int64)
 		isConstraint := ok && oid != 0
@@ -1748,6 +1763,7 @@ func (i *Inspector) buildTriggers(ctx context.Context, schema *IR, targetSchema
 			Deferrable:        deferrable,
 			InitiallyDeferred: initDeferred,
 			Comment:           comment,
+			Disabled:          disabled,
 		}
 
 		// Add trigger to the appropriate map

ir/ir.go

@@ -298,6 +298,7 @@ type Trigger struct {
 	InitiallyDeferred bool           `json:"initially_deferred,omitempty"` // Whether deferred by default
 	OldTable          string         `json:"old_table,omitempty"`          // REFERENCING OLD TABLE AS name
 	NewTable          string         `json:"new_table,omitempty"`          // REFERENCING NEW TABLE AS name
+	Disabled          bool           `json:"disabled,omitempty"`           // true = DISABLED (tgenabled='D'); omitted/false = enabled (Postgres default)
 }
 
 // TriggerTiming represents the timing of trigger execution