v9.2.3 - fix preprocessed tags

package.json

@@ -1,6 +1,6 @@
 {
   "name": "rescript-schema",
-  "version": "9.2.2",
+  "version": "9.2.3",
   "private": true,
   "description": "🧬 The fastest parser in the entire JavaScript ecosystem with a focus on small bundle size and top-notch DX",
   "keywords": [

packages/tests/src/core/S_object_nested_test.res

@@ -312,6 +312,33 @@ test("S.schema object with a deep strict applied to the nested field parent", t
   t->U.assertCompiledCode(~schema, ~op=#ReverseConvert, `i=>{let v0=i["nested"];return i}`)
 })
 
+test("Nested tags on reverse convert", t => {
+  let schema = S.object(s => {
+    s.nested("nested").tag("tag", "value")
+  })
+
+  t->Assert.deepEqual(()->S.reverseConvertOrThrow(schema), %raw(`{"nested":{"tag":"value"}}`), ())
+})
+
+test("Nested preprocessed tags on reverse convert", t => {
+  let schema = S.object(s => {
+    let _ = s.nested("nested").field(
+      "tag",
+      S.literal("value")->S.preprocess(_ => {serializer: v => "_" ++ v->Obj.magic}),
+    )
+    let _ = s.nested("nested").field(
+      "intTag",
+      S.literal(1)->S.preprocess(_ => {serializer: v => "_" ++ v->Obj.magic}),
+    )
+  })
+
+  t->Assert.deepEqual(
+    ()->S.reverseConvertOrThrow(schema),
+    %raw(`{"nested":{"tag":"_value", "intTag":"_1"}}`),
+    (),
+  )
+})
+
 test("S.schema object with a deep strict applied to the nested field parent + reverse", t => {
   let schema =
     S.schema(s =>

packages/tests/src/core/S_preprocess_test.res

@@ -283,7 +283,20 @@ test("Reverse schema to the original schema", t => {
     parser: _ => 1->Int.toFloat,
     serializer: _ => 1.->Int.fromFloat,
   })
-  t->U.assertEqualSchemas(schema->S.reverse, S.unknown->S.toUnknown)
+  t->Assert.truthy(
+    switch schema->S.classify {
+    | Int => true
+    | _ => false
+    },
+    (),
+  )
+  t->Assert.truthy(
+    switch schema->S.reverse->S.classify {
+    | Int => true
+    | _ => false
+    },
+    (),
+  )
 })
 
 test("Succesfully uses reversed schema for parsing back to initial value", t => {

src/S_Core.res

@@ -2688,7 +2688,7 @@ let rec preprocess = (schema, transformer) => {
         let reversed = schema.reverse()
         makeReverseSchema(
           ~name=primitiveName,
-          ~tagged=Unknown,
+          ~tagged=reversed.tagged,
           ~builder=(b, ~input, ~selfSchema as _, ~path) => {
             let input = b->B.parse(~schema=reversed, ~input, ~path)
             switch transformer(b->B.effectCtx(~selfSchema=schema, ~path)) {

src/S_Core.res.mjs

@@ -1850,7 +1850,7 @@ function preprocess(schema, transformer) {
                 }
               }), undefined, (function () {
                 var reversed = schema["~r"]();
-                return makeReverseSchema(primitiveName, "unknown", empty, (function (b, input, param, path) {
+                return makeReverseSchema(primitiveName, reversed.t, empty, (function (b, input, param, path) {
                               var input$1 = reversed.b(b, input, reversed, path);
                               var match = transformer(effectCtx(b, schema, path));
                               var serializer = match.s;