It depends a bit on your requirements. EDN is definitely a sane choice, as it covers all of Clojure’s data structures. Choose JSON if you need to play nice with other technology as well, e.g. using a REST client to test API calls. It also has the added benefit of being supported by browser development tools without any extensions. Transit is a library that allows to transfer EDN in a more efficient (compact) way, piggy-backing on JSON or msgpack. Consider using Muuntaja, which is a library and middleware for Ring that supports content negotiation. This allows you to encode your data to JSON, EDN, or Transit transparently depending on the client’s Accept headers. This way you can get the best of multiple worlds.

https://github.com/metosin/muuntaja

I recently heard an episode of #clojuredesign-podcast where @U5FV4MJHG and @U0510902N were discussing this topic. I believe the library https://github.com/ptaoussanis/sente was one of the main focal points of the episode. It was during the miniseries on web development; episodes 63-74. I don’t recall which exact episode it was. All the episodes are available https://clojuredesign.club.

here's how cljdoc does it https://github.com/cljdoc/cljdoc/blob/master/src/cljdoc/server/system.clj#L111

ah so a similarly simple approach haha; thank you

As a substitute to ORM I'd try approaching it from a domain model first, like start from a spec, then use it to programmatically define the database interface and functions to operate on it. Just imagine mapping the spec's namespace to a table and name to a column, for a relational model

I assume you 120% sure that you need database-agnostic layer. This is very important from my point of view because I never saw a real necessity to have it. then you can define an interface with methods that reflect what you want to do with the data. like save-user or find-top-hits etc. then focus on implementations for the target databases. Libraries like integrant, component or mount will help in the future to organise your codebase.

@U04V4KLKC Yeah, I see your point that it is probably unnecessary in most cases and falls into the category of “intellectually satisfying over-engineering.” I’m asking because I find it easier to work with files on disk during development without thinking about running a database under localhost, managing database connections, etc. Then I can create simple files on disk that “fake” the data which would have been returned from a database connection in production. Knowing how an experienced Clojure developer would approach a problem like this also helps solidify my understanding of how to “think in Clojure.”

@UK0810AQ2 When you say “domain model” and “starting from a spec,” do you mean defining the basic data structures (e.g., maps) which are required to represent the “entities” in the system, then adding specs to those data structures to express the “schema” (for lack of a better term) of the keys and values (including nested data structures) within said data structures? I’m reminded of https://www.youtube.com/watch?v=Tb823aqgX_0 by @U0JUR9FPH.

@U01PE7630AC thinking of something like:

(s/def :user/id int?)
(s/def :user/name string?)
(s/def ::user (s/keys :req [:user/id :user/name]))

(s/def :bundle/id int?)
(s/def :bundle/owner ::user) ;; foreign key?
(s/def ::bundle (s/keys :req [::bundle/id :bundle/owner]))

Oh, I see! Thanks for the example. I haven’t gotten a grasp of spec yet, but that seems to make sense.

@U01PE7630AC usually I recommend to keep development environment as close to production as possible. So if your application suppose to talk with postgres database it also suppose to handle all possible problems that can happen because of connection problems or db locks etc. You can mock responses from database using files on disk but that covers only "happy path" (I'm saying this with 90% confidence because for sure you can build sophisticated mocks that can cover everything, theoretically) I would suggest to spend few evenings reading about docker which solves for me the problem of "bring it all together". As a result your application will be ready to face almost all problems you may hit in production.

> How would an experienced Clojure developer approach this problem of creating a “generic storage interface” for your application code to “contain/hide” the particulars of necessary I/O? Probably the "DAO" pattern. Have a namespace that takes your data structure, decomposes it into inserts/recomposes it from selects/etc

(ns persistence.user)

(defn by-id [db id]
  ...)

(defn save [db user]
  ...)

(ns persistence.user)

(defprotocol UserPersistence
  (by-id [_ id])
  (save [_ user]))

(extend-type UserPersistence
   SQLWhatever
   ...)

one thing we do in the work codebase is always (internal to these p-thing namespaces) have explicit serialize and deserialize functions for converting to and from our table representations

this is structurally useful for adapting sql rows consistently to a more domain-specific form, but not actually required by anything

component, donut.system, integrant, clip, etc aren't required for any of this - they just make the task of passing stuff down as arguments more straightforward

My, and I think others, hypothesis is that you won't actually need to swap out this stuff

but you can account for maybe wanting to do that in your initial draft via the namespace separation

the spec stuff is orthogonal, but having a description of how data flows always makes it easier to recover context and change stuff later

If your production DB is Postgres you can actually test against real Postgres in-process without using Docker or Docker-compose https://eli.naeher.name/embedded-postgres-in-clojure/

This way you get to run all the same migrations/config/etc across environments

@UFTRLDZEW Oh, cool! Thanks for that tip. One of the things I miss from Erlang/OTP is that it ships with a robust built-in database (https://www.erlang.org/doc/man/mnesia.html) and some lower-level mechanisms for persisting data in memory and disk. And lightweight https://dantswain.herokuapp.com/blog/2014/09/27/storing-state-in-erlang-with-processes/. It looks like Postgres can be used similarly.

https://github.com/dscarpetti/codax The closest analog to what you're describing I've seen is this library, though I've never used it:

The classpath route looks cleaner to me (no arbitrary paths) but on the other hand it's less explicit and you have to make sure the resource is unique, based on the https://clojure.org/reference/deps_and_cli: > We discourage order-dependence in the classpath, which implies a namespace or resource file is duplicated (and thus likely broken).

I'd like to see this discussion as well.

Looks similar to this question from a couple days ago, check out the thread for some ideas 🙂: https://clojurians.slack.com/archives/C053AK3F9/p1649090531582539

Ah, just joined the channel. Thanks, I will!

Did you figure it out after all? Consider giving your input over at #improve-getting-started if you face any issues Welcome to the community by the way 🙂

Yes the easiest way was to import flatten from plumbing https://github.com/plumatic/plumbing/blob/master/src/plumbing/map.cljc#L47 Thank you 🙂

What do you mean by ‘channel compatible’?

cljs-http returns a channel out of the box https://github.com/r0man/cljs-http#async-response-handling

whereas with clj-http I'd need to wrap the callback API in a channel myself

Java now ships with a very capable built in http client

https://docs.oracle.com/en/java/javase/11/docs/api/java.net.http/java/net/http/HttpClient.html

There are some clojure wrappers around, but using it unwrapped it is great, 0 extra dependencies

what do you mean? I see a POST function here: https://github.com/r0man/cljs-http/blob/5588ebbd810de00db3c1dc2bea5ab9fb8d5be9b4/src/cljs_http/client.cljs#L342-L345

This is my call I use post function

but on server I get Phoenix.Router.NoRouteError) no route found for OPTIONS /api/crud/persist

https://dev.to/p0oker/why-is-my-browser-sending-an-options-http-request-instead-of-post-5621

might be helpful

thank you, I added manually options to server side when it responds it sends both options and post. as the blog post indicates. so I need to fix my server side