just some thoughts in case its related, I am using transit+json because my keys are namespaces this is so they get preserved over the wire

hello

I tried to apply this https://github.com/metosin/malli/pull/545/files

in my project

I've added zoned-date-time

in some other ns I define schema like:

(def ZDT
  (mt/time-schema :zoned-date-time))

then in the reitit router I have malli coercion set and the endpoint has this:

:parameters
  {:body
   [:map
    [:scrape-request
     [:map
      [:id int?]
      [:from-date
       [:map
        {:registry
         #:my-name-space{:zdt :zoned-date-time}}
        :my-name-space/zdt]]]]]},

but when I try to create the routes I get:

Execution error (ExceptionInfo) at reitit.exception/exception (exception.cljc:19).
:malli.core/invalid-schema {:schema :zoned-date-time}

{:schema :zoned-date-time}

any idea?

same problem if I don't use registry

:parameters
  {:body
   [:map
    [:scrape-request
     [:map [:id int?] [:from-date :zoned-date-time]]]]},

what am I doing wrong?

please?

I probably son't use the default registry correctly. Any hints please?

Thanx @lambder, I was trying to add support for java.time.LocalDate and java.time.Instant to my project, and your post helped me. I added the code from https://github.com/metosin/malli/pull/545/files and imported it to the registry with

(defn service-routes []
  ["/api"
   {:coercion   (reitit.coercion.malli/create
                  {:options {:registry (merge
                                           (m/default-schemas)
                                           (malli-time/time-schemas))}})

[:mydate {:description "My description"
          :json-schema/example "2021-11-05"}
 :local-date]

(defn ->error-reporter
  [parser message]
  (fn -report [value]

(defn ->error-reporter
  [parser message]
  (fn -report [value _]

"Should be local-date or LocalDate"

great stuff, @ronny

have you seen the massages in the thread?

one thing I'm missing is to make it work with edn request

it works with json only

I'll do

`(fn -report [value & _]

Yes. I was also wondering about type vs format. Not an expert on json schema, but looks like you are right

just in case some other call needs single arity

I also added :json-schema/example:

:local-date {:class LocalDate :parser -string->local-date :json-schema/type :local-date :json-schema/example "2022-02-23"}

...

:json-schema/example (:json-schema/example props -name)

if I don't supply the example for date-time, the SwaggerUI will get one form me

If I don’t provide json-schema/example, Swagger will show “Unknown Type: local-date”. Maybe your change to

"type": "string",
"format": "date-time" 

local-date is not corret

there is only date and date-time

see here https://www.baeldung.com/openapi-dates

for local dates you probably want to adapt:

customDate: 
  type: string 
  pattern: '^\d{4}(0[1-9]|1[012])(0[1-9]|[12][0-9]|3[01])$'
  description: Custom date 
  example: "20210130"

Isn’t “date” a good fit for java.time.LocalDate? Format yyyy-MM-dd

it is

With

:local-date {:class LocalDate :parser -string->local-date :json-schema/type :string :json-schema/format "date"}

right

do you have your app working with edn encoding?

do I need to provide analog of:

{:transformers {:body {:default default-transformer-provider
                         :formats {"application/json" json-transformer-provider}}
                  :string {:default string-transformer-provider}
                  :response {:default default-transformer-provider
                             :formats {"application/json" json-transformer-provider}}}

for edn?

No, sorry, haven't done anything to provide support for edn in our application

when my edn request is:

{
  :scrape-request {
    :id 1
    :from-date #time/zoned-date-time "2022-01-01T16:14:34.447Z"
  }
}

I'm getting:

{:schema "[:map {:closed true} [:scrape-request [:map {:closed true} [:id int?] [:from-date :zoned-date-time]]]]", :errors ({:path [:scrape-request :from-date], :in [:scrape-request :from-date], :schema ":zoned-date-time", :value (. java.time.ZonedDateTime parse "2022-01-01T16:14:34.447Z"), :message "Should be zoned-date-time or ZonedDateTime"}), :value {:scrape-request {:id 1, :from-date (. java.time.ZonedDateTime parse "2022-01-01T16:14:34.447Z")}}, :type :reitit.coercion/request-coercion, :coercion :malli, :in [:request :body-params], :humanized {:scrape-request {:from-date ["Should be zoned-date-time or ZonedDateTime"]}}}

see: :from-date (. java.time.ZonedDateTime parse "2022-01-01T16:14:34.447Z")

how on earth this form gets there are all?

this is added to the registry:

:zoned-date-time #IntoSchema{:type :zoned-date-time},

using this:

(m/-simple-schema
        {:type type
         :type-properties
               (cond-> {:error/fn         error-fn
                        :decode/json      {:enter safe-parser}
                        :encode/json      {:enter #(prn %)}
                        :json-schema/type (:json-schema/type props -name)}
                 (:json-schema/format props -name) (assoc :json-schema/format (:json-schema/format props -name)))
         :pred pred})

the `safe-parser` is:

provided by :

(defn -string->zoned-date-time [x]
  (ZonedDateTime/parse x))

so this :from-date (. java.time.ZonedDateTime parse "2022-01-01T16:14:34.447Z") looks a lot like (ZonedDateTime/parse x)

but instead if being invoked is it passed a a value. How did it happen ?

funny thing the value to decoder is coercion.malli is already wrapped with something like this:

this happens in reitit.coercion by transforming the request to the value

@lambder those decode/json transformations aren't used by coercion here (no coercion really needed for these values) when you are using EDN. As EDN can already represent types, the coercion doesn't do anything. If you have *data-reader* registered for the #time/zoned-date-time tag (or provided :readers option to muuntaja edn format) the value should be correct and the problem must be with the schema validation (the predicate).

hey @juhoteperi no, I don't have the readers supplied to muuntaja sepcially

I got `

:muuntaja   formats/instance

that instance is:

(def instance
  (m/create
    (-> m/default-options
      (update-in
        [:formats "application/transit+json" :decoder-opts]
        (partial merge time/time-deserialization-handlers))
      (update-in
        [:formats "application/transit+json" :encoder-opts]
        (partial merge time/time-serialization-handlers)))))

Muuntaja will use *data-readers*, which is already provided by Clojure if you have the readers in a data_readers.clj file somewhere

I do in my core ns `

(time-literals.read-write/print-time-literals-clj!)

But hmm, it could be problem with those data readers, because :value (. java.time.ZonedDateTime parse "2022-01-01T16:14:34.447Z") seems really strange. Looks like the value isn't the ZonedDateTime instance, but the Clojure form calling that ZonedDateTime/parse method

but not setting it for read

will get back to it in about 1h30m

need to run now

> The library includes the magic file data_readers.cljc which Clojure and the Clojurescript compilers() will look for.

thanks for everything

So just including time-literals in the classpath should add data-readers for those tags

If data-readers are working correctly, if you eval in the REPL {:foo #time/zoned-date-time "2022-01-01T16:14:34.447Z"} you should get the same map back, the tagged value is read to ZonedDateTime instance, and because you have the print method registered, it should be printed out the same way.

In need to add time readers to end/read-string option for it to work

So I guess they are not added to data_readers, but I'll dbl check

@juhoteperi this is just black magic to me