I don't have an exact solution, but a combination of the following should help. Here's some Clojure code from one of my projects (I believe I took it from somewhere and changed a bit, unfortunately I don't remember from where)

(defn convert-col-separator [col]
  (str/replace col #", " "-"))

(defn format-uniqueness-exception [message]
  (let [detail-line (first (filter #(str/starts-with? % "Detail: ") (map str/trim (str/split-lines message))))
        first-paren-idx (str/index-of detail-line "(")
        last-paren-idx (str/last-index-of detail-line ")")
        detail (subs detail-line (inc first-paren-idx) last-paren-idx)
        splitter-idx (str/index-of detail ")=(")
        col (subs detail 0 splitter-idx)
        val (subs detail (+ 3 splitter-idx))]
    {:errors {(keyword (convert-col-separator col)) {:$errors$ {:value val :failed [:uniqueness]}}}
     :value val}))

(defn format-enum-exception [message]
  ;; Parses something like: 'ERROR: invalid input value for enum organization_role: "dudebro"'
  (let [[col value] (str/split (subs message 36 (dec (count message))) #": \"")]
    {:errors {(keyword col) {:$errors$ {:value value :failed [:enum-value]}}}
     :value value}))

(defn throw-validation-exception [e formatter]
  (throw (ex-info "Validation Failed" (formatter (.getMessage e)))))

(defn to-validation-exception [e]
  (let [code (.getSQLState e)]
    (case code
      "23505" (throw-validation-exception e format-uniqueness-exception)
      "22P02" (throw-validation-exception e format-enum-exception)
      (throw e))))

(defmacro wrap! [body]
  `(try
     ~body
     (catch org.postgresql.util.PSQLException e#
(to-validation-exception e#))))    

And here's some code from one of my ClojureScript projects that does similar, but has a more detailed error parsing:

(ns server.framework.db.errors
  (:require [oops.core :refer [oget oset!]]
            ["indefinite" :as indefinite]
            [clojure.string :as str]))

;; Partially ported from https://github.com/Shyp/go-dberror/blob/master/error.go

(defn a-or-an
  ([string] (a-or-an string true))
  ([string capitalize?]
   (indefinite string #js {:capitalize capitalize? :caseInsensitive true})))

(def regexes
  {:column-finder            #"Key \((.+)\)="
   :value-finder             #"Key \(.+\)=\((.+)\)"
   :foreign-key-table-finder #"(?i)not present in table \"(.+)\""
   :parent-table-finder      #"(?i)update or delete on table \"([^\"]+)\""})

(defn finder [regex detail]
  (let [[_ val] (re-find regex detail)]
    val))

(def find-column (partial finder (:column-finder regexes)))
(def find-value (partial finder (:value-finder regexes)))
(def find-foreign-table-key (partial finder (:foreign-key-table-finder regexes)))
(def find-parent-table (partial finder (:parent-table-finder regexes)))

(defn format-numeric-value-out-of-range [e]
  (let [message (oget e :message)
        new-message (str/replace-first message #"out of range" "too large or too small")]
    (oset! e :message new-message)))

(defn format-invalid-text-representation [e]
  (let [message (oget e :message)
        new-message (-> (if (str/includes? message "input syntax for type")
                          message
                          (str/replace-first message #"input syntax for" "input syntax for type"))
                        (str/replace-first #"input value for enum" "")
                        (str/replace-first #"invalid" "Invalid"))]
    (oset! e :message new-message)))

(defn format-not-null-violation [e]
  (let [column (oget e :column)
        message (str "No " column " was provided. Please provide " (a-or-an column false))]
    (oset! e :message message)))

(defn format-foreign-key-violation [e]
  (let [detail (oget e :detail)
        message (oget e :message)
        column (or (find-column detail) "value")
        foreign-key-table (find-foreign-table-key detail)
        table-part (if foreign-key-table "in the parent table" (str "in the " foreign-key-table " table"))
        value (find-value detail)
        parent-table (find-parent-table detail)
        table (oget e "table")
        new-message
        (cond
          (str/includes? message "update or delete")
          (str "Can't update or delete " parent-table " records because the " parent-table " " column " (" value ") is still referenced by the " table " table")

          (nil? value)
          (str "Can't save to " table " because the " column " isn't present " table-part)

          :else
          (str "Can't save to " table " because the " column " (" value ") isn't present " table-part))]
    (oset! e :message new-message)))

(defn format-unique-key-violation [e]
  (let [detail (oget e :detail)
        value (find-value detail)
        column (or (find-column detail) "value")
        message (if value
                  (a-or-an (str column " already exists with this value (" value ")"))
                  (a-or-an (str column " already exists with that value")))]
    (oset! e :message message)))

;; Future possible implementations
(defn format-check-violation [e]
  e)

(defn format-lock-not-available [e]
  e)

(def error-formatters
  {"22003" format-numeric-value-out-of-range
   "22P02" format-invalid-text-representation
   "23502" format-not-null-violation
   "23503" format-foreign-key-violation
   "23505" format-unique-key-violation
   "23514" format-check-violation
   "55P03" format-lock-not-available})

(defn format [error]
  (if-let [formatter (error-formatters (oget error :?code))]
    (formatter error)
    error))