Use built-in JSON String transformation for JSON String output in S.compile

Author: DZakh

IDEAS.md

@@ -1,10 +1,8 @@
 # Ideas draft
 
-## Alpha.3
+## Alpha.4
 
-- `S.unknown.with(S.to, S.schema(true).with(S.noValidation, true))` - Support transformation to literals without validation, to be able to set the output value. (This is how assert works)
-- Use ReScript v12
-- Use unboxed variants for JSONSchema definitions and dependencies
+- Use built-in JSON String transformation for JSON String output in `S.compile`
 
 ## v11
 

packages/sury/src/Sury.res

@@ -1669,6 +1669,8 @@ let failTransform = (b, ~inputVar, ~path, ~target) => {
 
 let jsonName = `JSON`
 
+let jsonString = shaken("jsonString")
+
 let inputToString = (b, input: val) => {
   b->B.val(`""+${input.inline}`, ~schema=string)
 }
@@ -1968,6 +1970,12 @@ and internalCompile = (~schema, ~flag, ~defs) => {
       mut.to = Some(t)
     })
     ->castToInternal
+  } else if flag->Flag.unsafeHas(Flag.jsonStringOutput) {
+    schema
+    ->updateOutput(mut => {
+      mut.to = Some(jsonString)
+    })
+    ->castToInternal
   } else {
     schema
   }
@@ -1979,17 +1987,10 @@ and internalCompile = (~schema, ~flag, ~defs) => {
   let isAsync = output.flag->Flag.has(ValFlag.async)
   schema.isAsync = Some(isAsync)
 
-  if (
-    code === "" &&
-    output === input &&
-    !(flag->Flag.unsafeHas(Flag.async->Flag.with(Flag.jsonStringOutput)))
-  ) {
+  if code === "" && output === input && !(flag->Flag.unsafeHas(Flag.async)) {
     Builder.noopOperation
   } else {
     let inlinedOutput = ref(output.inline)
-    if flag->Flag.unsafeHas(Flag.jsonStringOutput) {
-      inlinedOutput := `JSON.stringify(${inlinedOutput.contents})`
-    }
     if flag->Flag.unsafeHas(Flag.async) && !isAsync && !(defs->Obj.magic) {
       inlinedOutput := `Promise.resolve(${inlinedOutput.contents})`
     }
@@ -3556,8 +3557,6 @@ let enableJson = () => {
   }
 }
 
-let jsonString = shaken("jsonString")
-
 let enableJsonString = {
   let inlineJsonString = (b, ~schema, ~selfSchema, ~path) => {
     let tagFlag = schema.tag->TagFlag.get

packages/sury/src/Sury.res.mjs

@@ -972,6 +972,8 @@ function setHas(has, tag) {
 
 let jsonName = "JSON";
 
+let jsonString = shaken("jsonString");
+
 function inputToString(b, input) {
   return val(b, "\"\"+" + input.i, string);
 }
@@ -1154,16 +1156,43 @@ function parse(prevB, schema, inputArg, path) {
   return input;
 }
 
-function getOutputSchema(_schema) {
-  while (true) {
-    let schema = _schema;
-    let to = schema.to;
-    if (to === undefined) {
-      return schema;
-    }
-    _schema = to;
-    continue;
+function internalCompile(schema, flag, defs) {
+  let b = rootScope(flag, defs);
+  if (flag & 8) {
+    let output = reverse(schema);
+    jsonableValidation(output, output, "", flag);
+  }
+  let input = {
+    b: b,
+    v: _var,
+    i: "i",
+    f: 0,
+    type: "unknown"
   };
+  let schema$1 = flag & 4 ? updateOutput(schema, mut => {
+      let t = new Schema(unit.type);
+      t.const = unit.const;
+      t.noValidation = true;
+      mut.to = t;
+    }) : (
+      flag & 16 ? updateOutput(schema, mut => {
+          mut.to = jsonString;
+        }) : schema
+    );
+  let output$1 = parse(b, schema$1, input, "");
+  let code = allocateScope(b);
+  let isAsync = has(output$1.f, 2);
+  schema$1.isAsync = isAsync;
+  if (code === "" && output$1 === input && !(flag & 2)) {
+    return noopOperation;
+  }
+  let inlinedOutput = output$1.i;
+  if (flag & 2 && !isAsync && !defs) {
+    inlinedOutput = "Promise.resolve(" + inlinedOutput + ")";
+  }
+  let inlinedFunction = "i=>{" + code + "return " + inlinedOutput + "}";
+  let ctxVarValue1 = b.g.e;
+  return new Function("e", "s", "return " + inlinedFunction)(ctxVarValue1, s);
 }
 
 function reverse(schema) {
@@ -1291,6 +1320,18 @@ function jsonableValidation(output, parent, path, flag) {
   output.items.forEach(item => jsonableValidation(item.schema, output, path + ("[" + fromString(item.location) + "]"), flag));
 }
 
+function getOutputSchema(_schema) {
+  while (true) {
+    let schema = _schema;
+    let to = schema.to;
+    if (to === undefined) {
+      return schema;
+    }
+    _schema = to;
+    continue;
+  };
+}
+
 function isAsyncInternal(schema, defs) {
   try {
     let b = rootScope(2, defs);
@@ -1311,44 +1352,6 @@ function isAsyncInternal(schema, defs) {
   }
 }
 
-function internalCompile(schema, flag, defs) {
-  let b = rootScope(flag, defs);
-  if (flag & 8) {
-    let output = reverse(schema);
-    jsonableValidation(output, output, "", flag);
-  }
-  let input = {
-    b: b,
-    v: _var,
-    i: "i",
-    f: 0,
-    type: "unknown"
-  };
-  let schema$1 = flag & 4 ? updateOutput(schema, mut => {
-      let t = new Schema(unit.type);
-      t.const = unit.const;
-      t.noValidation = true;
-      mut.to = t;
-    }) : schema;
-  let output$1 = parse(b, schema$1, input, "");
-  let code = allocateScope(b);
-  let isAsync = has(output$1.f, 2);
-  schema$1.isAsync = isAsync;
-  if (code === "" && output$1 === input && !(flag & 18)) {
-    return noopOperation;
-  }
-  let inlinedOutput = output$1.i;
-  if (flag & 16) {
-    inlinedOutput = "JSON.stringify(" + inlinedOutput + ")";
-  }
-  if (flag & 2 && !isAsync && !defs) {
-    inlinedOutput = "Promise.resolve(" + inlinedOutput + ")";
-  }
-  let inlinedFunction = "i=>{" + code + "return " + inlinedOutput + "}";
-  let ctxVarValue1 = b.g.e;
-  return new Function("e", "s", "return " + inlinedFunction)(ctxVarValue1, s);
-}
-
 function operationFn(s, o) {
   if ((o in s)) {
     return (s[o]);
@@ -2371,8 +2374,6 @@ function enableJson() {
   json.$defs = defs;
 }
 
-let jsonString = shaken("jsonString");
-
 function inlineJsonString(b, schema, selfSchema, path) {
   let tagFlag = flags[schema.type];
   let $$const = schema.const;
@@ -2859,6 +2860,45 @@ 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;
+    }
+    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 definitionToTarget(definition, to, flattened) {
   let ritemsByItemPath = {};
   let ritem = definitionToRitem(definition, "", ritemsByItemPath);
@@ -2949,45 +2989,6 @@ 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_compile_test.res

@@ -1,5 +1,7 @@
 open Ava
 
+S.enableJsonString()
+
 let assertCode = (t, fn: 'a => 'b, code) => {
   t->Assert.is((fn->Obj.magic)["toString"](), code)
 }
@@ -17,9 +19,9 @@ test("Doesn't compile primitive unknown with assert output to noop", t => {
 })
 
 test("Doesn't compile to noop when primitive converted to json string", t => {
-  let schema = S.string
+  let schema = S.bool
   let fn = schema->S.compile(~input=Any, ~output=JsonString, ~mode=Sync, ~typeValidation=false)
-  t->assertCode(fn, `i=>{return JSON.stringify(i)}`)
+  t->assertCode(fn, `i=>{return ""+i}`)
 })
 
 test("JsonString output with Async mode", t => {