feat: Add enum support with context-aware breaking change detection (#46)

* feat: Add enum support with context-aware breaking change detection

Implements detection of JSON Schema enum changes, resolving issue #38.

Changes:
- Add EnumAdd and EnumRemove change types with context flags
- Track whether enum constraint is being added/removed entirely
- Smart breaking change logic:
  - Adding values to existing enum: non-breaking (accepts more)
  - Removing values from existing enum: breaking (rejects data)
  - Adding enum constraint: breaking (restricts values)
  - Removing enum constraint: non-breaking (relaxes values)
- Comprehensive test coverage with 9 test cases including the real-world
  scenario from the original issue

Fixes #38

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

Co-Authored-By: Claude <noreply@anthropic.com>

* fix screwed up merge

---------

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Markus Unterwaditzer <markus-tarpit+git@unterwaditzer.net>

Author: 3 people

src/diff_walker.rs

@@ -387,6 +387,39 @@ impl<F: FnMut(Change)> DiffWalker<F> {
         }
     }
 
+    fn diff_enum(&mut self, json_path: &str, lhs: &mut SchemaObject, rhs: &mut SchemaObject) {
+        let lhs_enum = lhs.enum_values.as_deref().unwrap_or(&[]);
+        let rhs_enum = rhs.enum_values.as_deref().unwrap_or(&[]);
+        let lhs_has_no_enum = lhs.enum_values.is_none();
+        let rhs_has_no_enum = rhs.enum_values.is_none();
+
+        // Find removed enum values (in lhs but not in rhs)
+        for lhs_value in lhs_enum {
+            if !rhs_enum.contains(lhs_value) {
+                (self.cb)(Change {
+                    path: json_path.to_owned(),
+                    change: ChangeKind::EnumRemove {
+                        removed: lhs_value.clone(),
+                        rhs_has_no_enum,
+                    },
+                });
+            }
+        }
+
+        // Find added enum values (in rhs but not in lhs)
+        for rhs_value in rhs_enum {
+            if !lhs_enum.contains(rhs_value) {
+                (self.cb)(Change {
+                    path: json_path.to_owned(),
+                    change: ChangeKind::EnumAdd {
+                        added: rhs_value.clone(),
+                        lhs_has_no_enum,
+                    },
+                });
+            }
+        }
+    }
+
     fn diff_pattern(&mut self, json_path: &str, lhs: &mut SchemaObject, rhs: &mut SchemaObject) {
         let lhs_pattern = &lhs.string().pattern;
         let rhs_pattern = &rhs.string().pattern;
@@ -594,6 +627,7 @@ impl<F: FnMut(Change)> DiffWalker<F> {
         }
         self.diff_const(json_path, lhs, rhs);
         self.diff_format(json_path, lhs, rhs);
+        self.diff_enum(json_path, lhs, rhs);
         self.diff_pattern(json_path, lhs, rhs);
         self.diff_min_length(json_path, lhs, rhs);
         self.diff_max_length(json_path, lhs, rhs);

src/types.rs

@@ -124,6 +124,22 @@ pub enum ChangeKind {
         /// The new format value.
         new_format: String,
     },
+    /// An enum value has been added to the allowed values.
+    EnumAdd {
+        /// The value that was added to the enum.
+        added: serde_json::Value,
+        /// Whether the enum constraint was added (lhs had no enum).
+        /// If true, this is breaking as it adds a new constraint.
+        lhs_has_no_enum: bool,
+    },
+    /// An enum value has been removed from the allowed values.
+    EnumRemove {
+        /// The value that was removed from the enum.
+        removed: serde_json::Value,
+        /// Whether the entire enum constraint was removed (rhs has no enum).
+        /// If true, this is non-breaking as it relaxes the constraint.
+        rhs_has_no_enum: bool,
+    },
     /// A pattern constraint has been added.
     PatternAdd {
         /// The pattern that was added.
@@ -221,6 +237,16 @@ impl ChangeKind {
             Self::FormatAdd { .. } => true,
             Self::FormatRemove { .. } => false,
             Self::FormatChange { .. } => true,
+            // EnumAdd is breaking only if it adds a new enum constraint (lhs had no enum).
+            // Adding values to an existing enum is non-breaking (accepts more data).
+            Self::EnumAdd {
+                lhs_has_no_enum, ..
+            } => *lhs_has_no_enum,
+            // EnumRemove is breaking if removing values from a surviving enum constraint.
+            // Removing the entire enum constraint is non-breaking (accepts more data).
+            Self::EnumRemove {
+                rhs_has_no_enum, ..
+            } => !rhs_has_no_enum,
             // Pattern changes are conservatively treated as breaking.
             // Determining if one regex is a subset of another requires complex analysis.
             Self::PatternAdd { .. } => true,

tests/fixtures/enum/add.json

@@ -0,0 +1,10 @@
+{
+  "lhs": {
+    "type": "string",
+    "enum": ["error", "warning", "info"]
+  },
+  "rhs": {
+    "type": "string",
+    "enum": ["error", "warning", "info", "debug"]
+  }
+}

tests/fixtures/enum/add_and_remove.json

@@ -0,0 +1,10 @@
+{
+  "lhs": {
+    "type": "string",
+    "enum": ["error", "warning", "debug"]
+  },
+  "rhs": {
+    "type": "string",
+    "enum": ["error", "info", "debug"]
+  }
+}

tests/fixtures/enum/add_constraint.json

@@ -0,0 +1,9 @@
+{
+  "lhs": {
+    "type": "string"
+  },
+  "rhs": {
+    "type": "string",
+    "enum": ["error", "warning", "info"]
+  }
+}

tests/fixtures/enum/mixed_types.json

@@ -0,0 +1,8 @@
+{
+  "lhs": {
+    "enum": ["error", 1, null, true]
+  },
+  "rhs": {
+    "enum": ["error", 1, null, true, "warning"]
+  }
+}

tests/fixtures/enum/number_values.json

@@ -0,0 +1,10 @@
+{
+  "lhs": {
+    "type": "integer",
+    "enum": [1, 2, 3]
+  },
+  "rhs": {
+    "type": "integer",
+    "enum": [1, 2, 3, 4]
+  }
+}

tests/fixtures/enum/real_world_event_type.json

@@ -0,0 +1,10 @@
+{
+  "lhs": {
+    "type": "string",
+    "enum": ["expectct", "expectstaple", "transaction", "default"]
+  },
+  "rhs": {
+    "type": "string",
+    "enum": ["expectct", "expectstaple", "transaction", "default", "generic"]
+  }
+}

tests/fixtures/enum/remove.json

@@ -0,0 +1,10 @@
+{
+  "lhs": {
+    "type": "string",
+    "enum": ["error", "warning", "info", "debug"]
+  },
+  "rhs": {
+    "type": "string",
+    "enum": ["error", "warning", "info"]
+  }
+}

tests/fixtures/enum/remove_constraint.json

@@ -0,0 +1,9 @@
+{
+  "lhs": {
+    "type": "string",
+    "enum": ["error", "warning", "info"]
+  },
+  "rhs": {
+    "type": "string"
+  }
+}