nonNullable to disallow null

README.md

@@ -1179,6 +1179,31 @@ const nullableString = stringSchema.nullable();
 nullableString.unwrap() === stringSchema; // true
 ```
 
+## NonNullables
+
+You can also make something NonNullable, using `z.nonNullable()`.
+
+```ts
+const nullableString = z.nonNullable(z.any());
+nullableString.parse("asdf"); // => "asdf"
+nullableString.parse(null); // fails
+```
+
+Or use the `.nonNullable()` method.
+
+```ts
+const E = z.any().nonNullable();
+type E = z.infer<typeof E>; // NonNullable<any>
+```
+
+Extract the inner schema with `.unwrap()`.
+
+```ts
+const stringSchema = z.any();
+const nullableString = stringSchema.nonNullable();
+nullableString.unwrap() === stringSchema; // true
+```
+
 ## Objects
 
 ```ts

deno/lib/README.md

@@ -1179,6 +1179,31 @@ const nullableString = stringSchema.nullable();
 nullableString.unwrap() === stringSchema; // true
 ```
 
+## NonNullables
+
+You can also make something NonNullable, using `z.nonNullable()`.
+
+```ts
+const nullableString = z.nonNullable(z.any());
+nullableString.parse("asdf"); // => "asdf"
+nullableString.parse(null); // fails
+```
+
+Or use the `.nonNullable()` method.
+
+```ts
+const E = z.any().nonNullable();
+type E = z.infer<typeof E>; // NonNullable<any>
+```
+
+Extract the inner schema with `.unwrap()`.
+
+```ts
+const stringSchema = z.any();
+const nullableString = stringSchema.nonNullable();
+nullableString.unwrap() === stringSchema; // true
+```
+
 ## Objects
 
 ```ts

deno/lib/__tests__/firstparty.test.ts

@@ -68,6 +68,8 @@ test("first party switch", () => {
  break;
  case z.ZodFirstPartyTypeKind.ZodNullable:
  break;
+ case z.ZodFirstPartyTypeKind.ZodNonNullable:
+ break;
  case z.ZodFirstPartyTypeKind.ZodDefault:
  break;
  case z.ZodFirstPartyTypeKind.ZodCatch:

deno/lib/__tests__/nonNullable.test.ts

@@ -0,0 +1,40 @@
+// @ts-ignore TS6133
+import { expect } from "https://deno.land/x/[email protected]/mod.ts";
+const test = Deno.test;
+
+import * as z from "../index.ts";
+
+test("parses a number correctly using z....nonNullable()", () => {
+ const a = z.nullable(z.number()).nonNullable();
+ type a = z.infer<typeof a>;
+ const foo: a = a.parse(5);
+ expect(foo).toEqual(5);
+});
+
+test("parses a number correctly using z.nonNullable(...)", () => {
+ const a = z.nonNullable(z.any());
+ type a = z.infer<typeof a>;
+ const foo: a = a.parse(5);
+ expect(foo).toEqual(5);
+});
+
+test("fails is passed null", () => {
+ const a = z.nullable(z.any()).nonNullable();
+
+ expect(() => {
+ a.parse(null);
+ }).toThrow(z.ZodError)
+});
+
+test("fails is passed undefined", () => {
+ const a = z.nullable(z.any()).nonNullable();
+
+ expect(() => {
+ a.parse(undefined);
+ }).toThrow(z.ZodError)
+});
+
+test("unwrap", () => {
+ const unwrapped = z.any().nonNullable().unwrap();
+ expect(unwrapped).toBeInstanceOf(z.ZodAny);
+});

deno/lib/helpers/util.ts

@@ -159,6 +159,7 @@ export const ZodParsedType = util.arrayToEnum([
  "never",
  "map",
  "set",
+ "nonNullable"
 ]);
 
 export type ZodParsedType = keyof typeof ZodParsedType;

deno/lib/types.ts

@@ -410,6 +410,9 @@ export abstract class ZodType<
  this.isOptional = this.isOptional.bind(this);
  }
 
+ nonNullable(): ZodNonNullable<this> {
+ return ZodNonNullable.create(this, this._def) as any;
+ }
  optional(): ZodOptional<this> {
  return ZodOptional.create(this, this._def) as any;
  }
@@ -4455,6 +4458,59 @@ export class ZodOptional<T extends ZodTypeAny> extends ZodType<
  };
 }
 
+//////////////////////////////////////////
+//////////////////////////////////////////
+////////// ///////////
+////////// ZodNonNullable ///////////
+////////// ///////////
+//////////////////////////////////////////
+//////////////////////////////////////////
+export interface ZodNonNullableDef<T extends ZodTypeAny = ZodTypeAny>
+ extends ZodTypeDef {
+ innerType: T;
+ typeName: ZodFirstPartyTypeKind.ZodNonNullable;
+}
+
+export type ZodNonNullableType<T extends ZodTypeAny> = ZodNonNullable<T>;
+
+export class ZodNonNullable<T extends ZodTypeAny> extends ZodType<
+ NonNullable<T["_output"]>,
+ ZodNonNullableDef<T>,
+ T["_input"]
+> {
+ _parse(input: ParseInput): ParseReturnType<this["_output"]> {
+ const parsedType = this._getType(input);
+ if (
+ parsedType === ZodParsedType.null ||
+ parsedType === ZodParsedType.undefined
+ ) {
+ const { ctx } = this._processInputParams(input);
+ addIssueToContext(ctx, {
+ code: ZodIssueCode.invalid_type,
+ expected: ZodParsedType.nonNullable,
+ received: ctx.parsedType,
+ });
+ return INVALID;
+ }
+ return this._def.innerType._parse(input);
+ }
+
+ unwrap() {
+ return this._def.innerType;
+ }
+
+ static create = <T extends ZodTypeAny>(
+ type: T,
+ params?: RawCreateParams
+ ): ZodNonNullable<T> => {
+ return new ZodNonNullable({
+ innerType: type,
+ typeName: ZodFirstPartyTypeKind.ZodNonNullable,
+ ...processCreateParams(params),
+ }) as any;
+ };
+}
+
 ///////////////////////////////////////////
 ///////////////////////////////////////////
 ////////// //////////
@@ -4927,6 +4983,7 @@ export enum ZodFirstPartyTypeKind {
  ZodEffects = "ZodEffects",
  ZodNativeEnum = "ZodNativeEnum",
  ZodOptional = "ZodOptional",
+ ZodNonNullable = "ZodNonNullable",
  ZodNullable = "ZodNullable",
  ZodDefault = "ZodDefault",
  ZodCatch = "ZodCatch",
@@ -4965,6 +5022,7 @@ export type ZodFirstPartySchemaTypes =
  | ZodNativeEnum<any>
  | ZodOptional<any>
  | ZodNullable<any>
+ | ZodNonNullable<any>
  | ZodDefault<any>
  | ZodCatch<any>
  | ZodPromise<any>
@@ -5015,6 +5073,7 @@ const promiseType = ZodPromise.create;
 const effectsType = ZodEffects.create;
 const optionalType = ZodOptional.create;
 const nullableType = ZodNullable.create;
+const nonNullableType = ZodNonNullable.create;
 const preprocessType = ZodEffects.createWithPreprocess;
 const pipelineType = ZodPipeline.create;
 const ostring = () => stringType().optional();
@@ -5055,6 +5114,7 @@ export {
  nanType as nan,
  nativeEnumType as nativeEnum,
  neverType as never,
+ nonNullableType as nonNullable,
  nullType as null,
  nullableType as nullable,
  numberType as number,

src/__tests__/firstparty.test.ts

@@ -67,6 +67,8 @@ test("first party switch", () => {
  break;
  case z.ZodFirstPartyTypeKind.ZodNullable:
  break;
+ case z.ZodFirstPartyTypeKind.ZodNonNullable:
+ break;
  case z.ZodFirstPartyTypeKind.ZodDefault:
  break;
  case z.ZodFirstPartyTypeKind.ZodCatch:

src/__tests__/nonNullable.test.ts

@@ -0,0 +1,39 @@
+// @ts-ignore TS6133
+import { expect, test } from "@jest/globals";
+
+import * as z from "../index";
+
+test("parses a number correctly using z....nonNullable()", () => {
+ const a = z.nullable(z.number()).nonNullable();
+ type a = z.infer<typeof a>;
+ const foo: a = a.parse(5);
+ expect(foo).toEqual(5);
+});
+
+test("parses a number correctly using z.nonNullable(...)", () => {
+ const a = z.nonNullable(z.any());
+ type a = z.infer<typeof a>;
+ const foo: a = a.parse(5);
+ expect(foo).toEqual(5);
+});
+
+test("fails is passed null", () => {
+ const a = z.nullable(z.any()).nonNullable();
+
+ expect(() => {
+ a.parse(null);
+ }).toThrow(z.ZodError)
+});
+
+test("fails is passed undefined", () => {
+ const a = z.nullable(z.any()).nonNullable();
+
+ expect(() => {
+ a.parse(undefined);
+ }).toThrow(z.ZodError)
+});
+
+test("unwrap", () => {
+ const unwrapped = z.any().nonNullable().unwrap();
+ expect(unwrapped).toBeInstanceOf(z.ZodAny);
+});

src/helpers/util.ts

@@ -159,6 +159,7 @@ export const ZodParsedType = util.arrayToEnum([
  "never",
  "map",
  "set",
+ "nonNullable"
 ]);
 
 export type ZodParsedType = keyof typeof ZodParsedType;

src/types.ts

@@ -410,6 +410,9 @@ export abstract class ZodType<
  this.isOptional = this.isOptional.bind(this);
  }
 
+ nonNullable(): ZodNonNullable<this> {
+ return ZodNonNullable.create(this, this._def) as any;
+ }
  optional(): ZodOptional<this> {
  return ZodOptional.create(this, this._def) as any;
  }
@@ -4455,6 +4458,59 @@ export class ZodOptional<T extends ZodTypeAny> extends ZodType<
  };
 }
 
+//////////////////////////////////////////
+//////////////////////////////////////////
+////////// ///////////
+////////// ZodNonNullable ///////////
+////////// ///////////
+//////////////////////////////////////////
+//////////////////////////////////////////
+export interface ZodNonNullableDef<T extends ZodTypeAny = ZodTypeAny>
+ extends ZodTypeDef {
+ innerType: T;
+ typeName: ZodFirstPartyTypeKind.ZodNonNullable;
+}
+
+export type ZodNonNullableType<T extends ZodTypeAny> = ZodNonNullable<T>;
+
+export class ZodNonNullable<T extends ZodTypeAny> extends ZodType<
+ NonNullable<T["_output"]>,
+ ZodNonNullableDef<T>,
+ T["_input"]
+> {
+ _parse(input: ParseInput): ParseReturnType<this["_output"]> {
+ const parsedType = this._getType(input);
+ if (
+ parsedType === ZodParsedType.null ||
+ parsedType === ZodParsedType.undefined
+ ) {
+ const { ctx } = this._processInputParams(input);
+ addIssueToContext(ctx, {
+ code: ZodIssueCode.invalid_type,
+ expected: ZodParsedType.nonNullable,
+ received: ctx.parsedType,
+ });
+ return INVALID;
+ }
+ return this._def.innerType._parse(input);
+ }
+
+ unwrap() {
+ return this._def.innerType;
+ }
+
+ static create = <T extends ZodTypeAny>(
+ type: T,
+ params?: RawCreateParams
+ ): ZodNonNullable<T> => {
+ return new ZodNonNullable({
+ innerType: type,
+ typeName: ZodFirstPartyTypeKind.ZodNonNullable,
+ ...processCreateParams(params),
+ }) as any;
+ };
+}
+
 ///////////////////////////////////////////
 ///////////////////////////////////////////
 ////////// //////////
@@ -4927,6 +4983,7 @@ export enum ZodFirstPartyTypeKind {
  ZodEffects = "ZodEffects",
  ZodNativeEnum = "ZodNativeEnum",
  ZodOptional = "ZodOptional",
+ ZodNonNullable = "ZodNonNullable",
  ZodNullable = "ZodNullable",
  ZodDefault = "ZodDefault",
  ZodCatch = "ZodCatch",
@@ -4965,6 +5022,7 @@ export type ZodFirstPartySchemaTypes =
  | ZodNativeEnum<any>
  | ZodOptional<any>
  | ZodNullable<any>
+ | ZodNonNullable<any>
  | ZodDefault<any>
  | ZodCatch<any>
  | ZodPromise<any>
@@ -5015,6 +5073,7 @@ const promiseType = ZodPromise.create;
 const effectsType = ZodEffects.create;
 const optionalType = ZodOptional.create;
 const nullableType = ZodNullable.create;
+const nonNullableType = ZodNonNullable.create;
 const preprocessType = ZodEffects.createWithPreprocess;
 const pipelineType = ZodPipeline.create;
 const ostring = () => stringType().optional();
@@ -5055,6 +5114,7 @@ export {
  nanType as nan,
  nativeEnumType as nativeEnum,
  neverType as never,
+ nonNullableType as nonNullable,
  nullType as null,
  nullableType as nullable,
  numberType as number,