Our bb.edn

bb.edn

{:paths [#_"bin" "src/clj" "resources" "env/ion/resources"]
 :deps {}
 :tasks
 {:requires ([clojure.string :as str]
             [yada.util.date :as date])

  :init (do
          (defn eshell [& args]
            (let [s-args (str/join " " (map str/trimr args))]
              (println s-args (str "  <" (date/now->dh) ">"))
              (apply shell args))))

  -config {:extra-deps {cprop/cprop {:mvn/version "0.1.17"}}
           :requires ([yada.util.env :as env])}

  -config-app {:depends [-config -env-key]
               :task (:yada (env/get-config {} -env-key))}

  ;; Sometimes depended-upon command line arguments

  -args-str
  (str/join " " *command-line-args*)

  -args-rest-str
  (str/join " " (rest *command-line-args*))

  -arg1-env
  {:depends [-envs-names]
   :requires ([clojure.edn :as edn])
   :task (let [env (some-> *command-line-args* first edn/read-string)]
           (assert env (str "First argument must set environment among: " -envs-names))
           env)}

  -arg2-search-rg
  {:web "https://github.com/BurntSushi/ripgrep/blob/master/GUIDE.md"
   :task (let [sp (some-> *command-line-args* second)]
           (assert sp (str "Second argument must be ripgrep's search pattern"))
           sp)}

  ;; Constants

  -envs-names    {:depends [-config]   :task (env/get-envs-names)} ; ":local, :sone, :demo"
  -env-key       {:depends [-arg1-env] :task -arg1-env}            ;  :local
  -env-name      {:depends [-env-key]  :task (name -env-key)}      ;  "local"

  -deps-alias    {:depends [-config-app] :task (-> -config-app :bin :deps-alias)}
  -deps-main     {:depends [-config-app] :task (-> -config-app :bin :deps-main)}

  -system        {:depends [-config-app] :task (-> -config-app :ion :system)}
  -app           {:depends [-config-app] :task (-> -config-app :ion :app)}
  -compute-group {:depends [-config-app] :task (-> -config-app :ion :compute-group-primary)}

  ;; Tasks

  d
  {:doc "DEPLOY"}

  d-backend
  {:doc "Deploy the  backend in the selected environment"
   :web "https://console.aws.amazon.com/amplify/home?region=us-east-1#/"
   :depends [-config-app -env-key -deps-main -env -env-name -args-rest-str -compute-group]
   :task (case -env-key
           :local (eshell (str "clojure " -deps-main " -e \"(start/start!)\""))
           #_else (eshell (str "clojure -M:only/bin -m d-backend "
                               " --group " -compute-group
                               " --creds-profile " -env-name
                               " --preheat-url " (-> -config-app :ops :url-ops-version)
                               " " -args-rest-str " ")))}

  d-frontend
  {:doc "Deploy the frontend in the selected environment"
   :web "https://console.aws.amazon.com/amplify/home?region=us-east-1#/"
   :depends [-env-key -config-app]
   :task (case -env-key
           :local (eshell "bin/d_frontend.clj")
           #_else (eshell (str "curl -X POST -d {} \""
                               "https://webhooks.amplify.us-east-1.amazonaws.com/prod/webhooks?id="
                               (-> -config-app :aws :amplify-webhook-id)
                               "&token="
                               (-> -config-app :aws :amplify-webhook-token)
                               "&operation=startbuild"
                               "\" -H \"Content-Type:application/json\"")))}

  runecho
  {:doc "Runs and echoes (prints) the result of running another task"
   :depends [-args-rest-str]
   :task (eshell "bb run --prn " (first *command-line-args*) -args-rest-str)}

  s
  {:doc "SETUP"}

  s-bootstrap
  {:doc "Setup fundamental dev tools (also run when rebuilding container)"
   :task (eshell "bin/s-bootstrap.sh")}

  s-check
  {:doc "Setup: test if fundamental dev tools are properly setup"
   :task (eshell "bin/s-check.sh")}

  s-deps
  {:doc "Setup: download deps in advance"
   :task (eshell "bin/s-deps.clj")}

  s-more
  {:doc "Setup: show more options"
   :task (shell "echo" "See https://media4.giphy.com/media/2bLAdm3jWPDsQ/giphy.gif")}


  t
  {:doc "TUNNEL"}

  t-db
  {:doc "Tunnel from local port 8182 to compute instance (Socks)"
   :web "https://docs.datomic.com/cloud/getting-started/get-connected.html"
   :depends [-system -env-name]
   :task (eshell "datomic" "client" "access" -system "--profile" -env-name)}

  t-db-check
  {:doc "Tunnel: test if t-db is currently open"
   :web "https://docs.datomic.com/cloud/getting-started/get-connected.html"
   :depends [-system -config-app]
   :task (eshell "curl -x"
                 "socks5h://localhost:8182"
                 (-> -config-app :db :client :endpoint))}

  t-repl
  {:doc "Tunnel from local port 7000 to compute instance (nREPL)"
   :web "https://console.aws.amazon.com/ec2/v2/home?region=us-east-1#Instances:instanceState=running"
   :depends [-config-app]
   :task (let [kf (-> -config-app :tunnel :ssh-key-path)
               ci (-> -config-app :tunnel :ec2-compute-private-ipv4-address)
               bi (-> -config-app :tunnel :ec2-bastion-public-ipv4-dns)]
           (shell "chmod" "600" kf)
           (eshell "ssh"
                   (str "-i" kf)
                   (str "-L 7000:" ci ":7000")
                   (str "ec2-user@" bi)))}
  ;; Get ahold of `datomic-cloud-yada-*.pem` by asking Daniel or Samuel to give them to you!
  ;; The above ec2 ipv4 values will be out of date when we stand up newer stacks or instances...
  ;; When the compute instance changes, we will also need to set it up again for SSH access on port 7000.
  ;; For compute instance, see https://github.com/markbastian/replion#system-modifications
  ;; For bastion instance, see https://github.com/markbastian/replion#set-up-ssh-tunnel-through-your-bastion


  u
  {:doc "UTILITY"}

  u-deps-graph
  {:doc "Utility to graph the dependencies to a PNG image (for depl. envs; broken in dev)"
   :web "https://github.com/practicalli/clojure-deps-edn#project-dependencies"
   :depends [-deps-alias]
   :task (let [filename "project-dependencies-graph.png"]
           (clojure -deps-alias "-X:project/graph-deps")
           (eshell "code" filename))}

  u-deps-outdated
  {:doc "Utility to list outdated dependencies across all envs"
   :task (clojure "-M:project/outdated --exclude=com.datomic/dev-local")}

  u-deps-search
  {:doc "Utility to search through deps        across all envs (w/ query or fuzzy)"
   :web "https://github.com/BurntSushi/ripgrep/blob/master/GUIDE.md"
   :task (if-let [q (first *command-line-args*)]
           (eshell "bin/u-deps-search-rg-col.sh" q)
           (eshell "bin/u-deps-search-fz.sh"))}

  u-deps-tree-search
  {:doc "Utility to search through deps tree   across all envs (w/ query or fuzzy)"
   :web "https://github.com/BurntSushi/ripgrep/blob/master/GUIDE.md"
   :task (if-let [q (first *command-line-args*)]
           (eshell "bin/u-deps-tree-search-rg.sh" q)
           (eshell "bin/u-deps-tree-search-fz.sh"))}}}

(comment
  ;; May be useful later
  ;; -------------------

  #_(let [res (sh "yarn" :dir "frontend")]
      (if (= 0 (:exit res))
        (println (str "✅" \newline (:out res)))
        (println (str "❌" \newline (:err res)))))

  -clojure-files (fs/glob "clj" "**.clj")
  -classes-dir (let [dir "target/classes"]
                 (fs/create-dirs dir)
                 dir)

  z-req {:requires ([srcfile])
         :task (srcfile/some-fn 1 2 3)}

  ;; Maintenance tasks
  z-clean {:doc "Clean"
           :requires ([babashka.fs :as fs])
           :task (do (fs/delete-tree "target")
                     (fs/delete-tree "public/otherthng")
                     nil)}
  z-classes {:depends [-classes-dir -clojure-files]
             :task (when-let [modified (fs/modified-since -classes-dir -java-files)]
                     (prn :modified (map str modified))
                     (println "Compiling java")
                     (apply shell "javac" "-d" -classes-dir modified))}
  z-classes2 {:depends [-classes-dir -clojure-files]
              :task (let [jar-file "target/foo.jar"]
                      (when-let [modified (seq (concat (fs/modified-since -classes-dir -java-files)
                                                       (fs/modified-since -classes-dir -java-files)))]
                        (println "Packaging")
                        (if (fs/exists? jar-file)
                          (apply shell "jar uf" jar-file modified)
                          (shell "jar cf"       jar-file -classes-dir))))}

  ;; Development tasks
  z-onething {:doc "z-onething"
              :task (do
                      (shell "ls")
                      (shell "ls -l")
                      (run 'z-req))}
  z-otherthng {:depends [z-onething]
               :doc "Other thing"
               :task (clojure "-M:frontend watch ontolog")}

  -z-parathing {:depends [z-onething z-otherthng]}
  z-parathing {:doc "Run both things in parallel"
               :task (run '-z-parathing {:parallel true})}

  ;; Deployment tasks
  z-both:blah (do (run 'first)
                  (run 'second))

  ;; File watching tasks
  z-generate   {:doc  "Re-generate index.html"
                :task (load-file "generate.clj")}
  -z-fswatcher {:requires ([babashka.pods :as pods])
                :task     (do (pods/load-pod 'org.babashka/fswatcher "0.0.1")
                              (require '[pod.babashka.fswatcher :as fw]))}
  z-watch      {:doc     "Watch changes in generate.clj and re-generate index.html on each change"
                :depends [-z-fswatcher]
                :task
                (do  (fw/watch "generate.clj" (fn [_]
                                                (run 'generate)))
                          ;; don't exit task
                     (deref (promise)))})

tasks-print-out

❯ bb tasks
The following tasks are available:

d                  DEPLOY
d-backend          Deploy the  backend in the selected environment
d-frontend         Deploy the frontend in the selected environment
runecho            Runs and echoes (prints) the result of running another task
s                  SETUP
s-bootstrap        Setup fundamental dev tools (also run when rebuilding container)
s-check            Setup: test if fundamental dev tools are properly setup
s-deps             Setup: download deps in advance
s-more             Setup: show more options
t                  TUNNEL
t-db               Tunnel from local port 8182 to compute instance (Socks)
t-db-check         Tunnel: test if t-db is currently open
t-repl             Tunnel from local port 7000 to compute instance (nREPL)
u                  UTILITY
u-deps-graph       Utility to graph the dependencies to a PNG image (for depl. envs; broken in dev)
u-deps-outdated    Utility to list outdated dependencies across all envs
u-deps-search      Utility to search through deps        across all envs (w/ query or fuzzy)
u-deps-tree-search Utility to search through deps tree   across all envs (w/ query or fuzzy)

Where is yada.util.data coming from? Does this have anything to do with the yada framework?

Where is yada.util.data coming from? Does this have anything to do with the yada framework?

@borkdude btw it's date, not data. It's an util that comes from our app's main codebase.
We also use our new yada.util.env to expose our app's config to the tasks:

BTW yada is the pre-alpha product we're developing...

Thanks for clarifying!