v10.0.4 🚀 - Improve optional and nullable ts types

Author: DZakh

packages/sury/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@sury/sury",
-  "version": "10.0.3",
+  "version": "10.0.4",
   "license": "MIT",
   "exclude": ["!src", "!rescript.json", "!README.md", "!package.json", "!docs"],
   "exports": "./src/S.mjs"

packages/sury/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sury",
-  "version": "10.0.3",
+  "version": "10.0.4",
   "private": true,
   "description": "🧬 The fastest schema with next-gen DX",
   "keywords": [

packages/sury/src/S.d.ts

@@ -455,25 +455,30 @@ export function tuple<Output, Input extends unknown[]>(
   }) => Output
 ): Schema<Output, Input>;
 
-export function optional<Output, Input, Or = undefined>(
+export function optional<
+  Output,
+  Input,
+  Or extends Output | undefined = undefined
+>(
   schema: Schema<Output, Input>,
   or?: (() => Or) | Or,
   // To make .with work
   _?: never
 ): Schema<
-  Or extends undefined ? Output | undefined : Output | Or,
+  Or extends undefined ? Output | undefined : Output,
   Input | undefined
 >;
 
-export function nullable<Output, Input, Or = undefined>(
+export function nullable<
+  Output,
+  Input,
+  Or extends Output | undefined = undefined
+>(
   schema: Schema<Output, Input>,
   or?: (() => Or) | Or,
   // To make .with work
   _?: never
-): Schema<
-  Or extends undefined ? Output | undefined : Output | Or,
-  Input | null
->;
+): Schema<Or extends undefined ? Output | undefined : Output, Input | null>;
 
 export const nullish: <Output, Input>(
   schema: Schema<Output, Input>

packages/sury/tests/S_test.ts

@@ -387,6 +387,20 @@ test("Successfully parses nullable string", (t) => {
   expectType<TypeEqual<typeof value1, string | undefined>>(true);
 });
 
+test("Successfully parses nullable of array with default", (t) => {
+  const schema = S.nullable(S.array(S.string), []);
+  const value1 = S.parseOrThrow(["foo"], schema);
+  const value2 = S.parseOrThrow(null, schema);
+
+  t.deepEqual(value1, ["foo"]);
+  t.deepEqual(value2, []);
+
+  expectType<TypeEqual<S.Schema<string[], string[] | null>, typeof schema>>(
+    true
+  );
+  expectType<TypeEqual<typeof value1, string[]>>(true);
+});
+
 test("Successfully parses nullable string with default", (t) => {
   const schema = S.nullable(S.string, "bar");
   const value1 = S.parseOrThrow("foo", schema);

packages/sury/tests/index.ts

@@ -0,0 +1,41 @@
+import * as S from "sury";
+
+export const databaseContextSchema = S.schema({
+  schemas: S.nullable(
+    S.array(
+      S.schema({
+        schema: S.string,
+        tables: S.nullable(
+          S.array(
+            S.schema({
+              name: S.string,
+              columns: S.nullable(
+                S.array(
+                  S.schema({
+                    name: S.string,
+                    type: S.string,
+                    nullable: S.boolean,
+                    default: S.nullable(S.string),
+                  })
+                ),
+                []
+              ),
+            })
+          ),
+          []
+        ),
+      })
+    ),
+    []
+  ),
+  enums: S.nullable(
+    S.array(
+      S.schema({
+        schema: S.string,
+        name: S.string,
+        value: S.string,
+      })
+    ),
+    []
+  ),
+});