MR here for comments https://github.com/metosin/malli/pull/866

You can use :tuple instead of :vector The docs say: A :tuple describes a fixed length Clojure vector of heterogeneous elements

Yes, but :items isn't fixed length it can have length >=1

Ups, I didn't read the example properly 😅

Some sort of transformer might work, but I don't want to apply this to every instance of string/:vector in a schema

I would:

(def vectorify-transformer
  (let [coders {:vector #(cond-> % (not (vector? %)) (vector))}]
    (mt/transformer
     {:decoders coders
      :encoders coders})))

(m/decode [:map [:items [:vector :string]]] {:items ["a"]} vectorify-transformer)
; => {:items ["a"]}

(m/decode [:map [:items [:vector :string]]] {:items "a"} vectorify-transformer)
; => {:items ["a"]}

there is mt/collection-transformer which ensures the correct type, but doesn’t create collections of non-collection items. There could be a similar built-in for this too.

Is there a way to apply a transformer to just a specific key in the schema?

sure, many ways, simplest being:

[:vector {:encode/string vectorize} ...]

Ah.. in the past i've always defined my own simple schema

m/-simple-schema that is

… or you could tag the keys and read those in the transformer:

[:map [:items [:vector {:vectorize true} :string]]]

[:map [:items {:vectorize true} [:vector :string]]]

non need for simple-schema here, if instance properties are good enough. or a new property for more declarative transformation

aha, that's a nice solution.. it keeps the schemas as data

Can the transformer get access to the original schema?

transformers can read the schemas (and properties) at transfromer creation time, so it’s also super efficient, e.g. creating a decoder from this would mount the transforming function:

[:map [:items [:vector {:vectorize true} :string]]]

[:map [:items [:vector :string]]]

yes

see the mt/default-value-transformer which reads the :default key from schema. there is a :compile option to access the schema.

returning nil from :compile as “nothing to do here”

:compile should return nil in the nop case, or the encoder/decoder fn itself?

from :compile.

brilliant!

(def vectorize-transformer
    (let [coders {:vector {:compile
                           (fn [schema _]
                             (when (some-> schema m/properties (find :vectorize))
                               #(cond-> % (not (vector? %)) (vector))))}}]
      (mt/transformer
       {:decoders coders
        :encoders coders})))

many thanks @U055NJ5CC malli is great 🙂 sometimes i find it difficult to find the extension points like that. diving into the core code is a great tip

👍

@U055NJ5CC given schema [:vector {:vectorize true} :string] , (m/properties schema) returns {:vectorize true} . What is the equivelent malli.core function to get the :string part? of which there may be more than one in the case of :tuple or :enum

Usually I use (m/form schema) to get the plain data and then things like (second form) or (nth schema 2)

There is m/type, m/properties and m/children for this

I think a better approach would be to perform regex validation always, what do you think?

https://github.com/metosin/malli/issues/867

Thanks for reporting, PR to fix this (I think regex is good) would be most welcome.

ok, I will do it

Currently, the registries do not check the references eagerly to see if everything is linked correctly. m/schema does check those eagerly:

(def schema1
  {::id      int?
   ::country string?})

(def schema3
  {::secondary-id ::DOES-NOT-EXIST
   ::age          int?})

(mr/set-default-registry!
 (merge
  (m/default-schemas)
  schema1
  schema3))

(m/schema [:map ::id ::age])
; => [:map :user/id :user/age]

(m/schema [:map ::id ::secondary-id])
; =throws=> {:type :malli.core/invalid-schema, :message :malli.core/invalid-schema, :data {:schema :user/DOES-NOT-EXIST}}

there could be a helper to verify the correctness of a registry, but is not atm.

thanks, I did try this, but I think I’m using incorrectly because it doesn’t work with valid references:

(def schema1
    {::id      int?
     ::country string?})

  (def schema2
    {::secondary-id ::id
     ::age          int?})

  (malli/schema
   (merge
    (malli/default-schemas)
    schema1
    schema2))

malli/schema expects one schema, you have a full registry there.

oh, so I’d have to check every schema one by one, right?

yes

(m/schema
 ;; schema syntax
 [:map ::id ::secondary-id]
 ;; options
 {:registry (merge
             (m/default-schemas)
             schema1
             schema2)})
; => [:map :user/id :user/secondary-id]

that’s correct syntax for m/schema

thanks!

.. but checks just what is in the schema syntax. to verify all schemas in registry, you have to pull the schemas (via malli.registry/schemas) and check them 1 by 1, I guess.

my use case is to merge registries and check whether they have any broken links, let me see if I can come up with a solution

kinda works (will make less imperative):

(defn check-registry [registry]
  (let [schemas (-> registry
                    mr/registry
                    mr/schemas)]
    (doseq [[k _] schemas]
      (when (or (string? k) (and (qualified-keyword? k)
                                 (-> k namespace (str/starts-with? "malli") not)))
        (malli/schema [:map k] {:registry registry})))))

you could check just your own custom registry, no need to crawl the default schemas I guess. btw, there is m/-reference? to check if the key is a valid reference type (string or qualified kw).

both great tips, thank you!

I filtered out the malli schemas because the check fails when I pass it one of them

yes, there is a bunch of schemas that can’t be created without children, e.g. (m/schema :schema) fails, it requires 1 child, (m/schema [:schema :int]). Same with :map-of, :enum , :or, :vector etc.

there is ::m/schema and ::m/val as internal schema types, marking eager references and entry values, both require a child.

hmm simply merging my own schemas into a registry (and not the default malli schemas) and checking the result with my function doesn’t work, presumably because they use int? and string? which only exist in the default schemas

Yes, you have the full registry when validating (via options or global registry), but just need to loop the own ones

implementation for the new registry would be ~7 loc.

that’s pretty cool , its not for everyone but very legit and simple approach i like it