v8.0.2 🚀

docs/js-usage.md

@@ -31,6 +31,7 @@
 - [JSON string](#json-string)
 - [Describe](#describe)
 - [Custom schema](#custom-schema)
+- [Recursive schemas](#recursive-schemas)
 - [Refinements](#refinements)
 - [Transforms](#transforms)
 - [Functions on schema](#functions-on-schema)
@@ -486,6 +487,26 @@ const mySetSchema = S.custom("MySet", (input, s) => {
 type MySet = S.Output<typeof mySetSchema>; // Set<any>
 ```
 
+## Recursive schemas
+
+You can define a recursive schema in **rescript-schema**. Unfortunately, TypeScript derives the Schema type as `unknown` so you need to explicitly specify the type and it'll start correctly typechecking.
+
+```ts
+type Node = {
+  id: string;
+  children: Node[];
+};
+
+let nodeSchema = S.recursive<Node>((nodeSchema) =>
+  S.object({
+    id: S.string,
+    children: S.array(nodeSchema),
+  })
+);
+```
+
+> 🧠 Despite supporting recursive schema, passing cyclical data into rescript-schema will cause an infinite loop.
+
 ## Refinements
 
 **rescript-schema** lets you provide custom validation logic via refinements. It's useful to add checks that's not possible to cover with type system. For instance: checking that a number is an integer or that a string is a valid email address.

package.json

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

packages/tests/src/core/S_test.ts

@@ -1328,6 +1328,39 @@ test("Assert passes with valid data", (t) => {
   t.pass();
 });
 
+test("Successfully parses recursive object", (t) => {
+  type Node = {
+    id: string;
+    children: Node[];
+  };
+
+  let nodeSchema = S.recursive<Node>((nodeSchema) =>
+    S.object({
+      id: S.string,
+      children: S.array(nodeSchema),
+    })
+  );
+
+  expectType<TypeEqual<typeof nodeSchema, S.Schema<Node, Node>>>(true);
+
+  t.deepEqual(
+    nodeSchema.parseOrThrow({
+      id: "1",
+      children: [
+        { id: "2", children: [] },
+        { id: "3", children: [{ id: "4", children: [] }] },
+      ],
+    }),
+    {
+      id: "1",
+      children: [
+        { id: "2", children: [] },
+        { id: "3", children: [{ id: "4", children: [] }] },
+      ],
+    }
+  );
+});
+
 test("Example", (t) => {
   // Create login schema with email and password
   const loginSchema = S.object({

src/S.d.ts

@@ -86,7 +86,7 @@ export function tuple<A extends UnknownSchema, B extends UnknownSchema[]>(
   [Input<A>, ...SchemaTupleInput<B>]
 >;
 export function tuple<Output>(
-  definer: (ctx: {
+  definer: (s: {
     item: <InputIndex extends number, ItemOutput>(
       inputIndex: InputIndex,
       schema: Schema<ItemOutput, unknown>
@@ -136,13 +136,13 @@ export const union: <A extends UnknownSchema, B extends UnknownSchema[]>(
 >;
 
 export function schema<Value>(
-  definer: (ctx: {
+  definer: (s: {
     matches: <Output>(schema: Schema<Output, unknown>) => Output;
   }) => Value
 ): Schema<Value, unknown>;
 
 export function object<Output>(
-  definer: (ctx: {
+  definer: (s: {
     field: <InputFieldName extends string, FieldOutput>(
       inputFieldName: InputFieldName,
       schema: Schema<FieldOutput, unknown>
@@ -194,6 +194,10 @@ export function custom<Output, Input = unknown>(
   serializer: (value: Output, s: EffectCtx<unknown, unknown>) => Input
 ): Schema<Output, Input>;
 
+export function recursive<Output, Input = Output>(
+  definer: (schema: Schema<Output, Input>) => Schema<Output, Input>
+): Schema<Output, Input>;
+
 export function name(schema: Schema<unknown, unknown>): string;
 export function setName<Output, Input>(
   schema: Schema<Output, Input>,

src/S.js

@@ -18,6 +18,7 @@ export const jsonString = S.jsonString;
 export const union = S.union;
 export const object = S.js_object;
 export const schema = S.schema;
+export const recursive = S.recursive;
 export const merge = S.js_merge;
 export const Object = S.$$Object;
 export const custom = S.js_custom;