         (let [[expr cb] (de-alias-expression expr cb)
               ast (om-parser/expr->ast expr)]
           (cond
-            ;; Also :route/projects (but a separate expression for analytics, which
-            ;; doesn't actually need to hit the server)
-            (and (= :circleci/organization (:key ast))
-                 (= '[:organization/name] (:query ast)))
-            (let [{:keys [organization/vcs-type organization/name]} (:params ast)]
-              (cb {:circleci/organization {:organization/name name}} query))
-
-            ;; :route/workflow
-            (project-runs-ast? ast)
-            (let [{:keys [connection/offset connection/limit]}
-                  (:params (expr-ast/get-in ast [:organization/project :routed-page]))]
-              (merge-workflow-runs {:organization/vcs-type (-> ast :params :organization/vcs-type)
-                                    :organization/name (-> ast :params :organization/name)
-                                    :project/name (-> ast
-                                                      (expr-ast/get :organization/project)
-                                                      :params
-                                                      :project/name)}
-                                   offset
-                                   limit
-                                   cb
-                                   query))
-
             ;; :route/run
             (let [{:keys [key children]} ast]
               (and (= :circleci/run key)

       ;; Wrap the callback to rename the key in the result back to the alias.
       #(cb (rename-keys %1 {aliased-from (:key ast)}) %2)]
      [expr cb])))

(defn- merge-workflow-runs
  [{vcs-type :organization/vcs-type
    org-name :organization/name
    project-name :project/name}
   offset
   limit
   merge-fn
   query]
  (api/get-project-workflows
   (callback-api-chan
    (fn [response]
      (let [novelty {:circleci/organization
                     {:organization/project
                      {:project/name project-name
                       :project/organization {:organization/vcs-type vcs-type
                                              :organization/name org-name}
                       :routed-page {:connection/total-count (:total-count response)
                                     :connection/edges (->> (:results response)
                                                            (map adapt-to-run)
                                                            (mapv #(hash-map :edge/node %)))}}}}]
        (merge-fn novelty query))))
   (vcs-url/vcs-url vcs-type org-name project-name)
   {:offset offset :limit limit}))

(def ^:private ignore-response-callback (fn [_response] nil))


                                           :project/parallelism
                                           :project/oss?]}
                  {:organization/plan [*]}]
                (:query ast)))
        (project-runs-ast? ast))))

(defmulti send* key)

