sound really strange. do you have a repro of this?

Actually no. I reverted the changes to my input and output schemas to get you the repro, but it wont happen again. I have to dig into this more now. If you want I can give you the transformer and the schemas though

Update: jackout and jack-in seems to cause it to happen with unmodified schema... here is the schemas and transformer: Input schema:

(def schema-rest-status-simple
   [:map
    [:routers {:optional true} [:vector [:map [:name :string] [:connections [:map [:created :int] [:active :int]]]]]]
    [:composite :boolean]
    [:name :string]
    [:type :string]
    [:policy :string]
    [:datasources
     [:vector
      [:map
       [:role :string]
       [:groupId :int]
       [:standby :boolean]
       [:witness :boolean]
       [:alertMessage :string]
       [:name :string]
       [:dataserver [:map [:state :string]]]
       [:state :string]
       [:replicator
        [:map
         [:role :string]
         [:appliedLatency :double]
         [:pipelineSource :string]
         [:maxStoredSeqno :int]
         [:state :string]
         [:relativeLatency :double]
         [:seqno :int]
         [:minStoredSeqno :int]
         [:appliedLastEventId :string]
         [:version :string]]]
       [:alertStatus :string]
       [:manager [:map [:state :string]]]
       [:lastError :string]
       [:lastShunResult :string]
       [:connections [:map [:created :int] [:active :int]]]
       [:archive :boolean]]]]
    [:coordinators [:vector :string]]
    [:multimaster :boolean]])

(def schema-rest-outbound
  [:schema
   {:registry {"Root" [:map
                       [::m/default [:map-of {:gen/min 1 :gen/max 100} :keyword "Cluster"]]]
               "Cluster" [:map
                          [:id [:string {:default "test"}]]
                          [:name :string]
                          [:isComposite :boolean]
                          [:policy :string]
                          [:topology :string]
                          [:dataservices [:map-of {:gen/min 1 :gen/max 4} :keyword "Dataservices"]]]
               "Dataservices" [:map 
                               [:id [:string {:default "test"}]]
                               [:name :string]
                               [:policy :string]
                               [:type :string]
                               [:coordinators [:vector :string]]
                               [:datasources [:map-of {:gen/min 1 :gen/max 6} :keyword "Datasources"]]]
               "Datasources" [:map
                              [:name :string]
                              [:role :string]
                              [:state :string]
                              [:standby :boolean]
                              [:archive :boolean]
                              [:witness :boolean]
                              [:alert "SourceAlert"]
                              [:replicator "Replicator"]
                              [:manager "Manager"]
                              [:connections "Connections"]
                              [:dataserver "Dataserver"]]
               "SourceAlert" [:map
                              [:status :string]
                              [:message :string]
                              [:lastError :string]
                              [:lastShunReason :string]]
               "Replicator" [:map
                             [:appliedLatency :double]
                             [:relativeLatency :double]
                             [:seqno :int]
                             [:minStoredSeqno :int]
                             [:maxStoredSeqno :int]
                             [:pipelineSource :string]
                             [:appliedLastEventId :string]
                             [:version :string]
                             [:role :string]]
               "Manager" [:map
                          [:state :string]]
               "Connections" [:map
                              [:created :int]
                              [:active :int]]
               "Dataserver" [:map
                             [:state :string]]}}
   "Root"])

(def rest-standalone-transformation
  {:registry {:rest-status schema-rest-status-simple
              :dashboard schema-rest-outbound}
   :mappings {:source :rest-status
              :target :dashboard
              :pattern '{:name ?name
                         :composite ?composite
                         :type ?type
                         :policy ?policy
                         :dashboard-id ?dashboard-id
                         :coordinators ?coordinators
                         :datasources [{:name (me/and !name !index)
                                        :manager {:state !manager-state}
                                        :dataserver {:state !data-state}
                                        :role !role
                                        :state !state
                                        :standby !standby
                                        :archive !archive
                                        :witness !witness
                                        :alertStatus !alert-s
                                        :alertMessage !alert-m
                                        :lastShunResult !shun
                                        :lastError !error
                                        :connections !connections
                                        :replicator {:state !repl-state
                                                     :version !version
                                                     :appliedLatency !a-latency
                                                     :relativeLatency !r-latency
                                                     :seqno !seqno
                                                     :minStoredSeqno !minseqno
                                                     :maxStoredSeqno !maxseqno
                                                     :appliedLastEventId !eventId
                                                     :pipelineSource !source
                                                     :role !repl-role}} ...]}
              :expression '{(me/keyword ?dashboard-id)
                            {:name ?name
                             :id ?dashboard-id
                             :isComposite ?composite
                             :topology ?type
                             :policy ?policy
                             :dataservices
                             {(me/keyword ?dashboard-id)
                              {:name ?name
                               :id ?dashboard-id
                               :type ?type
                               :policy ?policy
                               :coordinators ?coordinators
                               :datasources
                               {& ([(me/keyword !index)
                                    {:name !name
                                     :role !role
                                     :state !state
                                     :standby !standby
                                     :archive !archive
                                     :witness !witness
                                     :manager {:state !manager-state}
                                     :dataserver {:state !data-state}
                                     :connections !connections
                                     :replicator {:version !version
                                                  :state !repl-state
                                                  :appliedLatency !a-latency
                                                  :relativeLatency !r-latency
                                                  :seqno !seqno
                                                  :minStoredSeqno !minseqno
                                                  :maxStoredSeqno !maxseqno
                                                  :pipelineSource !source
                                                  :appliedLastEventId !eventId
                                                  :role !repl-role}
                                     :alert {:message !alert-m
                                             :status !alert-s
                                             :lastError !error
                                             :lastShunReason !shun}}] ...)}}}}}}})

(defn matcher
  [{:keys [pattern expression]}]
  (eval `(fn [data#]
           (let [~'data data#]
             ~(mre/compile-rewrite-args ; modified: original did not use compile-rewrite-args 
               (list 'data pattern expression)
               nil)))))

(defn transformer
  [{:keys [registry mappings]} source-transformer target-transformer]
  (let [{:keys [source target]} mappings
        xf (comp (map (m/coercer (get registry source) source-transformer))
                 (map (matcher mappings))
                 (map (m/coercer (get registry target) target-transformer)))]
    (fn [data] (into {} xf data))))

Sorry for the wall of text, it's my first proper meander thing and it is quite... verbose still to use it, i was running this:

(def status->dashboard-status
  (transformer
   rest-standalone-transformation
   (mt/transformer
    (mt/string-transformer))
   (mt/transformer
    (mt/string-transformer)
    (mt/default-value-transformer))))


  (try
    (status->dashboard-status [(assoc (mg/generate schema-rest-status-simple) :dashboard-id "dummy")])
    (catch Exception ex 
      (-> ex ex-data :data :explain merr/humanize prn)
      (prn (ex-data ex))))

maybe it's better to not go into that code @U055NJ5CC. I'm feeling this is a tool issue and not actually related to malli: If I jackout and jack in with calva in cursor., that schema does not work with Malli generator and the provided code. If i fix the code style issue in schema-rest-status-simple ie routers map being on one line. then jackout and back in again and evaluate everything, it works. So it's not actually a number range issue. It's a linebreak issue which makes me believe that there is no way it's nothing else than tool related

I figured that one out it was because of my own stupidity. There was a dependency error that caused the nested usage of meander to not work in the patterns and expressions as it was expected. hence the problems. While fixing that problem I think I finally clicked with Malli after playing with the generator and schema interaction as I debugged. I can basically develop my entire app with the generator. This thing is incredibly powerful. Thank you so much for making it, and making it open source.

I guess if I replace every :or with :union that would take me one step closer, however what should I do with the :and?

I think what I will try is to compile into only :not :or implementing rewrite rules for :and then I should just be able to use :union to merge all rules into one I think.

This looks interesting https://github.com/bsless/malli-keys-relations any info why it got abandon?

I have now solved it I think, what I do is a create a schema containing all values without any constraints, I use this schema to generate values, then I validate the results against to [:and ...] of all the expressions I have. Not sure if there is a smarter way but this looks to work very well, will need more testing before I know for sure.

hi. so the problem is that with :and? it uses the first branch as generator and rest to validate the generated values. if the first one gives too wide results, the rest don’t easily match.

you could: 1. put the most spesific first 2. use a custom generator at :and

(def schema1
  [:not [:map ["a" [:map ["b" [:re #"dd[A|B|C|F|D|E]"]]]]]])

(def schema2
  [:or
   [:map ["c" [:map ["d" [:= "3"]]]]]
   [:map ["c" [:map ["d" [:= "2"]]]]]
   [:map ["c" [:map ["d" [:= "9"]]]]]
   [:map ["c" [:map ["d" [:= "99"]]]]]])

(mg/generate [:and schema1 schema2])
;=> Couldn't satisfy such-that predicate after 100 tries.

(mg/generate [:and schema2 schema1])
;=> {"c" {"d" "3"}}

(mg/generate [:and {:gen/schema schema2} schema1 schema2])
;=> {"c" {"d" "2"}}

the :not doesn’t generate very well:

(mg/sample schema1)
;(nil
; nil
; (#uuid"303ca3c6-7463-4be4-8f01-07a2b2606446")
; 2.0
; nil
; [:R?/L??]
; nil
; ({-5 -})
; #{0 -0.3046875 f/yA. true "ch[Kd4.." -8/3 :-/k_}
; #{[] #{-5}})

hope this helps

Thanks for this, it makes sense that the first and works as a generator, that explains why what I did actually works.

One solution would be to combine specter and deref-recursive. An interesting idea would be deref-recursive into a data script db, then datalog

could you @U0ERZQ1K2 preudocode what you would like to see? e.g. input + output. I would just m/walk over the schema…

Yes... I'll come back on this with a usable example, I need to convert my stuff from spec/spec-tools first.