Merge branch 'ys/fix-analyzing-order'

src/alumbra/analyzer.clj

@@ -2,6 +2,7 @@
   (:require [alumbra.analyzer
              [directives :as directives]
              [enums :as enums]
+             [implementations :as implementations]
              [kinds :as kinds]
              [scalars :as scalars]
              [schema-root :as schema-root]
@@ -29,6 +30,7 @@
         (types/analyze schema)
         (unions/analyze schema)
         (kinds/aggregate)
+        (implementations/aggregate)
         (valid-fragment-spreads/aggregate))
     schema))
 

src/alumbra/analyzer/implementations.clj

@@ -0,0 +1,15 @@
+(ns alumbra.analyzer.implementations)
+
+(defn aggregate
+  [{:keys [interfaces types] :as schema}]
+  (reduce
+    (fn [schema {:keys [type-name implements]}]
+      (reduce
+        (fn [schema interface-name]
+          (cond-> schema
+            (contains? interfaces interface-name)
+            (update-in [:interfaces interface-name :implemented-by]
+                       conj
+                       type-name)))
+        schema implements))
+    schema (vals types)))

src/alumbra/analyzer/types.clj

@@ -51,12 +51,7 @@
         (update-in
           [:types implementing-type-name :implements]
           conj
-          type-name)
-        (contains? interfaces type-name)
-        (update-in
-          [:interfaces type-name :implemented-by]
-          conj
-          implementing-type-name)))
+          type-name)))
     data implements))
 
 ;; ## Types

test/alumbra/analyzer_test.clj

@@ -30,3 +30,17 @@
            (-> (get-in schema [:types "QueryRoot" :fields]) keys set)))
     (is (= "QueryRoot"
            (get-in schema [:schema-root :schema-root-types "query"])))))
+
+(deftest t-analyzer-interface-implementations
+  (let [declaration          "interface SomeInterface { x: Int }"
+        implementation       "type SomeType implements SomeInterface { x: Int }"
+        declaration-first    (analyze [declaration implementation])
+        implementation-first (analyze [implementation declaration])
+        implemented-by       #(get-in % [:interfaces "SomeInterface" :implemented-by])
+        implements           #(get-in % [:types "SomeType" :implements])]
+    (is (= (implemented-by declaration-first)
+           (implemented-by implementation-first)
+           #{"SomeType"}))
+    (is (= (implements declaration-first)
+           (implements implementation-first)
+           #{"SomeInterface"}))))