feat: detect circular interface implements chains

- interface implementing itself is caught in compile-type :interface
- indirect cycles (A->B->C->A) caught in prepare-and-validate-interfaces
  by checking if an interface appears in its own transitive implements set

🤖 Generated with [eca](https://eca.dev)

Co-Authored-By: eca-agent <git@eca.dev>

Author: hlship

src/com/walmartlabs/lacinia/schema.clj

@@ -1584,20 +1584,25 @@
 
 (defmethod compile-type :interface
   [interface schema]
-  (let [implements (->> interface :implements (map as-keyword) set)]
+  (let [interface-name (:type-name interface)
+        implements (->> interface :implements (map as-keyword) set)]
     (doseq [iface-name implements
             :let [type (get schema iface-name)]]
+      (when (= iface-name interface-name)
+        (throw (ex-info (format "Interface %s cannot implement itself."
+                          (q iface-name))
+                 {:interface interface-name})))
       (when-not type
         (throw (ex-info (format "Interface %s implements interface %s, which does not exist."
-                          (-> interface :type-name q)
+                          (q interface-name)
                           (q iface-name))
-                 {:interface (:type-name interface)
+                 {:interface interface-name
                   :schema-types (type-map schema)})))
       (when-not (= :interface (:category type))
         (throw (ex-info (format "Interface %s implements type %s, which is not an interface."
-                          (-> interface :type-name q)
+                          (q interface-name)
                           (q iface-name))
-                 {:interface (:type-name interface)
+                 {:interface interface-name
                   :schema-types (type-map schema)}))))
     (->> interface
       map->Interface
@@ -1787,6 +1792,14 @@
   [schema]
   (let [objects (types-with-category schema :object)
         interfaces (types-with-category schema :interface)
+        ;; Detect cycles in the interface implements graph before doing anything else.
+        _ (doseq [interface interfaces
+                  :let [interface-name (:type-name interface)
+                        transitive (all-implemented-interfaces schema interface-name)]]
+            (when (transitive interface-name)
+              (throw (ex-info (format "Interface %s is part of a circular implements chain."
+                                (q interface-name))
+                       {:interface interface-name}))))
         ;; Expand each object's :implements set to include transitively-inherited interfaces.
         ;; This is needed so check-compatible [:interface :object] works when an object only
         ;; directly lists a sub-interface but not its parent interfaces.

test/com/walmartlabs/interface_test.clj

@@ -134,6 +134,33 @@
        :parent-interface-name :node}
       (compile invalid-schema))))
 
+(deftest interface-circular-implements-fails
+  (testing "direct cycle (A implements B, B implements A)"
+    (let [invalid-schema '{:interfaces {:A {:implements [:B]
+                                            :fields {:id {:type String}}}
+                                        :B {:implements [:A]
+                                            :fields {:id {:type String}}}}}]
+      (is (thrown-with-msg? Throwable #"circular implements chain"
+                            (compile invalid-schema)))))
+
+  (testing "indirect cycle (A implements B, B implements C, C implements A)"
+    (let [invalid-schema '{:interfaces {:A {:implements [:B]
+                                            :fields {:id {:type String}}}
+                                        :B {:implements [:C]
+                                            :fields {:id {:type String}}}
+                                        :C {:implements [:A]
+                                            :fields {:id {:type String}}}}}]
+      (is (thrown-with-msg? Throwable #"circular implements chain"
+                            (compile invalid-schema))))))
+
+(deftest interface-cannot-implement-itself
+  (let [invalid-schema '{:interfaces {:node {:implements [:node]
+                                             :fields {:id {:type String}}}}}]
+    (expect-exception
+      "Interface `node' cannot implement itself."
+      {:interface :node}
+      (compile invalid-schema))))
+
 (deftest interface-implements-non-interface-fails
   ;; :resource tries to implement :article which is an object, not an interface
   (let [invalid-schema '{:interfaces {:node {:fields {:id {:type String}}}