Fix #150

Author: DZakh

packages/sury/src/Sury.res

@@ -2619,6 +2619,8 @@ let never = base(Never)
 never.refiner = Some(neverBuilder)
 let never: t<never> = never->castToPublic
 
+let nestedLoc = "BS_PRIVATE_NESTED_SOME_NONE"
+
 module Union = {
   @unboxed
   type itemCode = Single(string) | Multiple(array<string>)
@@ -2765,8 +2767,16 @@ module Union = {
                 : (tag :> string)
             switch byKey.contents->X.Dict.getUnsafeOption(key) {
             | Some(arr) =>
-              // There can only be one valid. Dedupe
               if (
+                tagFlag->Flag.unsafeHas(TagFlag.object) &&
+                  schema.properties->X.Option.getUnsafe->Dict.has(nestedLoc)
+              ) {
+                // This is a special case for https://github.com/DZakh/sury/issues/150
+                // When nested option goes together with an empty object schema
+                // Since we put None case check second, we need to change priority here.
+                arr->Js.Array2.unshift(schema)->ignore
+              } else if (
+                // There can only be one valid. Dedupe
                 !(
                   tagFlag->Flag.unsafeHas(
                     TagFlag.undefined->Flag.with(TagFlag.null)->Flag.with(TagFlag.nan),
@@ -3100,8 +3110,6 @@ module Union = {
 module Option = {
   type default = Value(unknown) | Callback(unit => unknown)
 
-  let nestedLoc = "BS_PRIVATE_NESTED_SOME_NONE"
-
   let nestedOption = {
     let nestedNone = () => {
       let itemSchema = Literal.parse(0)

packages/sury/src/Sury.res.mjs

@@ -1693,6 +1693,8 @@ let never = new Schema("never");
 
 never.refiner = neverBuilder;
 
+let nestedLoc = "BS_PRIVATE_NESTED_SOME_NONE";
+
 function getItemCode(b, schema, input, output, deopt, path) {
   try {
     let globalFlag = b.g.o;
@@ -1784,7 +1786,9 @@ function refiner(b, input, selfSchema, path) {
         let key = tagFlag & 8192 ? schema.class.name : tag;
         let arr = byKey[key];
         if (arr !== undefined) {
-          if (!(tagFlag & 2096)) {
+          if (tagFlag & 64 && nestedLoc in schema.properties) {
+            arr.unshift(schema);
+          } else if (!(tagFlag & 2096)) {
             arr.push(schema);
           }
 
@@ -2008,8 +2012,6 @@ function factory(schemas) {
   throw new Error("[Sury] S.union requires at least one item");
 }
 
-let nestedLoc = "BS_PRIVATE_NESTED_SOME_NONE";
-
 function nestedNone() {
   let itemSchema = parse$1(0);
   let item = {
@@ -2670,70 +2672,6 @@ function schemaRefiner(b, input, selfSchema, path) {
   }
 }
 
-function definitionToRitem(definition, path, ritemsByItemPath) {
-  if (typeof definition !== "object" || definition === null) {
-    return {
-      k: 1,
-      p: path,
-      s: copyWithoutCache(parse$1(definition))
-    };
-  }
-  let item = definition[itemSymbol];
-  if (item !== undefined) {
-    let ritemSchema = copyWithoutCache(getOutputSchema(item.schema));
-    ((delete ritemSchema.serializer));
-    let ritem = {
-      k: 0,
-      p: path,
-      s: ritemSchema
-    };
-    item.r = ritem;
-    ritemsByItemPath[getFullDitemPath(item)] = ritem;
-    return ritem;
-  }
-  if (Array.isArray(definition)) {
-    let items = [];
-    for (let idx = 0, idx_finish = definition.length; idx < idx_finish; ++idx) {
-      let location = idx.toString();
-      let inlinedLocation = "\"" + location + "\"";
-      let ritem$1 = definitionToRitem(definition[idx], path + ("[" + inlinedLocation + "]"), ritemsByItemPath);
-      let item_schema = ritem$1.s;
-      let item$1 = {
-        schema: item_schema,
-        location: location
-      };
-      items[idx] = item$1;
-    }
-    let mut = new Schema("array");
-    return {
-      k: 2,
-      p: path,
-      s: (mut.items = items, mut.additionalItems = "strict", mut.serializer = neverBuilder, mut)
-    };
-  }
-  let fieldNames = Object.keys(definition);
-  let properties = {};
-  let items$1 = [];
-  for (let idx$1 = 0, idx_finish$1 = fieldNames.length; idx$1 < idx_finish$1; ++idx$1) {
-    let location$1 = fieldNames[idx$1];
-    let inlinedLocation$1 = fromString(location$1);
-    let ritem$2 = definitionToRitem(definition[location$1], path + ("[" + inlinedLocation$1 + "]"), ritemsByItemPath);
-    let item_schema$1 = ritem$2.s;
-    let item$2 = {
-      schema: item_schema$1,
-      location: location$1
-    };
-    items$1[idx$1] = item$2;
-    properties[location$1] = item_schema$1;
-  }
-  let mut$1 = new Schema("object");
-  return {
-    k: 2,
-    p: path,
-    s: (mut$1.items = items$1, mut$1.properties = properties, mut$1.additionalItems = globalConfig.a, mut$1.serializer = neverBuilder, mut$1)
-  };
-}
-
 function definitionToSchema(definition) {
   if (typeof definition !== "object" || definition === null) {
     return parse$1(definition);
@@ -2860,42 +2798,67 @@ function nested(fieldName) {
   return ctx$1;
 }
 
-function advancedBuilder(definition, flattened) {
-  return (b, input, selfSchema, path) => {
-    let isFlatten = b.g.o & 64;
-    let outputs = isFlatten ? input.properties : ({});
-    if (!isFlatten) {
-      let items = selfSchema.items;
-      for (let idx = 0, idx_finish = items.length; idx < idx_finish; ++idx) {
-        let match = items[idx];
-        let location = match.location;
-        let itemInput = get(b, input, location);
-        let inlinedLocation = inlineLocation(b, location);
-        let path$1 = path + ("[" + inlinedLocation + "]");
-        outputs[location] = parse(b, match.schema, itemInput, path$1);
-      }
-      objectStrictModeCheck(b, input, items, selfSchema, path);
-    }
-    if (flattened !== undefined) {
-      let prevFlag = b.g.o;
-      b.g.o = prevFlag | 64;
-      for (let idx$1 = 0, idx_finish$1 = flattened.length; idx$1 < idx_finish$1; ++idx$1) {
-        let item = flattened[idx$1];
-        outputs[item.i] = parse(b, item.schema, input, path);
-      }
-      b.g.o = prevFlag;
+function definitionToRitem(definition, path, ritemsByItemPath) {
+  if (typeof definition !== "object" || definition === null) {
+    return {
+      k: 1,
+      p: path,
+      s: copyWithoutCache(parse$1(definition))
+    };
+  }
+  let item = definition[itemSymbol];
+  if (item !== undefined) {
+    let ritemSchema = copyWithoutCache(getOutputSchema(item.schema));
+    ((delete ritemSchema.serializer));
+    let ritem = {
+      k: 0,
+      p: path,
+      s: ritemSchema
+    };
+    item.r = ritem;
+    ritemsByItemPath[getFullDitemPath(item)] = ritem;
+    return ritem;
+  }
+  if (Array.isArray(definition)) {
+    let items = [];
+    for (let idx = 0, idx_finish = definition.length; idx < idx_finish; ++idx) {
+      let location = idx.toString();
+      let inlinedLocation = "\"" + location + "\"";
+      let ritem$1 = definitionToRitem(definition[idx], path + ("[" + inlinedLocation + "]"), ritemsByItemPath);
+      let item_schema = ritem$1.s;
+      let item$1 = {
+        schema: item_schema,
+        location: location
+      };
+      items[idx] = item$1;
     }
-    let getItemOutput = item => {
-      switch (item.k) {
-        case 0 :
-          return outputs[item.location];
-        case 1 :
-          return get(b, getItemOutput(item.of), item.location);
-        case 2 :
-          return outputs[item.i];
-      }
+    let mut = new Schema("array");
+    return {
+      k: 2,
+      p: path,
+      s: (mut.items = items, mut.additionalItems = "strict", mut.serializer = neverBuilder, mut)
     };
-    return definitionToOutput(b, definition, getItemOutput, selfSchema.to);
+  }
+  let fieldNames = Object.keys(definition);
+  let properties = {};
+  let items$1 = [];
+  for (let idx$1 = 0, idx_finish$1 = fieldNames.length; idx$1 < idx_finish$1; ++idx$1) {
+    let location$1 = fieldNames[idx$1];
+    let inlinedLocation$1 = fromString(location$1);
+    let ritem$2 = definitionToRitem(definition[location$1], path + ("[" + inlinedLocation$1 + "]"), ritemsByItemPath);
+    let item_schema$1 = ritem$2.s;
+    let item$2 = {
+      schema: item_schema$1,
+      location: location$1
+    };
+    items$1[idx$1] = item$2;
+    properties[location$1] = item_schema$1;
+  }
+  let mut$1 = new Schema("object");
+  return {
+    k: 2,
+    p: path,
+    s: (mut$1.items = items$1, mut$1.properties = properties, mut$1.additionalItems = globalConfig.a, mut$1.serializer = neverBuilder, mut$1)
   };
 }
 
@@ -2989,6 +2952,45 @@ function definitionToTarget(definition, to, flattened) {
   return mut;
 }
 
+function advancedBuilder(definition, flattened) {
+  return (b, input, selfSchema, path) => {
+    let isFlatten = b.g.o & 64;
+    let outputs = isFlatten ? input.properties : ({});
+    if (!isFlatten) {
+      let items = selfSchema.items;
+      for (let idx = 0, idx_finish = items.length; idx < idx_finish; ++idx) {
+        let match = items[idx];
+        let location = match.location;
+        let itemInput = get(b, input, location);
+        let inlinedLocation = inlineLocation(b, location);
+        let path$1 = path + ("[" + inlinedLocation + "]");
+        outputs[location] = parse(b, match.schema, itemInput, path$1);
+      }
+      objectStrictModeCheck(b, input, items, selfSchema, path);
+    }
+    if (flattened !== undefined) {
+      let prevFlag = b.g.o;
+      b.g.o = prevFlag | 64;
+      for (let idx$1 = 0, idx_finish$1 = flattened.length; idx$1 < idx_finish$1; ++idx$1) {
+        let item = flattened[idx$1];
+        outputs[item.i] = parse(b, item.schema, input, path);
+      }
+      b.g.o = prevFlag;
+    }
+    let getItemOutput = item => {
+      switch (item.k) {
+        case 0 :
+          return outputs[item.location];
+        case 1 :
+          return get(b, getItemOutput(item.of), item.location);
+        case 2 :
+          return outputs[item.i];
+      }
+    };
+    return definitionToOutput(b, definition, getItemOutput, selfSchema.to);
+  };
+}
+
 function shape(schema, definer) {
   return updateOutput(schema, mut => {
     let ditem = {

packages/sury/tests/S_null_test.res

@@ -168,3 +168,35 @@ test("Serializes Some(None) to null for null nested in null", t => {
     `i=>{if(i===void 0){i=null}else if(typeof i==="object"&&i&&i["BS_PRIVATE_NESTED_SOME_NONE"]===0){i=null}return i}`,
   )
 })
+
+// https://github.com/DZakh/sury/issues/150
+module OuterRecord = {
+  module Inner = {
+    type t = {k?: option<int>}
+
+    let schema = S.schema((s): t => {
+      k: ?s.matches(S.option(S.null(S.int))),
+    })
+  }
+
+  type t = {record?: option<Inner.t>}
+
+  let schema = S.schema(s => {
+    record: ?s.matches(S.option(S.null(Inner.schema))),
+  })
+
+  test("Record schema with optional nullable field", t => {
+    let record = {record: None}
+
+    t->Assert.deepEqual(record, %raw(`{ record: { BS_PRIVATE_NESTED_SOME_NONE: 0 } }`))
+    t->Assert.deepEqual(record->S.reverseConvertOrThrow(schema), %raw(`{ record: null }`))
+    t->Assert.deepEqual(record->S.reverseConvertToJsonStringOrThrow(schema), `{"record":null}`)
+
+    Js.log(schema->S.reverse)
+    t->U.assertCompiledCode(
+      ~schema,
+      ~op=#ReverseConvert,
+      `i=>{let v0=i["record"];if(typeof v0==="object"&&v0){if(v0["BS_PRIVATE_NESTED_SOME_NONE"]===0){v0=null}else{try{let v1=v0["k"];if(typeof v1==="object"&&v1&&v1["BS_PRIVATE_NESTED_SOME_NONE"]===0){v1=null}v0={"k":v1,}}catch(e1){}}}return {"record":v0,}}`,
+    )
+  })
+}

packages/sury/tests/S_option_test.res

@@ -197,7 +197,7 @@ test("Triple nested option support", t => {
   t->U.assertCompiledCode(
     ~schema,
     ~op=#ReverseConvert,
-    `i=>{if(typeof i==="object"&&i){if(i["BS_PRIVATE_NESTED_SOME_NONE"]===0){i=void 0}else if(i["BS_PRIVATE_NESTED_SOME_NONE"]===1){i=void 0}}return i}`,
+    `i=>{if(typeof i==="object"&&i){if(i["BS_PRIVATE_NESTED_SOME_NONE"]===1){i=void 0}else if(i["BS_PRIVATE_NESTED_SOME_NONE"]===0){i=void 0}}return i}`,
   )
 })