bound-input function to be called in place of dom/input when you want to update the underlying state key by key. It assumes a component with Ident

bound-input

(ns credito.core
  (:require
    [cljs.pprint :refer [pprint]]
    [datascript.core :as d]
    [goog.dom :as gdom]
    [om.dom :as dom]
    [om.next :as om :refer-macros [defui]]
    ))

(enable-console-print!)

(def dado-inicial {
                   :operador [
                              {:id 1
                               :nome "geraldao"
                               :email "[email protected]"}
                              ]
                   :operadores-desativados [{:id 2
                                             :nome "maria"
                                             :email "[email protected]"}
                                            {:id 3
                                             :nome "joana"
                                             :email "[email protected]"}]
                   })

(defmulti read om/dispatch)

(defn pega-operadores
  [state key]
  (let [st @state]
    (into [] (map #(get-in st %)) (get st key))))

(defmethod read :operador
  [{:keys [state] :as env} key params]
  {:value (pega-operadores state key)})

(defmethod read :operadores-desativados
  [{:keys [state] :as env} key params]
  {:value (pega-operadores state key)})

;; (defmethod read :default
;;   [{:keys [state] :as env} key params]
;;   (let [st @state]
;;     (if-not (sequential? key)
;;       {:value (get st key :not-found)}
;;       {:value (get-in st key :not-found)})))

(defmulti mutate om/dispatch)

(defmethod mutate 'app/assoc-in
  [{:keys [state] :as env} key {:keys [ref new-value ident]}]
  {:value ident
   :action #(swap! state assoc-in (conj ident ref) new-value)})


(defn bound-input
  [parent {:keys [className ref value mutate-key]
           :as attrs
           :or {className "form-control"
                mutate-key 'app/assoc-in}}]
  {:pre [(and (some? ref)
              (find attrs :value))]}
  (dom/input
    (js-obj
      "className" className
      "ref" ref
      "value" value
      "onChange"
      (fn [e]
        (om/transact!
          parent
          [`(~mutate-key
              ~{:ref ref
                :new-value (.-value (dom/node parent ref))
                :ident (om/ident parent (om/props parent))})])))))

(defui Operador
  static om/Ident
  (ident [this {:keys [id]}]
         [:operador/por-id id])
  static om/IQuery
  (query [this]
         '[:id :nome :email])
  Object
  (render [this]
          (let [{:keys [nome email]} (om/props this)]
            (dom/form
              nil
              (dom/div
                #js {:className "form-group"}
                (dom/label nil "Nome")
                (bound-input this {:ref :nome :value nome}))
              (dom/div
                #js {:className "form-group"}
                (dom/label nil "Email")
                (bound-input this {:ref :email :value email}))
              (dom/button
                #js
                {:className "btn"
                 :type "button"
                 :onClick (fn [e]
                            (let [reg (om/props this)]
                              (println reg)))}
                "Gravar")))))

(def operador (om/factory Operador {:keyfn :id}))

(defmethod mutate 'app/adiciona-desativado
  [{:keys [state]} _ operador]
  (let [i (om/ident Operador operador)]
    {:value [:operadores-desativados]
     :action #(swap! state
                     (fn [st]
                       (-> st
                           (assoc-in i operador)
                           (update :operadores-desativados conj i))))}))

(defui CreditoApp
  static om/IQuery
  (query [this]
         (let [q-operador (om/get-query Operador)]
           `[{:operador ~q-operador}
             {:operadores-desativados ~q-operador}]))
  Object
  (render [this]
          (let [{operadores :operador
                 desativados :operadores-desativados} (om/props this)]
            (dom/div nil
                     (dom/h2 nil "App")
                     (dom/h4 nil "Operador")
                     ;; (println (first operadores))
                     (operador (first operadores))

                     (dom/h4 nil "Operadores Desativados")
                     (apply dom/div
                            nil
                            (map #(operador %) desativados))))))

(def reconciler
  (om/reconciler
    {:state dado-inicial
     :parser (om/parser {:read read :mutate mutate})}))

(om/add-root! reconciler
              CreditoApp (gdom/getElement "app"))