    (let [prop-specs         (take-while vector? forms)
          props              (p/parse (first prop-specs))
          computed           (p/parse (second prop-specs))
-         fns                (drop-while vector? forms)
-         fns-aliased        (map resolve-fn-alias fns)
-         fns-with-query     (maybe-generate-query-fn fns-aliased props)
-         fns-with-args      (map maybe-inject-fn-args fns-with-query)
-         fns-with-names     (map normalize-fn-name fns-with-args)
-         fns-with-props     (map #(inject-props % props computed)
-                                 fns-with-names)
+         fns-with-props     (->> (drop-while vector? forms)
+                                 (maybe-generate-ident-fn props)
+                                 (maybe-generate-key-fn props)
+                                 (maybe-generate-query-fn props)
+                                 (map resolve-fn-alias)
+                                 (map maybe-inject-fn-args)
+                                 (map normalize-fn-name)
+                                 (map #(inject-props % props computed)))
          factory-fns        (filter #(= (fn-scope %) :factory)
                                     fns-with-props)
          factory-params     (zipmap (map (comp keyword first)

  (let [alias (fn-alias f)]
    `(~alias ~@body)))

(defn maybe-generate-query-fn
  "If (query ...) is missing from fns, it is generated automatically
   from the props spec."
  [fns props]
  (cond-> fns
    (not (some '#{query} (map first fns)))
    (conj (generate-query-fn props))))

(defn raw-fn?

            [workflo.macros.util.string :refer [camel->kebab]]))

;;;; Om Next query generation

(def fn-specs
  "Function specifications for all functions that are not Object
