TS: Powerful S.to instead of S.transform

Author: DZakh

IDEAS.md

@@ -7,6 +7,7 @@
 - Add `S.brand` for TS API
 - Update Standard Schema error message to only include reason part
 - Fix refinement on union schema which also uses `S.to`
+- TS API: Removed `S.transform` in favor of `S.to`
 
 ## v11
 

packages/sury/scripts/pack/Pack.res

@@ -155,15 +155,14 @@ let filesMapping = [
   ("deepStrict", "S.deepStrict"),
   ("strip", "S.strip"),
   ("deepStrip", "S.deepStrip"),
-  ("to", "S.to"),
+  ("to", "S.js_to"),
   ("toJSONSchema", "S.toJSONSchema"),
   ("fromJSONSchema", "S.fromJSONSchema"),
   ("extendJSONSchema", "S.extendJSONSchema"),
   ("shape", "S.shape"),
   ("tuple", "S.tuple"),
   ("asyncParserRefine", "S.js_asyncParserRefine"),
   ("refine", "S.js_refine"),
-  ("transform", "S.js_transform"),
   ("meta", "S.meta"),
   ("toExpression", "S.toExpression"),
   ("noValidation", "S.noValidation"),

packages/sury/scripts/pack/Pack.res.mjs

@@ -227,7 +227,7 @@ let filesMapping = [
   ],
   [
     "to",
-    "S.to"
+    "S.js_to"
   ],
   [
     "toJSONSchema",
@@ -257,10 +257,6 @@ let filesMapping = [
     "refine",
     "S.js_refine"
   ],
-  [
-    "transform",
-    "S.js_transform"
-  ],
   [
     "meta",
     "S.meta"

packages/sury/scripts/pack/Prepack.res.mjs

@@ -100,7 +100,7 @@ var filesMapping = [
   ["tuple", "S.tuple"],
   ["asyncParserRefine", "S.js_asyncParserRefine"],
   ["refine", "S.js_refine"],
-  ["transform", "S.js_transform"],
+  ["transform", "S.js_to"],
   ["meta", "S.meta"],
   ["toExpression", "S.toExpression"],
   ["noValidation", "S.noValidation"],

packages/sury/src/S.d.ts

@@ -96,26 +96,29 @@ export type JSON =
   | JSON[];
 
 export type Schema<Output, Input = unknown> = {
-  with<Transformed>(
-    transform: (
+  with<TargetOutput = unknown, TargetInput = unknown>(
+    to: (
       schema: Schema<unknown, unknown>,
-      parser:
-        | ((value: unknown, s: EffectCtx<unknown, unknown>) => unknown)
-        | undefined,
-      serializer?: (value: unknown, s: EffectCtx<unknown, unknown>) => Input
+      target: Schema<unknown, unknown>,
+      decode?: ((value: unknown) => unknown) | undefined,
+      encode?: (value: unknown) => Output
     ) => Schema<unknown, unknown>,
-    parser:
-      | ((value: Output, s: EffectCtx<unknown, unknown>) => Transformed)
-      | undefined,
-    serializer?: (value: Transformed, s: EffectCtx<unknown, unknown>) => Input
-  ): Schema<Transformed, Input>;
-  with(
+    target: Schema<TargetOutput, TargetInput>,
+    decode?: ((value: Output) => TargetInput) | undefined,
+    encode?: (value: TargetInput) => Output
+  ): Schema<TargetOutput, Input>;
+  // I don't know how, but it makes both S.refine and S.shape work
+  with<Shape>(
     refine: (
       schema: Schema<unknown, unknown>,
-      refiner: (value: unknown, s: EffectCtx<unknown, unknown>) => Promise<void>
+      refiner:
+        | ((value: unknown, s: EffectCtx<unknown, unknown>) => unknown)
+        | undefined
     ) => Schema<unknown, unknown>,
-    refiner: (value: Output, s: EffectCtx<Output, Input>) => Promise<void>
-  ): Schema<Output, Input>;
+    refiner:
+      | ((value: Output, s: EffectCtx<unknown, unknown>) => Shape)
+      | undefined
+  ): Schema<Shape, Input>;
   // with(message: string): t<Output, Input>; TODO: implement
   with<O, I>(fn: (schema: Schema<Output, Input>) => Schema<O, I>): Schema<O, I>;
   with<O, I, A1 extends string>(
@@ -619,14 +622,6 @@ export function refine<Output, Input>(
   refiner: (value: Output, s: EffectCtx<Output, Input>) => void
 ): Schema<Output, Input>;
 
-export function transform<Transformed, Output = unknown, Input = unknown>(
-  schema: Schema<Output, Input>,
-  parser:
-    | ((value: Output, s: EffectCtx<unknown, unknown>) => Transformed)
-    | undefined,
-  serializer?: (value: Transformed, s: EffectCtx<unknown, unknown>) => Output
-): Schema<Transformed, Input>;
-
 export const min: <Output extends string | number | unknown[], Input>(
   schema: Schema<Output, Input>,
   length: number,
@@ -726,20 +721,22 @@ export function compile<
   ? Promise<CompileOutputMappings<Input, Output>[OutputOption]>
   : never;
 
-export function shape<Output, Input, Shape>(
+export function shape<Shape = unknown, Output = unknown, Input = unknown>(
   schema: Schema<Output, Input>,
   shaper: (value: Output) => Shape
 ): Schema<Shape, Input>;
 
 export function to<
-  FromInput,
-  ToOutput,
-  FromOutput = FromInput,
-  ToInput = ToOutput
+  Output = unknown,
+  Input = unknown,
+  TargetInput = unknown,
+  TargetOutput = unknown
 >(
-  from: Schema<FromOutput, FromInput>,
-  to: Schema<ToOutput, ToInput>
-): Schema<ToOutput, FromInput>;
+  schema: Schema<Output, Input>,
+  target: Schema<TargetOutput, TargetInput>,
+  decode?: ((value: Output) => TargetInput) | undefined,
+  encode?: (value: TargetOutput) => Output
+): Schema<TargetOutput, Input>;
 
 export function toJSONSchema<Output, Input>(
   schema: Schema<Output, Input>

packages/sury/src/S.js

@@ -44,15 +44,14 @@ export var strict = S.strict
 export var deepStrict = S.deepStrict
 export var strip = S.strip
 export var deepStrip = S.deepStrip
-export var to = S.to
+export var to = S.js_to
 export var toJSONSchema = S.toJSONSchema
 export var fromJSONSchema = S.fromJSONSchema
 export var extendJSONSchema = S.extendJSONSchema
 export var shape = S.shape
 export var tuple = S.tuple
 export var asyncParserRefine = S.js_asyncParserRefine
 export var refine = S.js_refine
-export var transform = S.js_transform
 export var meta = S.meta
 export var toExpression = S.toExpression
 export var noValidation = S.noValidation

packages/sury/src/S.resi

@@ -257,6 +257,7 @@ and errorCode =
   | OperationFailed(string)
   | InvalidOperation({description: string})
   | InvalidType({expected: schema<unknown>, received: unknown, unionErrors?: array<error>})
+  | FailedTransformation({from: schema<unknown>, to: schema<unknown>, error: exn})
   | UnsupportedTransformation({from: schema<unknown>, to: schema<unknown>})
   | ExcessField(string)
   | UnexpectedAsync

packages/sury/src/Sury.res

@@ -573,6 +573,7 @@ and errorCode =
   | OperationFailed(string)
   | InvalidOperation({description: string})
   | InvalidType({expected: schema<unknown>, received: unknown, unionErrors?: array<error>})
+  | FailedTransformation({from: schema<unknown>, to: schema<unknown>, error: exn})
   | UnsupportedTransformation({from: schema<unknown>, to: schema<unknown>})
   | ExcessField(string)
   | UnexpectedAsync
@@ -829,6 +830,14 @@ Schema.prototype = sp;
       `Unsupported transformation from ${from->toExpression} to ${to->toExpression}`
     | UnexpectedAsync => "Encountered unexpected async transform or refine. Use parseAsyncOrThrow operation instead"
     | ExcessField(fieldName) => `Unrecognized key "${fieldName}"`
+    | FailedTransformation(_) => {
+        let text = %raw(`"" + reason$1.error`)
+        if text->String.startsWith("Error: ") {
+          text->String.slice(~start=7)
+        } else {
+          text
+        }
+      }
     | InvalidType({expected: schema, received, ?unionErrors}) =>
       let m = ref(`Expected ${schema->toExpression}, received ${received->stringify}`)
       switch unionErrors {
@@ -5431,19 +5440,48 @@ let js_union = values =>
     values->Js.Array2.map(Schema.definitionToSchema)->(Obj.magic: array<internal> => array<'a>),
   )
 
-let js_transform = (schema, ~parser as maybeParser=?, ~serializer as maybeSerializer=?) => {
-  schema->transform(s => {
-    {
-      parser: ?switch maybeParser {
-      | Some(parser) => Some(v => parser(v, s))
-      | None => None
-      },
-      serializer: ?switch maybeSerializer {
-      | Some(serializer) => Some(v => serializer(v, s))
-      | None => None
-      },
-    }
-  })
+let js_to = {
+  // FIXME: Test how it'll work if we have async var as input
+  let customBuilder = (~from, ~target, ~fn) => {
+    Builder.make((b, ~input, ~selfSchema as _, ~path) => {
+      let output = b->B.allocateVal(~schema=target)
+      b.code = `try{${output.inline}=${b->B.embed(fn)}(${input.inline})}catch(x){${b->B.failWithArg(
+          ~path,
+          e => FailedTransformation({
+            from: from->castToPublic,
+            to: target->castToPublic,
+            error: e,
+          }),
+          `x`,
+        )}}`
+      output
+    })
+  }
+
+  (
+    schema,
+    target,
+    ~decoder as maybeDecoder: option<'value => 'target>=?,
+    ~encoder as maybeEncoder: option<'target => 'value>=?,
+  ) => {
+    updateOutput(schema->castToInternal, mut => {
+      let target = target->castToInternal
+      let target = switch maybeEncoder {
+      | Some(fn) =>
+        let targetMut = target->copySchema
+        targetMut.serializer = Some(
+          customBuilder(~from=target, ~target=schema->castToInternal, ~fn),
+        )
+        targetMut
+      | None => target
+      }
+      mut.to = Some(target)
+      switch maybeDecoder {
+      | Some(fn) => mut.parser = Some(customBuilder(~from=schema->castToInternal, ~target, ~fn))
+      | None => ()
+      }
+    })
+  }
 }
 
 let js_refine = (schema, refiner) => {