consolidation

type AdvancedColumnLifecycleRule ¶

type AdvancedColumnLifecycleRule struct {
	// contains filtered or unexported fields
}

AdvancedColumnLifecycleRule handles complex column evolution patterns with edge cases

func NewAdvancedColumnLifecycleRule() *AdvancedColumnLifecycleRule

func (r *AdvancedColumnLifecycleRule) Apply(lifecycle *tracking.ObjectLifecycle, engine ConsolidationEngine) (*tracking.ConsolidationResult, error)

func (r *AdvancedColumnLifecycleRule) CanApply(lifecycle *tracking.ObjectLifecycle) bool

func (r *AdvancedColumnLifecycleRule) Risk() tracking.RiskLevel

type ColumnChange ¶

type ColumnChange struct {
	Name      string
	Operation string // ADD, DROP, ALTER, RENAME
	DataType  string
	Default   string
	NotNull   bool
	Order     int
}

ColumnChange tracks a column modification operation

type ColumnConstraint ¶

type ColumnConstraint struct {
	Type       ConstraintType `json:"type"`
	Name       string         `json:"name"`
	Definition string         `json:"definition"`
	TableLevel bool           `json:"table_level"`
}

ColumnConstraint represents a constraint on a column

type ColumnConstraintInfo ¶

type ColumnConstraintInfo struct {
	Name            string
	Type            ConstraintType
	Definition      string
	AffectedColumns []string
	TableLevel      bool
}

ColumnConstraintInfo represents parsed constraint information for column lifecycle tracking

type ColumnEvolutionRule ¶

type ColumnEvolutionRule struct{}

ColumnEvolutionRule handles complex column lifecycle patterns

func (r *ColumnEvolutionRule) Apply(lifecycle *tracking.ObjectLifecycle, engine ConsolidationEngine) (*tracking.ConsolidationResult, error)

func (r *ColumnEvolutionRule) CanApply(lifecycle *tracking.ObjectLifecycle) bool

func (r *ColumnEvolutionRule) Risk() tracking.RiskLevel

type ColumnLifecycleState ¶

type ColumnLifecycleState struct {
	Name            string                 `json:"name"`
	OriginalName    string                 `json:"original_name"`
	DataType        string                 `json:"data_type"`
	IsNullable      bool                   `json:"is_nullable"`
	DefaultValue    string                 `json:"default_value"`
	Constraints     []ColumnConstraint     `json:"constraints"`
	Position        int                    `json:"position"`
	Transformations []ColumnTransformation `json:"transformations"`
	Status          ColumnStatus           `json:"status"`
	Dependencies    []string               `json:"dependencies"`
}

ColumnLifecycleState represents the complete state of a column through its lifecycle

type ColumnOperation ¶

type ColumnOperation string

ColumnOperation represents operations that can be performed on columns

const (
	ColumnOpAdd            ColumnOperation = "ADD"
	ColumnOpDrop           ColumnOperation = "DROP"
	ColumnOpRename         ColumnOperation = "RENAME"
	ColumnOpChangeType     ColumnOperation = "CHANGE_TYPE"
	ColumnOpSetDefault     ColumnOperation = "SET_DEFAULT"
	ColumnOpDropDefault    ColumnOperation = "DROP_DEFAULT"
	ColumnOpSetNotNull     ColumnOperation = "SET_NOT_NULL"
	ColumnOpDropNotNull    ColumnOperation = "DROP_NOT_NULL"
	ColumnOpAddConstraint  ColumnOperation = "ADD_CONSTRAINT"
	ColumnOpDropConstraint ColumnOperation = "DROP_CONSTRAINT"
)

type ColumnStatus ¶

type ColumnStatus string

ColumnStatus represents the current status of a column

const (
	ColumnStatusActive    ColumnStatus = "ACTIVE"
	ColumnStatusDropped   ColumnStatus = "DROPPED"
	ColumnStatusRenamed   ColumnStatus = "RENAMED"
	ColumnStatusTransient ColumnStatus = "TRANSIENT" // Added and dropped in same lifecycle
)

type ColumnTransformation ¶

type ColumnTransformation struct {
	Operation  ColumnOperation `json:"operation"`
	OldValue   string          `json:"old_value"`
	NewValue   string          `json:"new_value"`
	AtSequence int             `json:"at_sequence"`
	SQL        string          `json:"sql"`
	HasDataOps bool            `json:"has_data_ops"`
}

ColumnTransformation tracks changes to a column

type ConditionalSchemaRule ¶

type ConditionalSchemaRule struct{}

ConditionalSchemaRule consolidates conditional schema operations (IF NOT EXISTS, CREATE OR REPLACE)

func (r *ConditionalSchemaRule) Apply(lifecycle *tracking.ObjectLifecycle, engine ConsolidationEngine) (*tracking.ConsolidationResult, error)

func (r *ConditionalSchemaRule) CanApply(lifecycle *tracking.ObjectLifecycle) bool

func (r *ConditionalSchemaRule) Risk() tracking.RiskLevel

type ConditionalState ¶

type ConditionalState struct {
	ShouldExist  bool
	UseReplace   bool
	FinalSQL     string
	Dependencies []string
	WasCreated   bool
}

ConditionalState represents the final desired state after analyzing conditional operations

type ConflictPolicy ¶

type ConflictPolicy string

ConflictPolicy defines how to handle rule conflicts

const (
	ConflictPolicyHighestPriority ConflictPolicy = "highest_priority" // Use rule with highest priority
	ConflictPolicyFirstRegistered ConflictPolicy = "first_registered" // Use first registered rule
	ConflictPolicyError           ConflictPolicy = "error"            // Return error on conflict
)

type ConsolidationEngine ¶

type ConsolidationEngine interface {
	GetTracker() *tracking.Tracker
	GetConfig() *config.Config
	GetSafetyLevel() string // Returns the current safety level (paranoid, conservative, standard, aggressive)
}

ConsolidationEngine interface for the engine that applies consolidation rules

type ConsolidationRule ¶

type ConsolidationRule interface {
	CanApply(lifecycle *tracking.ObjectLifecycle) bool
	Apply(lifecycle *tracking.ObjectLifecycle, engine ConsolidationEngine) (*tracking.ConsolidationResult, error)
	Risk() tracking.RiskLevel
}

ConsolidationRule interface for consolidation rules used by the squasher

type ConsolidationRuleEngine ¶

type ConsolidationRuleEngine struct {
	// contains filtered or unexported fields
}

ConsolidationRuleEngine manages and applies consolidation rules

func NewConsolidationRuleEngine() *ConsolidationRuleEngine

func (cre *ConsolidationRuleEngine) AddRule(rule ConsolidationRule)

func (cre *ConsolidationRuleEngine) ApplyRules(lifecycle *tracking.ObjectLifecycle, engine ConsolidationEngine) (*tracking.ConsolidationResult, error)

func (cre *ConsolidationRuleEngine) GetApplicableRules(lifecycle *tracking.ObjectLifecycle) []ConsolidationRule

func (cre *ConsolidationRuleEngine) GetRegistry() *RuleRegistry

func (cre *ConsolidationRuleEngine) Rules() []ConsolidationRule

type ConstraintType ¶

type ConstraintType string

ConstraintType represents different types of column constraints

const (
	ConstraintPrimaryKey ConstraintType = "PRIMARY_KEY"
	ConstraintForeignKey ConstraintType = "FOREIGN_KEY"
	ConstraintUnique     ConstraintType = "UNIQUE"
	ConstraintCheck      ConstraintType = "CHECK"
	ConstraintDefault    ConstraintType = "DEFAULT"
	ConstraintNotNull    ConstraintType = "NOT_NULL"
)

type CreateAlterConsolidationRule ¶

type CreateAlterConsolidationRule struct{}

CreateAlterConsolidationRule consolidates CREATE statements followed by ALTER statements

func (r *CreateAlterConsolidationRule) Apply(lifecycle *tracking.ObjectLifecycle, engine ConsolidationEngine) (*tracking.ConsolidationResult, error)

func (r *CreateAlterConsolidationRule) CanApply(lifecycle *tracking.ObjectLifecycle) bool

func (r *CreateAlterConsolidationRule) Risk() tracking.RiskLevel

type DOBlockAlterTableRule ¶

type DOBlockAlterTableRule struct{}

DOBlockAlterTableRule extracts ALTER TABLE statements from DO blocks This allows ALTER statements wrapped in IF NOT EXISTS checks to be consolidated with their corresponding CREATE TABLE statements

func (r *DOBlockAlterTableRule) Apply(lifecycle *tracking.ObjectLifecycle, engine ConsolidationEngine) (*tracking.ConsolidationResult, error)

func (r *DOBlockAlterTableRule) CanApply(lifecycle *tracking.ObjectLifecycle) bool

func (r *DOBlockAlterTableRule) Risk() tracking.RiskLevel

type DOBlockEnumTypeRule ¶

type DOBlockEnumTypeRule struct{}

DOBlockEnumTypeRule consolidates DO blocks that create ENUM types

func (r *DOBlockEnumTypeRule) Apply(lifecycle *tracking.ObjectLifecycle, engine ConsolidationEngine) (*tracking.ConsolidationResult, error)

func (r *DOBlockEnumTypeRule) CanApply(lifecycle *tracking.ObjectLifecycle) bool

func (r *DOBlockEnumTypeRule) Risk() tracking.RiskLevel

type DropCreateCycleRule ¶

type DropCreateCycleRule struct{}

DropCreateCycleRule handles DROP followed by CREATE consolidation This includes tables and views (DROP VIEW + CREATE VIEW → CREATE OR REPLACE VIEW)

func (r *DropCreateCycleRule) Apply(lifecycle *tracking.ObjectLifecycle, engine ConsolidationEngine) (*tracking.ConsolidationResult, error)

func (r *DropCreateCycleRule) CanApply(lifecycle *tracking.ObjectLifecycle) bool

func (r *DropCreateCycleRule) Risk() tracking.RiskLevel

type EnumDeduplicationRule ¶

type EnumDeduplicationRule struct{}

EnumDeduplicationRule detects and resolves duplicate ENUM type definitions This handles cases where multiple ENUMs with similar names or conflicting values exist

func (r *EnumDeduplicationRule) Apply(lifecycle *tracking.ObjectLifecycle, engine ConsolidationEngine) (*tracking.ConsolidationResult, error)

func (r *EnumDeduplicationRule) CanApply(lifecycle *tracking.ObjectLifecycle) bool

func (r *EnumDeduplicationRule) Risk() tracking.RiskLevel

type ErrorRecoveryRule ¶

type ErrorRecoveryRule struct {
	MaxRetries     int
	RecoveryMode   string // "conservative", "aggressive", "fallback"
	ValidateSQL    bool
	LogFailures    bool
	FailureMetrics map[string]int
	// contains filtered or unexported fields
}

ErrorRecoveryRule provides enhanced error recovery and validation for consolidation failures

func NewErrorRecoveryRule(maxRetries int, recoveryMode string, validateSQL bool) *ErrorRecoveryRule

func (rule *ErrorRecoveryRule) Apply(lifecycle *tracking.ObjectLifecycle, engine ConsolidationEngine) (*tracking.ConsolidationResult, error)

func (rule *ErrorRecoveryRule) CanApply(lifecycle *tracking.ObjectLifecycle) bool

func (rule *ErrorRecoveryRule) Risk() tracking.RiskLevel

type ExternalDependencyFilterRule ¶

type ExternalDependencyFilterRule struct {
	ExternalSchemas map[string]bool
	ExternalTables  map[string]bool
}

ExternalDependencyFilterRule filters out dependencies on external schemas

func NewExternalDependencyFilterRule() *ExternalDependencyFilterRule

func (r *ExternalDependencyFilterRule) Apply(lifecycle *tracking.ObjectLifecycle, engine ConsolidationEngine) (*tracking.ConsolidationResult, error)

func (r *ExternalDependencyFilterRule) CanApply(lifecycle *tracking.ObjectLifecycle) bool

func (r *ExternalDependencyFilterRule) Risk() tracking.RiskLevel

type FunctionDeduplicationRule ¶

type FunctionDeduplicationRule struct{}

FunctionDeduplicationRule consolidates duplicate function definitions

func (r *FunctionDeduplicationRule) Apply(lifecycle *tracking.ObjectLifecycle, engine ConsolidationEngine) (*tracking.ConsolidationResult, error)

func (r *FunctionDeduplicationRule) CanApply(lifecycle *tracking.ObjectLifecycle) bool

func (r *FunctionDeduplicationRule) Risk() tracking.RiskLevel

type MultipleCreateConsolidationRule ¶

type MultipleCreateConsolidationRule struct{}

MultipleCreateConsolidationRule handles multiple CREATE statements for the same object

func (r *MultipleCreateConsolidationRule) Apply(lifecycle *tracking.ObjectLifecycle, engine ConsolidationEngine) (*tracking.ConsolidationResult, error)

func (r *MultipleCreateConsolidationRule) CanApply(lifecycle *tracking.ObjectLifecycle) bool

func (r *MultipleCreateConsolidationRule) Risk() tracking.RiskLevel

type PublicationDeduplicationRule ¶

type PublicationDeduplicationRule struct{}

PublicationDeduplicationRule removes duplicate ALTER PUBLICATION ADD TABLE statements This prevents "relation X is already member of publication Y" errors during deployment

func (r *PublicationDeduplicationRule) Apply(lifecycle *tracking.ObjectLifecycle, engine ConsolidationEngine) (*tracking.ConsolidationResult, error)

func (r *PublicationDeduplicationRule) CanApply(lifecycle *tracking.ObjectLifecycle) bool

func (r *PublicationDeduplicationRule) Risk() tracking.RiskLevel

type RLSConsolidationRule ¶

type RLSConsolidationRule struct{}

RLSConsolidationRule consolidates Row Level Security operations

func (r *RLSConsolidationRule) Apply(lifecycle *tracking.ObjectLifecycle, engine ConsolidationEngine) (*tracking.ConsolidationResult, error)

func (r *RLSConsolidationRule) CanApply(lifecycle *tracking.ObjectLifecycle) bool

func (r *RLSConsolidationRule) Risk() tracking.RiskLevel

type RegisteredRule ¶

type RegisteredRule struct {
	Rule     ConsolidationRule
	Metadata RuleMetadata
}

RegisteredRule wraps a ConsolidationRule with metadata

type RegistryStats ¶

type RegistryStats struct {
	TotalRules      int
	EnabledRules    int
	DisabledRules   int
	RulesByCategory map[RuleCategory]int
	RulesByProvider map[string]int
}

RegistryStats provides statistics about the registry

type RuleCategory ¶

type RuleCategory string

RuleCategory represents the category of a consolidation rule

const (
	CategoryTableOps     RuleCategory = "table_operations"    // Table CREATE/ALTER consolidation
	CategoryFunctionOps  RuleCategory = "function_operations" // Function deduplication
	CategoryDeadCode     RuleCategory = "dead_code"           // Dead code removal
	CategorySecurity     RuleCategory = "security"            // RLS, policies, auth
	CategoryOptimization RuleCategory = "optimization"        // Performance optimizations
	CategoryExtension    RuleCategory = "extension"           // Extension-specific rules
	CategoryPluginAuth   RuleCategory = "plugin_auth"         // Plugin authentication patterns
	CategoryPluginORM    RuleCategory = "plugin_orm"          // ORM-specific patterns
)

type RuleMetadata ¶

type RuleMetadata struct {
	Name        string       // Unique rule name (e.g., "create_alter_consolidation")
	Description string       // Human-readable description
	Category    RuleCategory // Rule category for organization
	Priority    int          // Execution priority (higher = executed first)
	Provider    string       // Provider name (e.g., "core", "supabase", "clerk")
	Tags        []string     // Tags for filtering (e.g., "aggressive", "safe", "auth")
	Enabled     bool         // Whether rule is enabled
	Version     string       // Rule version for compatibility
}

RuleMetadata provides descriptive information about a consolidation rule

type RuleRegistry ¶

type RuleRegistry struct {
	// contains filtered or unexported fields
}

RuleRegistry manages dynamic rule registration with priorities and filtering

func GetRegistry() *RuleRegistry

func NewRuleRegistry(conflictPolicy ConflictPolicy) *RuleRegistry

func (r *RuleRegistry) Clear()

func (r *RuleRegistry) DisableRule(name string) error

func (r *RuleRegistry) EnableRule(name string) error

func (r *RuleRegistry) GetAllRules() []*RegisteredRule

func (r *RuleRegistry) GetApplicableRules(lifecycle *tracking.ObjectLifecycle) []*RegisteredRule

func (r *RuleRegistry) GetEnabledRules() []*RegisteredRule

func (r *RuleRegistry) GetRule(name string) (*RegisteredRule, error)

func (r *RuleRegistry) GetRulesByCategory(category RuleCategory) []*RegisteredRule

func (r *RuleRegistry) GetRulesByProvider(provider string) []*RegisteredRule

func (r *RuleRegistry) GetRulesByTag(tag string) []*RegisteredRule

func (r *RuleRegistry) GetStats() RegistryStats

func (r *RuleRegistry) Register(rule ConsolidationRule, metadata RuleMetadata) error

func (r *RuleRegistry) Unregister(name string) error

type SeparateAlterRule ¶

type SeparateAlterRule struct{}

SeparateAlterRule identifies ALTER statements that cannot be integrated into CREATE TABLE and must remain as separate statements. This includes RLS operations, column modifications, renames, owner changes, and schema changes.

This rule is critical for maintaining PostgreSQL execution order requirements: - RLS can only be enabled AFTER table exists - Column modifications require existing columns - Renames/ownership changes are administrative operations

func (r *SeparateAlterRule) Apply(lifecycle *tracking.ObjectLifecycle, engine ConsolidationEngine) (*tracking.ConsolidationResult, error)

func (r *SeparateAlterRule) CanApply(lifecycle *tracking.ObjectLifecycle) bool

func (r *SeparateAlterRule) Risk() tracking.RiskLevel

type TransactionBoundaryRule ¶

type TransactionBoundaryRule struct{}

TransactionBoundaryRule optimizes transaction boundaries for better performance

func (r *TransactionBoundaryRule) Apply(lifecycle *tracking.ObjectLifecycle, engine ConsolidationEngine) (*tracking.ConsolidationResult, error)

func (r *TransactionBoundaryRule) CanApply(lifecycle *tracking.ObjectLifecycle) bool

func (r *TransactionBoundaryRule) Risk() tracking.RiskLevel