         fields (-> schema :queryType :fields)
         idents (filter (comp ident-map :name) fields)]
     (-> {}
-        (into (mapcat (fn [{:keys [type name]}]
+        (into (mapcat (fn [{:keys [name type]}]
                         (let [params        (get ident-map name)
                               ident-key     (keyword (kebab-case name) (kebab-case (str/join "-and-" (keys params))))
-                              entity-fields (mapv (fn [[entity attr]] (entity-field-key prefix entity attr)) (vals params))
+                              entity-fields (mapv (fn [item] (ident-map-entry prefix item)) (vals params))
                               entity-field  (cond-> entity-fields (= 1 (count entity-fields)) first)
-                              fields        (-> (get index-io #{(type-key prefix (:name type))})
+                              fields        (-> (get index-io #{(ffirst (type->field-entry prefix type))})
                                                 keys)]
                           (mapv (fn [field]
                                   [field {::entity-field entity-field


(defn index-idents [{::keys [prefix ident-map]}]
  (into #{}
        (map #(apply entity-field-key prefix %))
        (->> (vals ident-map)
             (filterv #(= 1 (count %)))
             (map vals)

                (mapcat (fn [{:keys [type name]}]
                          (let [params    (get ident-map name)
                                input-set (ident-map-params->io input params)
                                fields    (-> (get index-io #{(ffirst (type->field-entry prefix type))}) keys)]
                            (mapv (fn [field]
                                    [field {input-set #{resolver}}])
                              fields)))))
