Merge pull request #32 from mycelium-clj/feature/lite-schema

Add lite schema syntax for cell definitions

Author: yogthos

src/mycelium/cell.clj

@@ -1,6 +1,7 @@
 (ns mycelium.cell
   "Cell registry for Mycelium. Cells are registered via `defmethod cell-spec`."
-  (:require [mycelium.validation :as v]))
+  (:require [mycelium.schema :as schema]
+            [mycelium.validation :as v]))
 
 (defmulti cell-spec
   "Multimethod-backed cell registry. Dispatches on cell-id keyword,
@@ -35,26 +36,38 @@
       (throw (ex-info (str "Cell " id " not found in registry")
                       {:id id}))))
 
+(defn- output-dispatched?
+  "Heuristic for defcell/set-cell-schema! (no edge context available):
+   a map output schema is per-transition if all values are vectors (Malli schema
+   forms like [:map ...], [:or ...], etc.). If any value is a keyword or map,
+   it's treated as lite syntax. For manifests, edge context is used instead.
+   Trade-off: per-transition maps with bare keyword schemas (e.g. {:success :any})
+   would be misclassified as lite — use vector form [:any] in that rare case."
+  [output]
+  (and (map? output) (seq output) (every? vector? (vals output))))
+
 (defn set-cell-schema!
   "Sets or overwrites the schema for an already-registered cell.
-   Validates that the schema is well-formed Malli before updating.
+   Normalizes lite syntax, validates Malli, then updates.
    Throws if the cell is not found or the schema is invalid."
   [cell-id schema]
   (when-not (cell-spec cell-id)
     (throw (ex-info (str "Cell " cell-id " not found in registry")
                     {:id cell-id})))
-  (when (:input schema)
-    (v/validate-malli-schema! (:input schema) (str cell-id " :input")))
-  (when (:output schema)
-    (v/validate-output-schema! (:output schema) (str cell-id " :output")))
-  (swap! cell-overrides update cell-id merge {:schema schema})
-  schema)
+  (let [dispatched? (output-dispatched? (:output schema))
+        schema (schema/normalize-cell-schema schema dispatched?)]
+    (when (:input schema)
+      (v/validate-malli-schema! (:input schema) (str cell-id " :input")))
+    (when (:output schema)
+      (v/validate-output-schema! (:output schema) (str cell-id " :output")))
+    (swap! cell-overrides update cell-id merge {:schema schema})
+    schema))
 
 (defn set-cell-meta!
   "Sets metadata overrides (schema, requires) on a registered cell.
    The manifest calls this to inject metadata into cells that were registered
-   without schemas/requires. Validates schema is well-formed.
-   Throws if the cell is not found."
+   without schemas/requires. Expects schemas to be pre-normalized.
+   Validates schema is well-formed. Throws if the cell is not found."
   [cell-id {:keys [schema requires] :as meta-map}]
   (when-not (cell-spec cell-id)
     (throw (ex-info (str "Cell " cell-id " not found in registry")
@@ -110,9 +123,12 @@
   ([cell-id opts handler-fn]
    (let [schema-keys #{:input :output}
          opt-keys    #{:doc :requires :async?}
-         schema      (when opts
+         raw-schema  (when opts
                        (let [s (select-keys opts schema-keys)]
                          (when (seq s) s)))
+         dispatched? (and raw-schema (output-dispatched? (:output raw-schema)))
+         schema      (when raw-schema
+                       (schema/normalize-cell-schema raw-schema dispatched?))
          extra       (when opts (select-keys opts opt-keys))
          spec        (cond-> {:id cell-id :handler handler-fn}
                        schema (assoc :schema schema)

src/mycelium/manifest.clj

@@ -7,6 +7,7 @@
             [malli.generator :as mg]
             [mycelium.cell :as cell]
             [mycelium.fragment :as fragment]
+            [mycelium.schema :as schema]
             [mycelium.validation :as v]))
 
 ;; ===== Cell definition validation =====
@@ -131,8 +132,26 @@
        (throw (ex-info "Manifest missing :cells" {:id id})))
      (when-not edges
        (throw (ex-info "Manifest missing :edges" {:id id})))
-     ;; Resolve :schema :inherit before validation
+     ;; Resolve :schema :inherit, then normalize lite syntax before validation
      (let [cells    (resolve-inherit-schemas cells)
+           ;; Normalize cell schemas using edge context for output disambiguation
+           ;; Join members have no edge entries, so fall back to heuristic:
+           ;; a map output where all values are vectors is per-transition.
+           cells    (into {}
+                          (map (fn [[cell-name cell-def]]
+                                 (if (or (= :inherit (:schema cell-def))
+                                         (nil? (:schema cell-def)))
+                                   [cell-name cell-def]
+                                   (let [edge-def    (get edges cell-name)
+                                         output      (get-in cell-def [:schema :output])
+                                         dispatched? (or (map? edge-def)
+                                                         (and (map? output)
+                                                              (seq output)
+                                                              (every? vector? (vals output))))
+                                         normalized  (schema/normalize-cell-schema
+                                                       (:schema cell-def) dispatched?)]
+                                     [cell-name (assoc cell-def :schema normalized)]))))
+                          cells)
            manifest (assoc manifest :cells cells)]
        ;; Validate each cell definition
        (doseq [[cell-name cell-def] cells]
@@ -174,9 +193,9 @@
                effective-dispatches (merge join-dispatches (or dispatches {}))]
            (v/validate-dispatch-coverage! edges effective-dispatches))
          (v/validate-reachability! edges valid-names))
-       ;; Validate :input-schema if present
+       ;; Validate :input-schema if present (normalize lite syntax first)
        (when-let [input-schema (:input-schema manifest)]
-         (v/validate-malli-schema! input-schema "input-schema"))
+         (v/validate-malli-schema! (schema/normalize-schema input-schema) "input-schema"))
        ;; Validate :regions if present
        (when-let [regions (:regions manifest)]
          (validate-regions! regions cells))
@@ -320,7 +339,7 @@
              :edges edges}
       dispatches (assoc :dispatches dispatches)
       (:joins manifest) (assoc :joins (:joins manifest))
-      (:input-schema manifest) (assoc :input-schema (:input-schema manifest))
+      (:input-schema manifest) (assoc :input-schema (schema/normalize-schema (:input-schema manifest)))
       (:interceptors manifest) (assoc :interceptors (:interceptors manifest))
       (:resilience manifest) (assoc :resilience (:resilience manifest))
       (:transforms manifest) (assoc :transforms (:transforms manifest)))))

src/mycelium/schema.clj

@@ -7,6 +7,48 @@
             [malli.transform :as mt]
             [maestro.core :as fsm]))
 
+;; ===== Lite schema normalization =====
+
+(defn normalize-schema
+  "Normalizes a schema that may be in lite syntax to standard Malli.
+   - Plain maps become [:map [:k1 v1] [:k2 v2] ...] with values recursively normalized
+   - Vectors, keywords, and nil pass through unchanged
+   Examples:
+     {:subtotal :double}             → [:map [:subtotal :double]]
+     {:address {:street :string}}    → [:map [:address [:map [:street :string]]]]
+     [:map [:x :int]]                → [:map [:x :int]]
+     :int                            → :int"
+  [schema]
+  (cond
+    (nil? schema) nil
+    (map? schema) (into [:map] (map (fn [[k v]] [k (normalize-schema v)])) schema)
+    :else schema))
+
+(defn normalize-output-schema
+  "Normalizes an output schema, accounting for per-transition maps.
+   When `dispatched?` is true and the schema is a map, each value is normalized
+   individually (per-transition output). Otherwise the map is treated as lite syntax."
+  [schema dispatched?]
+  (cond
+    (nil? schema)    nil
+    (vector? schema) schema
+    (map? schema)    (if dispatched?
+                       (into {} (map (fn [[k v]] [k (normalize-schema v)])) schema)
+                       (normalize-schema schema))
+    :else            schema))
+
+(defn normalize-cell-schema
+  "Normalizes a cell's :schema map, converting lite syntax to Malli.
+   `dispatched?` — true if the cell has branching edges (per-transition output)."
+  ([schema] (normalize-cell-schema schema false))
+  ([schema dispatched?]
+   (when schema
+     (let [input  (:input schema)
+           output (:output schema)]
+       (cond-> schema
+         input  (assoc :input (normalize-schema input))
+         output (assoc :output (normalize-output-schema output dispatched?)))))))
+
 (def ^:private terminal-states
   #{::fsm/end ::fsm/error ::fsm/halt})
 

src/mycelium/validation.clj

@@ -40,6 +40,7 @@
 (defn validate-cell-def!
   "Validates a single cell definition (manifest or fragment).
    Checks :id and :schema presence, validates Malli schemas.
+   Expects schemas to be pre-normalized (lite syntax already converted).
    Skips schema validation for :schema :inherit (resolved separately).
    `context` is a string prefix for error messages (e.g. \"Cell\" or \"Fragment cell\")."
   [cell-name cell-def context]