 
 (defn row-get [{:keys [table] :as env} row attr]
   (read-from (assoc env :row row :ast {:key attr :dispatch-key attr})
-    (:fields-getters table)))
+    (::reader-map table)))
 
 (defn parse-row [{:keys [table ast ::union-selector] :as env} row]
   (let [row' {:db/table (:key table) :db/id (row-get env row :db/id)}
-        readers [(:fields-getters table) placeholder-node]
+        readers [(::reader-map table) placeholder-node]
         ast (if (union-children? ast)
               (some-> ast :query (get (row-get env row union-selector)) (om/query->ast))
               ast)]
     (-> (reduce (fn [row' {:keys [key] :as ast}]
-                  (assoc row' key (read-from (assoc env :ast ast :row row) readers)))
+                  (if (contains? #{:db/id :db/table} key)
+                    row'
+                    (assoc row' key (read-from (assoc env :ast ast :row row) readers))))
                 row'
                 (:children ast))
         (read-chan-values))))

  (zipmap (keys schema)
          (map #(let [m (:fields %)]
                 (assoc %
                   :fields-getters
                   (zipmap (keys m)
                           (map
                             (fn [field]


(defn row-getter [schema k f]
  (let [table (keyword (namespace k))]
    (assoc-in schema [table ::reader-map k] f)))

(def db-specs
  (-> (prepare-schema
