Socket
Socket
Sign inDemoInstall

zod

Package Overview
Dependencies
Maintainers
1
Versions
361
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

zod - npm Package Compare versions

Comparing version 1.11.0-alpha.6 to 1.11.0

lib/src/isScalar.d.ts
lib/src/isScalar.js
lib/src/isScalar.js.map
lib/src/switcher.d.ts
lib/src/switcher.js
lib/src/switcher.js.map
lib/src/types/nativeEnum.d.ts
lib/src/types/nativeEnum.js
lib/src/types/nativeEnum.js.map

39

CHANGELOG.md
# Changelog
| zod version | release notes |
| ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| zod@1.10 | Dropping support for TypeScript 3.2 |
| zod@1.9 | Added z.instanceof() and z.custom(). Implemented ZodSchema.array() method. |
| zod@1.8 | Introduced z.void(). Major overhaul to error handling system, including the introduction of custom error maps. Wrote new [error handling guide](https://github.com/vriad/zod/blob/master/ERROR_HANDLING.md). |
| zod@1.7 | Added several built-in validators to string, number, and array schemas. Calls to `.refine` now return new instance. |
| zod@1.5 | Any and unknown types |
| zod@1.4 | Refinement types (`.refine`), `.parse` no longer returns deep clone |
| zod@1.3 | Promise schemas |
| zod@1.2.6 | `.parse` accepts `unknown`, `bigint` schemas |
| zod@1.2.5 | `.partial` and `.deepPartial` on object schemas |
| zod@1.2.3 | Date schemas |
| zod@1.2.0 | `.pick`, `.omit`, and `.extend` on object schemas |
| zod@1.1.0 | Records |
| zod@1.0.11 | `.nonstrict` |
| zod@1.0.10 | Type assertions with `.check` |
| zod@1.0.4 | Empty tuples |
| zod@1.0.0 | Type assertions, literals, enums, detailed error reporting |
| zod@1.0.0 | Initial release |
| zod version | release notes |
| ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| zod@1.11 | Introduced `.safeParse` option.<br>Introduced .regex method on string schemas.<br>Switched to `new URL()` constructor to check valid URLs.<br>Implemented `.primitives()` and `.nonprimitives()` on object schemas.<br>Implemented `z.nativeEnum()` for creating schemas from TypeScript `enum`s. |
| zod@1.10 | Dropping support for TypeScript 3.2 . |
| zod@1.9 | Added z.instanceof() and z.custom(). Implemented ZodSchema.array() method. |
| zod@1.8 | Introduced z.void(). Major overhaul to error handling system, including the introduction of custom error maps. Wrote new [error handling guide](https://github.com/vriad/zod/blob/master/ERROR_HANDLING.md). |
| zod@1.7 | Added several built-in validators to string, number, and array schemas. Calls to `.refine` now return new instance. |
| zod@1.5 | Any and unknown types |
| zod@1.4 | Refinement types (`.refine`), `.parse` no longer returns deep clone |
| zod@1.3 | Promise schemas |
| zod@1.2.6 | `.parse` accepts `unknown`, `bigint` schemas |
| zod@1.2.5 | `.partial` and `.deepPartial` on object schemas |
| zod@1.2.3 | Date schemas |
| zod@1.2.0 | `.pick`, `.omit`, and `.extend` on object schemas |
| zod@1.1.0 | Records |
| zod@1.0.11 | `.nonstrict` |
| zod@1.0.10 | Type assertions with `.check` |
| zod@1.0.4 | Empty tuples |
| zod@1.0.0 | Type assertions, literals, enums, detailed error reporting |
| zod@1.0.0 | Initial release |

2

lib/src/codegen.d.ts

@@ -1,2 +0,2 @@

import * as z from '.';
import * as z from './index';
declare type TypeResult = {

@@ -3,0 +3,0 @@ schema: any;

8

lib/src/codegen.js

@@ -10,3 +10,3 @@ "use strict";

Object.defineProperty(exports, "__esModule", { value: true });
var z = __importStar(require("."));
var z = __importStar(require("./index"));
var util_1 = require("./helpers/util");

@@ -134,5 +134,5 @@ var isOptional = function (schema) {

return _this.setType(id, _this.generate(lazyType).id);
case z.ZodTypes.transformer:
var codecOutput = def.output;
return _this.setType(id, _this.generate(codecOutput).id);
case z.ZodTypes.nativeEnum:
// const lazyType = def.getter();
return _this.setType(id, 'asdf');
default:

@@ -139,0 +139,0 @@ util_1.util.assertNever(def);

8

lib/src/defaultErrorMap.js

@@ -52,3 +52,6 @@ "use strict";

case ZodError_1.ZodErrorCode.invalid_string:
message = "Invalid " + error.validation;
if (error.validation !== 'regex')
message = "Invalid " + error.validation;
else
message = 'Invalid';
break;

@@ -84,5 +87,2 @@ // case ZodErrorCode.invalid_url:

break;
case ZodError_1.ZodErrorCode.invalid_intersection_types:
message = "Intersections only support ";
break;
default:

@@ -89,0 +89,0 @@ message = "Invalid input.";

20

lib/src/helpers/objectUtil.d.ts

@@ -28,8 +28,2 @@ import { ZodRawShape } from '../types/base';

}>;
type ObjectIntersectionInput<T extends ZodRawShape> = AddQuestionMarks<{
[k in keyof T]: T[k]['_input'];
}>;
type ObjectIntersectionOutput<T extends ZodRawShape> = AddQuestionMarks<{
[k in keyof T]: T[k]['_input'];
}>;
type Identity<T> = T;

@@ -39,13 +33,11 @@ type FlattenObject<T extends ZodRawShape> = Identity<{

}>;
type NoNeverKeys<T extends object> = {
[k in keyof T]: T[k] extends never ? never : k;
type NoNeverKeys<T extends ZodRawShape> = {
[k in keyof T]: [T[k]] extends [never] ? never : k;
}[keyof T];
type NoNever<T extends object> = {
[k in NoNeverKeys<T>]: T[k];
};
type ObjectType<T extends ZodRawShape> = FlattenObject<ObjectIntersection<NoNever<T>>>;
type ObjectTypeInput<T extends ZodRawShape> = FlattenObject<ObjectIntersectionInput<NoNever<T>>>;
type ObjectTypeOutput<T extends ZodRawShape> = FlattenObject<ObjectIntersectionOutput<NoNever<T>>>;
type NoNever<T extends ZodRawShape> = Identity<{
[k in NoNeverKeys<T>]: k extends keyof T ? T[k] : never;
}>;
type ObjectType<T extends ZodRawShape> = FlattenObject<ObjectIntersection<T>>;
const mergeShapes: <U extends ZodRawShape, T extends ZodRawShape>(first: U, second: T) => T & U;
const mergeObjects: <First extends ZodObject<any, any, any>>(first: First) => <Second extends ZodObject<any, any, any>>(second: Second) => ZodObject<First["_shape"] & Second["_shape"], MergeObjectParams<First["_params"], Second["_params"]>, First["_type"] & Second["_type"]>;
}

2

lib/src/helpers/partialUtil.d.ts

@@ -1,2 +0,2 @@

import * as z from '..';
import * as z from '../index';
export declare namespace partialUtil {

@@ -3,0 +3,0 @@ type RootDeepPartial<T extends z.ZodTypeAny> = {

1

lib/src/helpers/util.d.ts

@@ -8,2 +8,3 @@ export declare namespace util {

const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k; };
const getValidEnumValues: (obj: any) => {}[];
}

9

lib/src/helpers/util.js

@@ -17,3 +17,12 @@ "use strict";

};
util.getValidEnumValues = function (obj) {
var validKeys = Object.keys(obj).filter(function (k) { return typeof obj[obj[k]] !== 'number'; });
var filtered = {};
for (var _i = 0, validKeys_1 = validKeys; _i < validKeys_1.length; _i++) {
var k = validKeys_1[_i];
filtered[k] = obj[k];
}
return Object.values(filtered);
};
})(util = exports.util || (exports.util = {}));
//# sourceMappingURL=util.js.map

41

lib/src/index.d.ts

@@ -21,6 +21,5 @@ import { ZodString, ZodStringDef } from './types/string';

import { ZodEnum, ZodEnumDef } from './types/enum';
import { ZodNativeEnum, ZodNativeEnumDef } from './types/nativeEnum';
import { ZodPromise, ZodPromiseDef } from './types/promise';
import { ZodTransformer, ZodTransformerDef } from './types/transformer';
import { TypeOf, input, output, ZodType, ZodTypeAny, ZodTypeDef, ZodTypes } from './types/base';
import { ZodError, ZodErrorCode } from './ZodError';
import { TypeOf, ZodType, ZodTypeAny, ZodTypeDef, ZodTypes } from './types/base';
import { ZodParsedType } from './parser';

@@ -30,3 +29,3 @@ import { ZodErrorMap } from './defaultErrorMap';

export { ZodTypeDef, ZodTypes };
declare type ZodDef = ZodStringDef | ZodNumberDef | ZodBigIntDef | ZodBooleanDef | ZodDateDef | ZodUndefinedDef | ZodNullDef | ZodAnyDef | ZodUnknownDef | ZodVoidDef | ZodArrayDef | ZodObjectDef | ZodUnionDef | ZodIntersectionDef | ZodTupleDef | ZodRecordDef | ZodFunctionDef | ZodLazyDef | ZodLiteralDef | ZodEnumDef | ZodPromiseDef | ZodTransformerDef;
declare type ZodDef = ZodStringDef | ZodNumberDef | ZodBigIntDef | ZodBooleanDef | ZodDateDef | ZodUndefinedDef | ZodNullDef | ZodAnyDef | ZodUnknownDef | ZodVoidDef | ZodArrayDef | ZodObjectDef | ZodUnionDef | ZodIntersectionDef | ZodTupleDef | ZodRecordDef | ZodFunctionDef | ZodLazyDef | ZodLiteralDef | ZodEnumDef | ZodNativeEnumDef | ZodPromiseDef;
declare const stringType: () => ZodString;

@@ -45,13 +44,16 @@ declare const numberType: () => ZodNumber;

strict: true;
}, { [k in keyof ({ [k in { [k in keyof { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }]: undefined extends { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }[k] ? k : never; }[{ [k in keyof T]: T[k] extends never ? never : k; }[keyof T]]]?: { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }[k] | undefined; } & { [k in Exclude<{ [k in keyof T]: T[k] extends never ? never : k; }[keyof T], { [k in keyof { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }]: undefined extends { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }[k] ? k : never; }[{ [k in keyof T]: T[k] extends never ? never : k; }[keyof T]]>]: { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }[k]; })]: ({ [k in { [k in keyof { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }]: undefined extends { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }[k] ? k : never; }[{ [k in keyof T]: T[k] extends never ? never : k; }[keyof T]]]?: { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }[k] | undefined; } & { [k in Exclude<{ [k in keyof T]: T[k] extends never ? never : k; }[keyof T], { [k in keyof { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }]: undefined extends { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }[k] ? k : never; }[{ [k in keyof T]: T[k] extends never ? never : k; }[keyof T]]>]: { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }[k]; })[k]; }>;
declare const unionType: <T extends [ZodType<any, any>, ...ZodType<any, any>[]]>(types: T) => ZodUnion<T>;
}, { [k in keyof ({ [k in { [k in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k] ? k : never; }[keyof T]]?: { [k in keyof T]: T[k]["_type"]; }[k] | undefined; } & { [k in Exclude<keyof T, { [k in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k] ? k : never; }[keyof T]>]: { [k in keyof T]: T[k]["_type"]; }[k]; })]: ({ [k in { [k in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k] ? k : never; }[keyof T]]?: { [k in keyof T]: T[k]["_type"]; }[k] | undefined; } & { [k in Exclude<keyof T, { [k in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k] ? k : never; }[keyof T]>]: { [k in keyof T]: T[k]["_type"]; }[k]; })[k]; }>;
declare const unionType: <T extends [ZodType<any, any>, ZodType<any, any>, ...ZodType<any, any>[]]>(types: T) => ZodUnion<T>;
declare const intersectionType: <T extends ZodType<any, any>, U extends ZodType<any, any>>(left: T, right: U) => ZodIntersection<T, U>;
declare const tupleType: <T extends [ZodType<any, any>, ...ZodType<any, any>[]] | []>(schemas: T) => ZodTuple<T>;
declare const recordType: <Value extends ZodType<any, any> = ZodType<any, any>>(valueType: Value) => ZodRecord<Value>;
declare const functionType: <T extends ZodTuple<any> = ZodTuple<[]>, U extends ZodType<any, any> = ZodVoid>(args?: T | undefined, returns?: U | undefined) => ZodFunction<T, U>;
declare const functionType: <T extends ZodTuple<any> = ZodTuple<[]>, U extends ZodType<any, any> = ZodUnknown>(args?: T | undefined, returns?: U | undefined) => ZodFunction<T, U>;
declare const lazyType: <T extends ZodType<any, any>>(getter: () => T) => ZodLazy<T>;
declare const literalType: <T extends import("./helpers/primitive").Primitive>(value: T) => ZodLiteral<T>;
declare const enumType: <U extends string, T extends [U, ...U[]]>(values: T) => ZodEnum<T>;
declare const nativeEnumType: <T extends {
[k: string]: string | number;
[nu: number]: string;
}>(values: T) => ZodNativeEnum<T>;
declare const promiseType: <T extends ZodType<any, any>>(schema: T) => ZodPromise<T>;
declare const transformerType: <I extends ZodType<any, any>, O extends ZodType<any, any>>(input: I, output: O, transformer: (arg: I["_type"]) => O["_type"]) => ZodTransformer<I, O>;
declare const ostring: () => ZodUnion<[ZodString, ZodUndefined]>;

@@ -61,13 +63,26 @@ declare const onumber: () => ZodUnion<[ZodNumber, ZodUndefined]>;

declare const codegen: () => ZodCodeGenerator;
export declare const custom: <T>(check: (data: unknown) => any, params?: string | Pick<{
check: (arg: any) => any;
path?: (string | number)[] | undefined;
message?: string | undefined;
params?: {
[k: string]: any;
} | undefined;
}, "path" | "message" | "params"> | undefined) => ZodType<T, ZodTypeDef>;
declare const instanceOfType: <T extends new (...args: any[]) => any>(cls: T, params?: string | Pick<{
check: (arg: any) => any;
path?: (string | number)[] | undefined;
} & Pick<import("./ZodError").CustomError, "message" | "params">, "message" | "path" | "params"> | undefined) => ZodType<InstanceType<T>, ZodTypeDef>;
export { stringType as string, numberType as number, bigIntType as bigint, booleanType as boolean, dateType as date, undefinedType as undefined, nullType as null, anyType as any, unknownType as unknown, voidType as void, arrayType as array, objectType as object, unionType as union, intersectionType as intersection, tupleType as tuple, recordType as record, functionType as function, lazyType as lazy, literalType as literal, enumType as enum, promiseType as promise, transformerType as transformer, instanceOfType as instanceof, ostring, onumber, oboolean, codegen, };
message?: string | undefined;
params?: {
[k: string]: any;
} | undefined;
}, "path" | "message" | "params"> | undefined) => ZodType<InstanceType<T>, ZodTypeDef>;
export { stringType as string, numberType as number, bigIntType as bigint, booleanType as boolean, dateType as date, undefinedType as undefined, nullType as null, anyType as any, unknownType as unknown, voidType as void, arrayType as array, objectType as object, unionType as union, intersectionType as intersection, tupleType as tuple, recordType as record, functionType as function, lazyType as lazy, literalType as literal, enumType as enum, nativeEnumType as nativeEnum, promiseType as promise, instanceOfType as instanceof, ostring, onumber, oboolean, codegen, };
export declare const late: {
object: <T extends import("./types/base").ZodRawShape>(shape: () => T) => ZodObject<T, {
strict: true;
}, { [k in keyof ({ [k in { [k in keyof { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }]: undefined extends { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }[k] ? k : never; }[{ [k in keyof T]: T[k] extends never ? never : k; }[keyof T]]]?: { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }[k] | undefined; } & { [k in Exclude<{ [k in keyof T]: T[k] extends never ? never : k; }[keyof T], { [k in keyof { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }]: undefined extends { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }[k] ? k : never; }[{ [k in keyof T]: T[k] extends never ? never : k; }[keyof T]]>]: { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }[k]; })]: ({ [k in { [k in keyof { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }]: undefined extends { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }[k] ? k : never; }[{ [k in keyof T]: T[k] extends never ? never : k; }[keyof T]]]?: { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }[k] | undefined; } & { [k in Exclude<{ [k in keyof T]: T[k] extends never ? never : k; }[keyof T], { [k in keyof { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }]: undefined extends { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }[k] ? k : never; }[{ [k in keyof T]: T[k] extends never ? never : k; }[keyof T]]>]: { [k in keyof import("./helpers/objectUtil").objectUtil.NoNever<T>]: import("./helpers/objectUtil").objectUtil.NoNever<T>[k]["_type"]; }[k]; })[k]; }>;
}, { [k in keyof ({ [k in { [k in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k] ? k : never; }[keyof T]]?: { [k in keyof T]: T[k]["_type"]; }[k] | undefined; } & { [k in Exclude<keyof T, { [k in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k] ? k : never; }[keyof T]>]: { [k in keyof T]: T[k]["_type"]; }[k]; })]: ({ [k in { [k in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k] ? k : never; }[keyof T]]?: { [k in keyof T]: T[k]["_type"]; }[k] | undefined; } & { [k in Exclude<keyof T, { [k in keyof { [k in keyof T]: T[k]["_type"]; }]: undefined extends { [k in keyof T]: T[k]["_type"]; }[k] ? k : never; }[keyof T]>]: { [k in keyof T]: T[k]["_type"]; }[k]; })[k]; }>;
};
export { ZodString, ZodNumber, ZodBigInt, ZodBoolean, ZodDate, ZodUndefined, ZodNull, ZodAny, ZodUnknown, ZodVoid, ZodArray, ZodObject, ZodUnion, ZodIntersection, ZodTuple, ZodRecord, ZodFunction, ZodLazy, ZodLiteral, ZodEnum, ZodPromise, ZodTransformer, ZodType, ZodType as Schema, ZodType as ZodSchema, ZodTypeAny, ZodDef, ZodError, ZodErrorMap, ZodErrorCode, ZodParsedType, ZodCodeGenerator, };
export { TypeOf, TypeOf as infer, input, output };
export { ZodString, ZodNumber, ZodBigInt, ZodBoolean, ZodDate, ZodUndefined, ZodNull, ZodAny, ZodUnknown, ZodVoid, ZodArray, ZodObject, ZodUnion, ZodIntersection, ZodTuple, ZodRecord, ZodFunction, ZodLazy, ZodLiteral, ZodEnum, ZodNativeEnum, ZodPromise, ZodType, ZodType as Schema, ZodType as ZodSchema, ZodTypeAny, ZodDef, ZodErrorMap, ZodParsedType, ZodCodeGenerator, };
export * from './ZodError';
export { TypeOf, TypeOf as infer };

32

lib/src/index.js
"use strict";
/* ZOD */
function __export(m) {
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
Object.defineProperty(exports, "__esModule", { value: true });

@@ -44,6 +47,6 @@ var string_1 = require("./types/string");

exports.ZodEnum = enum_1.ZodEnum;
var nativeEnum_1 = require("./types/nativeEnum");
exports.ZodNativeEnum = nativeEnum_1.ZodNativeEnum;
var promise_1 = require("./types/promise");
exports.ZodPromise = promise_1.ZodPromise;
var transformer_1 = require("./types/transformer");
exports.ZodTransformer = transformer_1.ZodTransformer;
var base_1 = require("./types/base");

@@ -54,5 +57,15 @@ exports.ZodType = base_1.ZodType;

exports.ZodTypes = base_1.ZodTypes;
var ZodError_1 = require("./ZodError");
exports.ZodError = ZodError_1.ZodError;
exports.ZodErrorCode = ZodError_1.ZodErrorCode;
// import { ZodError, ZodErrorCode, ZodInvalidTypeError,
// ZodNonEmptyArrayIsEmptyError,
// ZodUnrecognizedKeysError,
// ZodInvalidUnionError,
// ZodInvalidLiteralValueError,
// ZodInvalidEnumValueError,
// ZodInvalidArgumentsError,
// ZodInvalidReturnTypeError,
// ZodInvalidDateError,
// ZodInvalidStringError,
// ZodTooSmallError,
// ZodTooBigError,
// ZodCustomError } from './ZodError';
var parser_1 = require("./parser");

@@ -102,6 +115,6 @@ exports.ZodParsedType = parser_1.ZodParsedType;

exports.enum = enumType;
var nativeEnumType = nativeEnum_1.ZodNativeEnum.create;
exports.nativeEnum = nativeEnumType;
var promiseType = promise_1.ZodPromise.create;
exports.promise = promiseType;
var transformerType = transformer_1.ZodTransformer.create;
exports.transformer = transformerType;
var ostring = function () { return stringType().optional(); };

@@ -115,3 +128,3 @@ exports.ostring = ostring;

exports.codegen = codegen;
var custom = function (check, params) {
exports.custom = function (check, params) {
return anyType().refine(check, params);

@@ -121,3 +134,3 @@ };

if (params === void 0) { params = { message: "Input not instance of " + cls.name }; }
return custom(function (data) { return data instanceof cls; }, params);
return exports.custom(function (data) { return data instanceof cls; }, params);
};

@@ -128,2 +141,3 @@ exports.instanceof = instanceOfType;

};
__export(require("./ZodError"));
//# sourceMappingURL=index.js.map

20

lib/src/parser.d.ts

@@ -8,3 +8,7 @@ import * as z from './types/base';

schema: any;
objects: any[];
objects: {
data: any;
error?: any;
times: number;
}[];
}[];

@@ -14,14 +18,12 @@ path?: (string | number)[];

};
export declare const getParsedType: (data: any) => "object" | "symbol" | "unknown" | "string" | "number" | "integer" | "nan" | "boolean" | "date" | "bigint" | "function" | "undefined" | "null" | "array" | "promise" | "void";
export declare const getParsedType: (data: any) => "number" | "string" | "nan" | "integer" | "boolean" | "date" | "bigint" | "symbol" | "function" | "undefined" | "null" | "array" | "object" | "unknown" | "promise" | "void";
export declare const ZodParsedType: {
object: "object";
symbol: "symbol";
unknown: "unknown";
number: "number";
string: "string";
number: "number";
nan: "nan";
integer: "integer";
nan: "nan";
boolean: "boolean";
date: "date";
bigint: "bigint";
symbol: "symbol";
function: "function";

@@ -31,2 +33,4 @@ undefined: "undefined";

array: "array";
object: "object";
unknown: "unknown";
promise: "promise";

@@ -40,3 +44,3 @@ void: "void";

};
export declare const ZodParser: (schemaDef: z.ZodTypeDef) => (data: any, baseParams?: ParseParams) => any;
export declare const ZodParser: (schemaDef: z.ZodTypeDef) => (obj: any, baseParams?: ParseParams) => any;
export {};

186

lib/src/parser.js

@@ -90,4 +90,2 @@ "use strict";

return 'undefined';
if (data === null)
return 'null';
if (typeof data === 'undefined')

@@ -98,2 +96,4 @@ return 'undefined';

return 'array';
if (!data)
return 'null';
if (data.then && typeof data.then === 'function' && data.catch && typeof data.catch === 'function') {

@@ -124,3 +124,3 @@ return 'promise';

]);
exports.ZodParser = function (schemaDef) { return function (data, baseParams) {
exports.ZodParser = function (schemaDef) { return function (obj, baseParams) {
if (baseParams === void 0) { baseParams = { seen: [], errorMap: defaultErrorMap_1.defaultErrorMap, path: [] }; }

@@ -134,3 +134,3 @@ var params = {

var errorArg = __assign({}, errorData, { path: params.path });
var ctxArg = { data: data };
var ctxArg = { data: obj };
var defaultError = defaultErrorMap_1.defaultErrorMap === params.errorMap

@@ -142,18 +142,38 @@ ? { message: "Invalid value." }

var def = schemaDef;
var parsedType = exports.getParsedType(obj);
var schemaSeen = params.seen.find(function (x) { return x.schema === schemaDef; });
var isPrimitive = typeof obj !== 'object' || obj === null;
if (schemaSeen) {
if (schemaSeen.objects.indexOf(data) !== -1) {
return data;
var found = schemaSeen.objects.find(function (x) { return x.data === obj; });
if (found) {
if (found.error) {
throw found.error;
}
found.times = found.times + 1;
if (found.times > 2 && !isPrimitive) {
return Symbol('recursion depth exceeded.');
}
else if (found.times > 2) {
}
}
else {
schemaSeen.objects.push(data);
//
schemaSeen.objects.push(obj);
}
}
else {
params.seen.push({ schema: schemaDef, objects: [data] });
params.seen.push({ schema: schemaDef, objects: [{ data: obj, error: undefined, times: 1 }] });
}
// }
// const setError = (error: Error) => {
// const schemaSeen = params.seen.find(x => x.schema === schemaDef);
// if (schemaSeen) {
// const found = schemaSeen.objects.find(x => x.data === obj);
// if (found) {
// //
// found.error = error;
// }
// }
// };
var error = new ZodError_1.ZodError([]);
var returnValue = data;
var parsedType = exports.getParsedType(data);
var returnValue = obj;
switch (def.t) {

@@ -163,2 +183,3 @@ case z.ZodTypes.string:

error.addError(makeError({ code: ZodError_1.ZodErrorCode.invalid_type, expected: exports.ZodParsedType.string, received: parsedType }));
// setError(error);
throw error;

@@ -170,6 +191,8 @@ }

error.addError(makeError({ code: ZodError_1.ZodErrorCode.invalid_type, expected: exports.ZodParsedType.number, received: parsedType }));
// setError(error);
throw error;
}
if (Number.isNaN(data)) {
if (Number.isNaN(obj)) {
error.addError(makeError({ code: ZodError_1.ZodErrorCode.invalid_type, expected: exports.ZodParsedType.number, received: exports.ZodParsedType.nan }));
// setError(error);
throw error;

@@ -181,2 +204,3 @@ }

error.addError(makeError({ code: ZodError_1.ZodErrorCode.invalid_type, expected: exports.ZodParsedType.number, received: parsedType }));
// setError(error);
throw error;

@@ -188,2 +212,3 @@ }

error.addError(makeError({ code: ZodError_1.ZodErrorCode.invalid_type, expected: exports.ZodParsedType.boolean, received: parsedType }));
// setError(error);
throw error;

@@ -195,2 +220,3 @@ }

error.addError(makeError({ code: ZodError_1.ZodErrorCode.invalid_type, expected: exports.ZodParsedType.undefined, received: parsedType }));
// setError(error);
throw error;

@@ -202,2 +228,3 @@ }

error.addError(makeError({ code: ZodError_1.ZodErrorCode.invalid_type, expected: exports.ZodParsedType.null, received: parsedType }));
// setError(error);
throw error;

@@ -213,2 +240,3 @@ }

error.addError(makeError({ code: ZodError_1.ZodErrorCode.invalid_type, expected: exports.ZodParsedType.void, received: parsedType }));
// setError(error);
throw error;

@@ -220,12 +248,15 @@ }

error.addError(makeError({ code: ZodError_1.ZodErrorCode.invalid_type, expected: exports.ZodParsedType.array, received: parsedType }));
// setError(error);
throw error;
}
// const data: any[] = data;
if (def.nonempty === true && data.length === 0) {
var data = obj;
if (def.nonempty === true && obj.length === 0) {
error.addError(makeError({ code: ZodError_1.ZodErrorCode.nonempty_array_is_empty }));
// setError(error);
throw error;
}
returnValue = data.map(function (item, i) {
data.map(function (item, i) {
try {
return def.type.parse(item, __assign({}, params, { path: params.path.concat([i]) }));
var parsedItem = def.type.parse(item, __assign({}, params, { path: params.path.concat([i]) }));
return parsedItem;
}

@@ -238,2 +269,3 @@ catch (err) {

if (!error.isEmpty) {
// setError(error);
throw error;

@@ -245,23 +277,17 @@ }

error.addError(makeError({ code: ZodError_1.ZodErrorCode.invalid_type, expected: exports.ZodParsedType.object, received: parsedType }));
// setError(error);
throw error;
}
var parsedobject = {};
var shape = def.shape();
var shapeKeys_1 = Object.keys(shape);
var dataKeys = Object.keys(data);
var extraKeys = dataKeys.filter(function (k) { return shapeKeys_1.indexOf(k) === -1; });
if (extraKeys.length) {
if (def.params.strict) {
if (def.params.strict) {
var shapeKeys_1 = Object.keys(shape);
var objKeys = Object.keys(obj);
var extraKeys = objKeys.filter(function (k) { return shapeKeys_1.indexOf(k) === -1; });
if (extraKeys.length) {
error.addError(makeError({ code: ZodError_1.ZodErrorCode.unrecognized_keys, keys: extraKeys }));
}
else {
for (var _i = 0, extraKeys_1 = extraKeys; _i < extraKeys_1.length; _i++) {
var key = extraKeys_1[_i];
parsedobject[key] = data[key];
}
}
}
for (var key in shape) {
try {
parsedobject[key] = def.shape()[key].parse(data[key], __assign({}, params, { path: params.path.concat([key]) }));
def.shape()[key].parse(obj[key], __assign({}, params, { path: params.path.concat([key]) }));
}

@@ -273,14 +299,11 @@ catch (err) {

}
returnValue = parsedobject;
break;
case z.ZodTypes.union:
var parsedUnion = void 0;
var isValid = false;
var unionErrors = [];
for (var _a = 0, _b = def.options; _a < _b.length; _a++) {
var option = _b[_a];
for (var _i = 0, _a = def.options; _i < _a.length; _i++) {
var option = _a[_i];
try {
parsedUnion = option.parse(data, params);
option.parse(obj, params);
isValid = true;
break;
}

@@ -305,10 +328,6 @@ catch (err) {

}
returnValue = parsedUnion;
break;
case z.ZodTypes.intersection:
// let parsedIntersection:any;
var parsedLeft = void 0;
var parsedRight = void 0;
try {
parsedLeft = def.left.parse(data, params);
def.left.parse(obj, params);
}

@@ -319,3 +338,3 @@ catch (err) {

try {
parsedRight = def.right.parse(data, params);
def.right.parse(obj, params);
}

@@ -325,15 +344,2 @@ catch (err) {

}
var parsedLeftType = exports.getParsedType(parsedLeft);
var parsedRightType = exports.getParsedType(parsedRight);
if (parsedLeft === parsedRight) {
returnValue = parsedLeft;
}
else if (parsedLeftType === exports.ZodParsedType.object && parsedRightType === exports.ZodParsedType.object) {
returnValue = __assign({}, parsedLeft, parsedRight);
}
else {
error.addError(makeError({
code: ZodError_1.ZodErrorCode.invalid_intersection_types,
}));
}
break;

@@ -343,13 +349,13 @@ case z.ZodTypes.tuple:

error.addError(makeError({ code: ZodError_1.ZodErrorCode.invalid_type, expected: exports.ZodParsedType.array, received: parsedType }));
// setError(error);
throw error;
}
if (data.length > def.items.length) {
if (obj.length > def.items.length) {
error.addError(makeError({ code: ZodError_1.ZodErrorCode.too_big, maximum: def.items.length, inclusive: true, type: 'array' }));
}
else if (data.length < def.items.length) {
else if (obj.length < def.items.length) {
error.addError(makeError({ code: ZodError_1.ZodErrorCode.too_small, minimum: def.items.length, inclusive: true, type: 'array' }));
}
// const parsedTuple: any[] = [];
var tupleData = data;
var parsedTuple = [];
var tupleData = obj;
for (var index in tupleData) {

@@ -365,16 +371,14 @@ var item = tupleData[index];

}
returnValue = parsedTuple;
break;
case z.ZodTypes.lazy:
var lazySchema = def.getter();
returnValue = lazySchema.parse(data, params);
lazySchema.parse(obj, params);
break;
case z.ZodTypes.literal:
if (data !== def.value) {
if (obj !== def.value) {
error.addError(makeError({ code: ZodError_1.ZodErrorCode.invalid_literal_value, expected: def.value }));
}
returnValue = data;
break;
case z.ZodTypes.enum:
if (def.values.indexOf(data) === -1) {
if (def.values.indexOf(obj) === -1) {
error.addError(makeError({

@@ -385,4 +389,11 @@ code: ZodError_1.ZodErrorCode.invalid_enum_value,

}
returnValue = data;
break;
case z.ZodTypes.nativeEnum:
if (util_1.util.getValidEnumValues(def.values).indexOf(obj) === -1) {
error.addError(makeError({
code: ZodError_1.ZodErrorCode.invalid_enum_value,
options: Object.values(def.values),
}));
}
break;
case z.ZodTypes.function:

@@ -395,2 +406,3 @@ if (parsedType !== exports.ZodParsedType.function) {

}));
// setError(error);
throw error;

@@ -417,3 +429,3 @@ }

}
var result = data.apply(void 0, args);
var result = obj.apply(void 0, args);
try {

@@ -434,5 +446,3 @@ return def.returns.parse(result);

};
returnValue = validatedFunc;
// return validatedFunc;
break;
return validatedFunc;
case z.ZodTypes.record:

@@ -445,8 +455,8 @@ if (parsedType !== exports.ZodParsedType.object) {

}));
// setError(error);
throw error;
}
var parsedRecord = {};
for (var key in data) {
for (var key in obj) {
try {
parsedRecord[key] = def.valueType.parse(data[key], __assign({}, params, { path: params.path.concat([key]) }));
def.valueType.parse(obj[key], __assign({}, params, { path: params.path.concat([key]) }));
}

@@ -457,6 +467,5 @@ catch (err) {

}
returnValue = parsedRecord;
break;
case z.ZodTypes.date:
if (!(data instanceof Date)) {
if (!(obj instanceof Date)) {
error.addError(makeError({

@@ -467,12 +476,12 @@ code: ZodError_1.ZodErrorCode.invalid_type,

}));
// setError(error);
throw error;
}
if (isNaN(data.getTime())) {
console.log('NAN');
if (isNaN(obj.getTime())) {
error.addError(makeError({
code: ZodError_1.ZodErrorCode.invalid_date,
}));
// setError(error);
throw error;
}
returnValue = data;
break;

@@ -486,13 +495,14 @@ case z.ZodTypes.promise:

}));
// setError(error);
throw error;
}
returnValue = new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
var dataValue, parsed;
return new Promise(function (res, rej) { return __awaiter(_this, void 0, void 0, function () {
var objValue, parsed;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, data];
case 0: return [4 /*yield*/, obj];
case 1:
dataValue = _a.sent();
objValue = _a.sent();
try {
parsed = def.type.parse(dataValue, params);
parsed = def.type.parse(objValue, params);
res(parsed);

@@ -507,11 +517,2 @@ }

}); });
break;
case z.ZodTypes.transformer:
// console.log(`input: "${data}"`);
var inputParseResult = def.input.parse(data);
// console.log(`inputParseResult: "${inputParseResult}"`);
var transformedResult = def.transformer(inputParseResult);
// console.log(`transformedResult: "${transformedResult}"`);
returnValue = def.output.parse(transformedResult);
break;
default:

@@ -521,4 +522,4 @@ util_1.util.assertNever(def);

var customChecks = def.checks || [];
for (var _c = 0, customChecks_1 = customChecks; _c < customChecks_1.length; _c++) {
var check = customChecks_1[_c];
for (var _b = 0, customChecks_1 = customChecks; _b < customChecks_1.length; _b++) {
var check = customChecks_1[_b];
if (!check.check(returnValue)) {

@@ -530,2 +531,3 @@ var checkMethod = check.check, noMethodCheck = __rest(check, ["check"]);

if (!error.isEmpty) {
// setError(error);
throw error;

@@ -532,0 +534,0 @@ }

10

lib/src/types/array.js

@@ -38,3 +38,3 @@ "use strict";

// import { ZodUnion } from './union';
var __1 = require("..");
var ZodError_1 = require("../ZodError");
var ZodArray = /** @class */ (function (_super) {

@@ -54,6 +54,6 @@ __extends(ZodArray, _super);

_this.min = function (minLength, message) {
return _this._refinement(__assign({ check: function (data) { return data.length >= minLength; }, code: __1.ZodErrorCode.too_small, type: 'array', inclusive: true, minimum: minLength }, (typeof message === 'string' ? { message: message } : message)));
return _this._refinement(__assign({ check: function (data) { return data.length >= minLength; }, code: ZodError_1.ZodErrorCode.too_small, type: 'array', inclusive: true, minimum: minLength }, (typeof message === 'string' ? { message: message } : message)));
};
_this.max = function (maxLength, message) {
return _this._refinement(__assign({ check: function (data) { return data.length <= maxLength; }, code: __1.ZodErrorCode.too_big, type: 'array', inclusive: true, maximum: maxLength }, (typeof message === 'string' ? { message: message } : message)));
return _this._refinement(__assign({ check: function (data) { return data.length <= maxLength; }, code: ZodError_1.ZodErrorCode.too_big, type: 'array', inclusive: true, maximum: maxLength }, (typeof message === 'string' ? { message: message } : message)));
};

@@ -96,6 +96,6 @@ _this.length = function (len, message) { return _this.min(len, { message: message }).max(len, { message: message }); };

_this.min = function (minLength, message) {
return _this._refinement(__assign({ check: function (data) { return data.length >= minLength; }, code: __1.ZodErrorCode.too_small, minimum: minLength, type: 'array', inclusive: true }, (typeof message === 'string' ? { message: message } : message)));
return _this._refinement(__assign({ check: function (data) { return data.length >= minLength; }, code: ZodError_1.ZodErrorCode.too_small, minimum: minLength, type: 'array', inclusive: true }, (typeof message === 'string' ? { message: message } : message)));
};
_this.max = function (maxLength, message) {
return _this._refinement(__assign({ check: function (data) { return data.length >= maxLength; }, code: __1.ZodErrorCode.too_big, maximum: maxLength, type: 'array', inclusive: true }, (typeof message === 'string' ? { message: message } : message)));
return _this._refinement(__assign({ check: function (data) { return data.length >= maxLength; }, code: ZodError_1.ZodErrorCode.too_big, maximum: maxLength, type: 'array', inclusive: true }, (typeof message === 'string' ? { message: message } : message)));
};

@@ -102,0 +102,0 @@ _this.length = function (len, message) { return _this.min(len, { message: message }).max(len, { message: message }); };

35

lib/src/types/base.d.ts
import { ParseParams, MakeErrorData } from '../parser';
import { util } from '../helpers/util';
import { ZodArray, ZodUnion, ZodNull, ZodUndefined, ZodTransformer } from '..';
import { CustomError } from '../ZodError';
import { ZodArray, ZodUnion, ZodNull, ZodUndefined, ZodError } from '../index';
export declare enum ZodTypes {

@@ -23,7 +21,7 @@ string = "string",

enum = "enum",
nativeEnum = "nativeEnum",
promise = "promise",
any = "any",
unknown = "unknown",
void = "void",
transformer = "transformer"
void = "void"
}

@@ -40,3 +38,7 @@ export declare type ZodTypeAny = ZodType<any, any>;

path?: (string | number)[];
} & util.Omit<CustomError, 'code' | 'path'>;
message?: string;
params?: {
[k: string]: any;
};
};
export interface ZodTypeDef {

@@ -50,21 +52,20 @@ t: ZodTypes;

}> = T['_type'];
export declare type input<T extends {
_input: any;
}> = T['_input'];
export declare type output<T extends {
_output: any;
}> = T['_output'];
export declare type infer<T extends {
export declare type Infer<T extends {
_type: any;
}> = T['_type'];
export declare abstract class ZodType<Type, Def extends ZodTypeDef = ZodTypeDef> {
readonly _input: Type;
readonly _output: Type;
readonly _type: Type;
readonly _def: Def;
parse: (x: Type | unknown, params?: ParseParams) => Type;
safeParse: (x: Type | unknown, params?: ParseParams) => {
success: true;
data: Type;
} | {
success: false;
error: ZodError;
};
parseAsync: (x: Type | unknown, params?: ParseParams) => Promise<Type>;
is(u: Type): u is Type;
check(u: Type | unknown): u is Type;
refine: <Val extends (arg: Type) => any>(check: Val, message?: string | Pick<Check<Type>, "message" | "path" | "params">) => this;
refine: <Func extends (arg: Type) => any>(check: Func, message?: string | Pick<Check<Type>, "path" | "message" | "params">) => this;
refinement: (refinement: Check<Type>) => this;

@@ -77,6 +78,4 @@ protected _refinement: (refinement: InternalCheck<Type>) => this;

array: () => ZodArray<this>;
transform: <This extends this, U extends ZodType<any>, Tx extends (arg: This['_type']) => U['_type']>(x: U, transformer: Tx) => ZodTransformer<This, U>;
default: <T extends Type = Type, Opt extends ZodUnion<[this, ZodUndefined]> = ZodUnion<[this, ZodUndefined]>>(def: T) => ZodTransformer<Opt, this>;
or: <U extends ZodType<any>>(arg: U) => ZodUnion<[this, U]>;
}
export {};

76

lib/src/types/base.js

@@ -15,3 +15,3 @@ "use strict";

var parser_1 = require("../parser");
var __1 = require("..");
var index_1 = require("../index");
var ZodTypes;

@@ -36,2 +36,3 @@ (function (ZodTypes) {

ZodTypes["enum"] = "enum";
ZodTypes["nativeEnum"] = "nativeEnum";
ZodTypes["promise"] = "promise";

@@ -41,3 +42,2 @@ ZodTypes["any"] = "any";

ZodTypes["void"] = "void";
ZodTypes["transformer"] = "transformer";
})(ZodTypes = exports.ZodTypes || (exports.ZodTypes = {}));

@@ -47,6 +47,24 @@ var ZodType = /** @class */ (function () {

var _this = this;
this.parseAsync = function (value) {
this.safeParse = function (data, params) {
try {
var parsed = _this.parse(data, params);
return {
success: true,
data: parsed,
};
}
catch (err) {
if (err instanceof index_1.ZodError) {
return {
success: false,
error: err,
};
}
throw err;
}
};
this.parseAsync = function (value, params) {
return new Promise(function (res, rej) {
try {
var parsed = _this.parse(value);
var parsed = _this.parse(value, params);
return res(parsed);

@@ -67,3 +85,3 @@ }

this.refinement = function (refinement) {
return _this._refinement(__assign({ code: __1.ZodErrorCode.custom_error }, refinement));
return _this._refinement(__assign({ code: index_1.ZodErrorCode.custom_error }, refinement));
};

@@ -74,48 +92,10 @@ this._refinement = function (refinement) {

// abstract // opt optional: () => any;
this.optional = function () { return __1.ZodUnion.create([_this, __1.ZodUndefined.create()]); };
this.nullable = function () { return __1.ZodUnion.create([_this, __1.ZodNull.create()]); };
this.array = function () { return __1.ZodArray.create(_this); };
// pre: <T extends string>(
// input: T,
// transformer: (arg: T) => Type,
// ) => any = (input, transformer) => 'adsf';
// transformFrom: <U extends ZodType<any>, Tx extends (arg: U['_type']) => this['_type']>(
// x: U,
// transformer: Tx,
// ) => ZodTransformer<U, this> = (input, transformer) => {
// return ZodTransformer.create(input, this, transformer);
// };
// transformFrom: <This extends this, U extends ZodType<any>, Tx extends (arg: U['_type']) => this['_type']>(
// x: U,
// transformer: Tx,
// ) => ZodTransformer<This, U> = (input, transformer) => {
// return ZodTransformer.create(this as any, input, transformer) as any;
// };
this.transform = function (input, transformer) {
return __1.ZodTransformer.create(_this, input, transformer);
};
this.default = function (def) {
return __1.ZodTransformer.create(_this.optional(), _this, function (x) {
return (x || def);
});
};
// default: (val: Type) => ZodTransformer<ZodType<Type | undefined>, this> = val => {
// return ZodTransformer.create(this.optional(), this, x => {
// return (x || val) as any;
// }) as any;
// };
// codec = (): ZodCodec<this, this> => {
// return ZodCodec.create(this, this, x => x);
// };
// transform: <U extends ZodType<any>, Tx extends (arg: Type) => U['_type']>(
// x: U,s
// transformer: Tx,
// ) => ZodCodec<this, U> = (input, transformer) => {
// return ZodCodec.create(input, this, transformer);
// };
this.optional = function () { return index_1.ZodUnion.create([_this, index_1.ZodUndefined.create()]); };
this.nullable = function () { return index_1.ZodUnion.create([_this, index_1.ZodNull.create()]); };
this.array = function () { return index_1.ZodArray.create(_this); };
this.or = function (arg) {
return __1.ZodUnion.create([_this, arg]);
return index_1.ZodUnion.create([_this, arg]);
};
this._def = def;
this.parse = parser_1.ZodParser(def);
this._def = def;
}

@@ -122,0 +102,0 @@ ZodType.prototype.is = function (u) {

8

lib/src/types/function.d.ts
import * as z from './base';
import { ZodTuple } from './tuple';
import { ZodVoid } from './void';
import { ZodUnknown } from './unknown';
export interface ZodFunctionDef<Args extends ZodTuple<any> = ZodTuple<any>, Returns extends z.ZodTypeAny = z.ZodTypeAny> extends z.ZodTypeDef {

@@ -15,5 +15,5 @@ t: z.ZodTypes.function;

returns: <NewReturnType extends z.ZodType<any, any>>(returnType: NewReturnType) => ZodFunction<Args, NewReturnType>;
implement: (func: TypeOfFunction<Args, Returns>) => TypeOfFunction<Args, Returns>;
validate: (func: TypeOfFunction<Args, Returns>) => TypeOfFunction<Args, Returns>;
static create: <T extends ZodTuple<any> = ZodTuple<[]>, U extends z.ZodType<any, any> = ZodVoid>(args?: T | undefined, returns?: U | undefined) => ZodFunction<T, U>;
implement: <F extends TypeOfFunction<Args, Returns>>(func: F) => F;
validate: <F extends TypeOfFunction<Args, Returns>>(func: F) => F;
static create: <T extends ZodTuple<any> = ZodTuple<[]>, U extends z.ZodType<any, any> = ZodUnknown>(args?: T | undefined, returns?: U | undefined) => ZodFunction<T, U>;
toJSON: () => {

@@ -20,0 +20,0 @@ t: z.ZodTypes.function;

7

lib/src/types/function.js

@@ -36,6 +36,3 @@ "use strict";

var tuple_1 = require("./tuple");
// import { ZodUndefined } from './undefined';
// import { ZodNull } from './null';
// import { ZodUnion } from './union';
var void_1 = require("./void");
var unknown_1 = require("./unknown");
var ZodFunction = /** @class */ (function (_super) {

@@ -75,3 +72,3 @@ __extends(ZodFunction, _super);

args: args || tuple_1.ZodTuple.create([]),
returns: returns || void_1.ZodVoid.create(),
returns: returns || unknown_1.ZodUnknown.create(),
});

@@ -78,0 +75,0 @@ };

16

lib/src/types/number.js

@@ -38,3 +38,3 @@ "use strict";

// import { ZodUnion } from './union';
var __1 = require("..");
var ZodError_1 = require("../ZodError");
var errorUtil_1 = require("../helpers/errorUtil");

@@ -49,21 +49,21 @@ var ZodNumber = /** @class */ (function (_super) {

_this.min = function (minimum, message) {
return _this._refinement(__assign({ check: function (data) { return data >= minimum; }, code: __1.ZodErrorCode.too_small, minimum: minimum, type: 'number', inclusive: true }, errorUtil_1.errorUtil.errToObj(message)));
return _this._refinement(__assign({ check: function (data) { return data >= minimum; }, code: ZodError_1.ZodErrorCode.too_small, minimum: minimum, type: 'number', inclusive: true }, errorUtil_1.errorUtil.errToObj(message)));
};
_this.max = function (maximum, message) {
return _this._refinement(__assign({ check: function (data) { return data <= maximum; }, code: __1.ZodErrorCode.too_big, maximum: maximum, type: 'number', inclusive: true }, errorUtil_1.errorUtil.errToObj(message)));
return _this._refinement(__assign({ check: function (data) { return data <= maximum; }, code: ZodError_1.ZodErrorCode.too_big, maximum: maximum, type: 'number', inclusive: true }, errorUtil_1.errorUtil.errToObj(message)));
};
_this.int = function (message) {
return _this._refinement(__assign({ check: function (data) { return Number.isInteger(data); }, code: __1.ZodErrorCode.invalid_type, expected: 'integer', received: 'number' }, errorUtil_1.errorUtil.errToObj(message)));
return _this._refinement(__assign({ check: function (data) { return Number.isInteger(data); }, code: ZodError_1.ZodErrorCode.invalid_type, expected: 'integer', received: 'number' }, errorUtil_1.errorUtil.errToObj(message)));
};
_this.positive = function (message) {
return _this._refinement(__assign({ check: function (data) { return data > 0; }, code: __1.ZodErrorCode.too_small, minimum: 0, type: 'number', inclusive: false }, errorUtil_1.errorUtil.errToObj(message)));
return _this._refinement(__assign({ check: function (data) { return data > 0; }, code: ZodError_1.ZodErrorCode.too_small, minimum: 0, type: 'number', inclusive: false }, errorUtil_1.errorUtil.errToObj(message)));
};
_this.negative = function (message) {
return _this._refinement(__assign({ check: function (data) { return data < 0; }, code: __1.ZodErrorCode.too_big, maximum: 0, type: 'number', inclusive: false }, errorUtil_1.errorUtil.errToObj(message)));
return _this._refinement(__assign({ check: function (data) { return data < 0; }, code: ZodError_1.ZodErrorCode.too_big, maximum: 0, type: 'number', inclusive: false }, errorUtil_1.errorUtil.errToObj(message)));
};
_this.nonpositive = function (message) {
return _this._refinement(__assign({ check: function (data) { return data <= 0; }, code: __1.ZodErrorCode.too_big, maximum: 0, type: 'number', inclusive: true }, errorUtil_1.errorUtil.errToObj(message)));
return _this._refinement(__assign({ check: function (data) { return data <= 0; }, code: ZodError_1.ZodErrorCode.too_big, maximum: 0, type: 'number', inclusive: true }, errorUtil_1.errorUtil.errToObj(message)));
};
_this.nonnegative = function (message) {
return _this._refinement(__assign({ check: function (data) { return data >= 0; }, code: __1.ZodErrorCode.too_small, minimum: 0, type: 'number', inclusive: true }, errorUtil_1.errorUtil.errToObj(message)));
return _this._refinement(__assign({ check: function (data) { return data >= 0; }, code: ZodError_1.ZodErrorCode.too_small, minimum: 0, type: 'number', inclusive: true }, errorUtil_1.errorUtil.errToObj(message)));
};

@@ -70,0 +70,0 @@ return _this;

17

lib/src/types/object.d.ts

@@ -14,6 +14,3 @@ import * as z from './base';

}
declare type makeKeysRequired<T extends ZodObject<any, any>> = T extends ZodObject<infer U, infer P> ? ZodObject<objectUtil.NoNever<{
[k in keyof U]: makeRequired<U[k]>;
}>, P> : never;
declare type makeRequired<T extends z.ZodType<any>> = T extends ZodUnion<infer U> ? U extends [infer Y, ZodUndefined] ? Y : U extends [ZodUndefined, infer Z] ? Z : T : T;
export declare type Scalars = string | string[] | number | number[] | boolean | boolean[] | bigint | bigint[] | undefined | null;
declare type ZodObjectType<T extends z.ZodRawShape, Params extends ZodObjectParams> = Params['strict'] extends true ? objectUtil.ObjectType<T> : objectUtil.Flatten<objectUtil.ObjectType<T> & {

@@ -29,3 +26,2 @@ [k: string]: any;

readonly params: Params;
readonly t: this;
toJSON: () => {

@@ -50,14 +46,15 @@ t: z.ZodTypes.object;

merge: <MergeShape extends z.ZodRawShape, MergeParams extends ZodObjectParams>(other: ZodObject<MergeShape, MergeParams>) => ZodObject<T & MergeShape, objectUtil.MergeObjectParams<Params, MergeParams>>;
pick: <Mask extends { [k in keyof T]?: true | undefined; }>(mask: Mask) => ZodObject<{ [k in keyof Mask]: k extends keyof T ? T[k] : never; }, Params, ZodObjectType<{ [k in keyof Mask]: k extends keyof T ? T[k] : never; }, Params>>;
omit: <Mask extends { [k in keyof T]?: true | undefined; }>(mask: Mask) => ZodObject<{ [k in keyof T]: k extends keyof Mask ? never : T[k]; }, Params, ZodObjectType<{ [k in keyof T]: k extends keyof Mask ? never : T[k]; }, Params>>;
pick: <Mask extends { [k in keyof T]?: true | undefined; }>(mask: Mask) => ZodObject<{ [k in { [k in keyof { [k in keyof Mask]: k extends keyof T ? T[k] : never; }]: [{ [k in keyof Mask]: k extends keyof T ? T[k] : never; }[k]] extends [never] ? never : k; }[keyof Mask]]: k extends keyof Mask ? { [k in keyof Mask]: k extends keyof T ? T[k] : never; }[k] : never; }, Params, ZodObjectType<{ [k in { [k in keyof { [k in keyof Mask]: k extends keyof T ? T[k] : never; }]: [{ [k in keyof Mask]: k extends keyof T ? T[k] : never; }[k]] extends [never] ? never : k; }[keyof Mask]]: k extends keyof Mask ? { [k in keyof Mask]: k extends keyof T ? T[k] : never; }[k] : never; }, Params>>;
omit: <Mask extends { [k in keyof T]?: true | undefined; }>(mask: Mask) => ZodObject<{ [k in { [k in keyof { [k in keyof T]: k extends keyof Mask ? never : T[k]; }]: [{ [k in keyof T]: k extends keyof Mask ? never : T[k]; }[k]] extends [never] ? never : k; }[keyof T]]: k extends keyof T ? { [k in keyof T]: k extends keyof Mask ? never : T[k]; }[k] : never; }, Params, ZodObjectType<{ [k in { [k in keyof { [k in keyof T]: k extends keyof Mask ? never : T[k]; }]: [{ [k in keyof T]: k extends keyof Mask ? never : T[k]; }[k]] extends [never] ? never : k; }[keyof T]]: k extends keyof T ? { [k in keyof T]: k extends keyof Mask ? never : T[k]; }[k] : never; }, Params>>;
partial: () => ZodObject<{ [k in keyof T]: ZodUnion<[T[k], ZodUndefined]>; }, Params, ZodObjectType<{ [k in keyof T]: ZodUnion<[T[k], ZodUndefined]>; }, Params>>;
require: () => makeKeysRequired<this>;
primitives: () => ZodObject<{ [k in { [k in keyof { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? T[k] : never; }]: [{ [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? T[k] : never; }[k]] extends [never] ? never : k; }[keyof T]]: k extends keyof T ? { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? T[k] : never; }[k] : never; }, Params, ZodObjectType<{ [k in { [k in keyof { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? T[k] : never; }]: [{ [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? T[k] : never; }[k]] extends [never] ? never : k; }[keyof T]]: k extends keyof T ? { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? T[k] : never; }[k] : never; }, Params>>;
nonprimitives: () => ZodObject<{ [k in { [k in keyof { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? never : T[k]; }]: [{ [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? never : T[k]; }[k]] extends [never] ? never : k; }[keyof T]]: k extends keyof T ? { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? never : T[k]; }[k] : never; }, Params, ZodObjectType<{ [k in { [k in keyof { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? never : T[k]; }]: [{ [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? never : T[k]; }[k]] extends [never] ? never : k; }[keyof T]]: k extends keyof T ? { [k in keyof T]: [T[k]["_type"]] extends [Scalars] ? never : T[k]; }[k] : never; }, Params>>;
deepPartial: () => partialUtil.RootDeepPartial<this>;
static create: <T_1 extends z.ZodRawShape>(shape: T_1) => ZodObject<T_1, {
strict: true;
}, { [k in keyof ({ [k in { [k in keyof { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }]: undefined extends { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }[k] ? k : never; }[{ [k in keyof T_1]: T_1[k] extends never ? never : k; }[keyof T_1]]]?: { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }[k] | undefined; } & { [k in Exclude<{ [k in keyof T_1]: T_1[k] extends never ? never : k; }[keyof T_1], { [k in keyof { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }]: undefined extends { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }[k] ? k : never; }[{ [k in keyof T_1]: T_1[k] extends never ? never : k; }[keyof T_1]]>]: { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }[k]; })]: ({ [k in { [k in keyof { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }]: undefined extends { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }[k] ? k : never; }[{ [k in keyof T_1]: T_1[k] extends never ? never : k; }[keyof T_1]]]?: { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }[k] | undefined; } & { [k in Exclude<{ [k in keyof T_1]: T_1[k] extends never ? never : k; }[keyof T_1], { [k in keyof { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }]: undefined extends { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }[k] ? k : never; }[{ [k in keyof T_1]: T_1[k] extends never ? never : k; }[keyof T_1]]>]: { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }[k]; })[k]; }>;
}, { [k in keyof ({ [k in { [k in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k] ? k : never; }[keyof T_1]]?: { [k in keyof T_1]: T_1[k]["_type"]; }[k] | undefined; } & { [k in Exclude<keyof T_1, { [k in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k] ? k : never; }[keyof T_1]>]: { [k in keyof T_1]: T_1[k]["_type"]; }[k]; })]: ({ [k in { [k in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k] ? k : never; }[keyof T_1]]?: { [k in keyof T_1]: T_1[k]["_type"]; }[k] | undefined; } & { [k in Exclude<keyof T_1, { [k in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k] ? k : never; }[keyof T_1]>]: { [k in keyof T_1]: T_1[k]["_type"]; }[k]; })[k]; }>;
static lazycreate: <T_1 extends z.ZodRawShape>(shape: () => T_1) => ZodObject<T_1, {
strict: true;
}, { [k in keyof ({ [k in { [k in keyof { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }]: undefined extends { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }[k] ? k : never; }[{ [k in keyof T_1]: T_1[k] extends never ? never : k; }[keyof T_1]]]?: { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }[k] | undefined; } & { [k in Exclude<{ [k in keyof T_1]: T_1[k] extends never ? never : k; }[keyof T_1], { [k in keyof { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }]: undefined extends { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }[k] ? k : never; }[{ [k in keyof T_1]: T_1[k] extends never ? never : k; }[keyof T_1]]>]: { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }[k]; })]: ({ [k in { [k in keyof { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }]: undefined extends { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }[k] ? k : never; }[{ [k in keyof T_1]: T_1[k] extends never ? never : k; }[keyof T_1]]]?: { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }[k] | undefined; } & { [k in Exclude<{ [k in keyof T_1]: T_1[k] extends never ? never : k; }[keyof T_1], { [k in keyof { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }]: undefined extends { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }[k] ? k : never; }[{ [k in keyof T_1]: T_1[k] extends never ? never : k; }[keyof T_1]]>]: { [k in keyof objectUtil.NoNever<T_1>]: objectUtil.NoNever<T_1>[k]["_type"]; }[k]; })[k]; }>;
}, { [k in keyof ({ [k in { [k in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k] ? k : never; }[keyof T_1]]?: { [k in keyof T_1]: T_1[k]["_type"]; }[k] | undefined; } & { [k in Exclude<keyof T_1, { [k in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k] ? k : never; }[keyof T_1]>]: { [k in keyof T_1]: T_1[k]["_type"]; }[k]; })]: ({ [k in { [k in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k] ? k : never; }[keyof T_1]]?: { [k in keyof T_1]: T_1[k]["_type"]; }[k] | undefined; } & { [k in Exclude<keyof T_1, { [k in keyof { [k in keyof T_1]: T_1[k]["_type"]; }]: undefined extends { [k in keyof T_1]: T_1[k]["_type"]; }[k] ? k : never; }[keyof T_1]>]: { [k in keyof T_1]: T_1[k]["_type"]; }[k]; })[k]; }>;
}
export {};

33

lib/src/types/object.js

@@ -35,6 +35,4 @@ "use strict";

var z = __importStar(require("./base"));
var undefined_1 = require("./undefined");
// import { ZodNull } from './null';
var union_1 = require("./union");
var objectUtil_1 = require("../helpers/objectUtil");
var isScalar_1 = require("../isScalar");
var AugmentFactory = function (def) { return function (augmentation) {

@@ -97,16 +95,16 @@ return new ZodObject(__assign({}, def, { shape: function () { return (__assign({}, def.shape(), augmentation)); } }));

};
_this.require = function () {
_this.primitives = function () {
var newShape = {};
for (var key in _this.shape) {
var val = _this.shape[key];
if (val instanceof union_1.ZodUnion && val.options.length === 2) {
if (val.options[0] instanceof undefined_1.ZodUndefined) {
newShape[key] = val.options[1];
}
else if (val.options[1] instanceof undefined_1.ZodUndefined) {
newShape[key] = val.options[0];
}
if (isScalar_1.isScalar(_this.shape[key])) {
newShape[key] = _this.shape[key];
}
else {
newShape[key] = val;
}
return new ZodObject(__assign({}, _this._def, { shape: function () { return newShape; } }));
};
_this.nonprimitives = function () {
var newShape = {};
for (var key in _this.shape) {
if (!isScalar_1.isScalar(_this.shape[key])) {
newShape[key] = _this.shape[key];
}

@@ -145,9 +143,2 @@ }

});
Object.defineProperty(ZodObject.prototype, "t", {
get: function () {
return this;
},
enumerable: true,
configurable: true
});
ZodObject.create = function (shape) {

@@ -154,0 +145,0 @@ return new ZodObject({

7

lib/src/types/string.d.ts
import * as z from './base';
import { StringValidation } from '../ZodError';
import { errorUtil } from '../helpers/errorUtil';

@@ -19,2 +20,5 @@ export interface ZodStringDef extends z.ZodTypeDef {

length(len: number, message?: errorUtil.ErrMessage): this;
protected _regex: (regex: RegExp, validation: StringValidation, message?: string | {
message?: string | undefined;
} | undefined) => this;
email: (message?: string | {

@@ -29,2 +33,5 @@ message?: string | undefined;

} | undefined) => this;
regex: (regexp: RegExp, message?: string | {
message?: string | undefined;
} | undefined) => this;
nonempty: (message?: string | {

@@ -31,0 +38,0 @@ message?: string | undefined;

28

lib/src/types/string.js

@@ -38,6 +38,5 @@ "use strict";

// import { ZodUnion } from './union';
var __1 = require("..");
var ZodError_1 = require("../ZodError");
var errorUtil_1 = require("../helpers/errorUtil");
var emailRegex = /^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))$/i;
var urlRegex = /^((https?|ftp):)?\/\/(((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:)*@)?(((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]))|((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?)(:\d*)?)(\/((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)+(\/(([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)*)*)?)?(\?((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|[\uE000-\uF8FF]|\/|\?)*)?(\#((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|\/|\?)*)?$/i;
var uuidRegex = /([a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}){1}/i;

@@ -52,16 +51,25 @@ var ZodString = /** @class */ (function (_super) {

_this.min = function (minLength, message) {
return _this._refinement(__assign({ check: function (data) { return data.length >= minLength; }, code: __1.ZodErrorCode.too_small, minimum: minLength, type: 'string', inclusive: true }, errorUtil_1.errorUtil.errToObj(message)));
return _this._refinement(__assign({ check: function (data) { return data.length >= minLength; }, code: ZodError_1.ZodErrorCode.too_small, minimum: minLength, type: 'string', inclusive: true }, errorUtil_1.errorUtil.errToObj(message)));
};
_this.max = function (maxLength, message) {
return _this._refinement(__assign({ check: function (data) { return data.length <= maxLength; }, code: __1.ZodErrorCode.too_big, maximum: maxLength, type: 'string', inclusive: true }, errorUtil_1.errorUtil.errToObj(message)));
return _this._refinement(__assign({ check: function (data) { return data.length <= maxLength; }, code: ZodError_1.ZodErrorCode.too_big, maximum: maxLength, type: 'string', inclusive: true }, errorUtil_1.errorUtil.errToObj(message)));
};
_this.email = function (message) {
return _this._refinement(__assign({ check: function (data) { return emailRegex.test(data); }, code: __1.ZodErrorCode.invalid_string, validation: 'email' }, errorUtil_1.errorUtil.errToObj(message)));
_this._regex = function (regex, validation, message) {
return _this._refinement(__assign({ validation: validation, code: ZodError_1.ZodErrorCode.invalid_string, check: function (data) { return regex.test(data); } }, errorUtil_1.errorUtil.errToObj(message)));
};
_this.email = function (message) { return _this._regex(emailRegex, 'email', message); };
_this.url = function (message) {
return _this._refinement(__assign({ check: function (data) { return urlRegex.test(data); }, code: __1.ZodErrorCode.invalid_string, validation: 'url' }, errorUtil_1.errorUtil.errToObj(message)));
return _this._refinement(__assign({ check: function (data) {
try {
new URL(data);
return true;
}
catch (_a) {
return false;
}
}, code: ZodError_1.ZodErrorCode.invalid_string, validation: 'url' }, errorUtil_1.errorUtil.errToObj(message)));
};
_this.uuid = function (message) {
return _this._refinement(__assign({ check: function (data) { return uuidRegex.test(data); }, code: __1.ZodErrorCode.invalid_string, validation: 'uuid' }, errorUtil_1.errorUtil.errToObj(message)));
};
// url = (message?: errorUtil.ErrMessage) => this._regex(urlRegex, 'url', message);
_this.uuid = function (message) { return _this._regex(uuidRegex, 'uuid', message); };
_this.regex = function (regexp, message) { return _this._regex(regexp, 'regex', message); };
_this.nonempty = function (message) { return _this.min(1, errorUtil_1.errorUtil.errToObj(message)); };

@@ -68,0 +76,0 @@ return _this;

7

lib/src/types/union.d.ts
import * as z from './base';
export interface ZodUnionDef<T extends [z.ZodTypeAny, ...z.ZodTypeAny[]] = [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]> extends z.ZodTypeDef {
export interface ZodUnionDef<T extends [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]] = [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]> extends z.ZodTypeDef {
t: z.ZodTypes.union;
options: T;
}
export declare class ZodUnion<T extends [z.ZodTypeAny, ...z.ZodTypeAny[]]> extends z.ZodType<T[number]['_type'], ZodUnionDef<T>> {
readonly options: T;
export declare class ZodUnion<T extends [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]> extends z.ZodType<T[number]['_type'], ZodUnionDef<T>> {
toJSON: () => {

@@ -12,3 +11,3 @@ t: z.ZodTypes.union;

};
static create: <T_1 extends [z.ZodType<any, any>, ...z.ZodType<any, any>[]]>(types: T_1) => ZodUnion<T_1>;
static create: <T_1 extends [z.ZodType<any, any>, z.ZodType<any, any>, ...z.ZodType<any, any>[]]>(types: T_1) => ZodUnion<T_1>;
}

9

lib/src/types/union.js

@@ -27,4 +27,4 @@ "use strict";

function ZodUnion() {
// opt optional: () => ZodUnion<[this, ZodUndefined]> = () => ZodUnion.create([this, ZodUndefined.create()]);
var _this = _super !== null && _super.apply(this, arguments) || this;
// opt optional: () => ZodUnion<[this, ZodUndefined]> = () => ZodUnion.create([this, ZodUndefined.create()]);
// null nullable: () => ZodUnion<[this, ZodNull]> = () => ZodUnion.create([this, ZodNull.create()]);

@@ -37,9 +37,2 @@ _this.toJSON = function () { return ({

}
Object.defineProperty(ZodUnion.prototype, "options", {
get: function () {
return this._def.options;
},
enumerable: true,
configurable: true
});
// distribute = <F extends (arg: T[number]) => z.ZodTypeAny>(f: F): ZodUnion<{ [k in keyof T]: ReturnType<F> }> => {

@@ -46,0 +39,0 @@ // return ZodUnion.create(this._def.options.map(f) as any);

45

lib/src/ZodError.d.ts

@@ -16,3 +16,2 @@ import { ZodParsedType } from './parser';

too_big: "too_big";
invalid_intersection_types: "invalid_intersection_types";
};

@@ -22,6 +21,5 @@ export declare type ZodErrorCode = keyof typeof ZodErrorCode;

path: (string | number)[];
code: ZodErrorCode;
message?: string;
};
interface InvalidTypeError extends ZodSuberrorBase {
export interface ZodInvalidTypeError extends ZodSuberrorBase {
code: typeof ZodErrorCode.invalid_type;

@@ -31,37 +29,38 @@ expected: ZodParsedType;

}
interface NonEmptyArrayIsEmptyError extends ZodSuberrorBase {
export interface ZodNonEmptyArrayIsEmptyError extends ZodSuberrorBase {
code: typeof ZodErrorCode.nonempty_array_is_empty;
}
interface UnrecognizedKeysError extends ZodSuberrorBase {
export interface ZodUnrecognizedKeysError extends ZodSuberrorBase {
code: typeof ZodErrorCode.unrecognized_keys;
keys: string[];
}
interface InvalidUnionError extends ZodSuberrorBase {
export interface ZodInvalidUnionError extends ZodSuberrorBase {
code: typeof ZodErrorCode.invalid_union;
unionErrors: ZodError[];
}
interface InvalidLiteralValueError extends ZodSuberrorBase {
export interface ZodInvalidLiteralValueError extends ZodSuberrorBase {
code: typeof ZodErrorCode.invalid_literal_value;
expected: string | number | boolean;
}
interface InvalidEnumValueError extends ZodSuberrorBase {
export interface ZodInvalidEnumValueError extends ZodSuberrorBase {
code: typeof ZodErrorCode.invalid_enum_value;
options: string[];
options: (string | number)[];
}
interface InvalidArgumentsError extends ZodSuberrorBase {
export interface ZodInvalidArgumentsError extends ZodSuberrorBase {
code: typeof ZodErrorCode.invalid_arguments;
argumentsError: ZodError;
}
interface InvalidReturnTypeError extends ZodSuberrorBase {
export interface ZodInvalidReturnTypeError extends ZodSuberrorBase {
code: typeof ZodErrorCode.invalid_return_type;
returnTypeError: ZodError;
}
interface InvalidDateError extends ZodSuberrorBase {
export interface ZodInvalidDateError extends ZodSuberrorBase {
code: typeof ZodErrorCode.invalid_date;
}
interface InvalidStringError extends ZodSuberrorBase {
export declare type StringValidation = 'email' | 'url' | 'uuid' | 'regex';
export interface ZodInvalidStringError extends ZodSuberrorBase {
code: typeof ZodErrorCode.invalid_string;
validation: 'email' | 'url' | 'uuid';
validation: StringValidation;
}
interface TooSmallError extends ZodSuberrorBase {
export interface ZodTooSmallError extends ZodSuberrorBase {
code: typeof ZodErrorCode.too_small;

@@ -72,3 +71,3 @@ minimum: number;

}
interface TooBigError extends ZodSuberrorBase {
export interface ZodTooBigError extends ZodSuberrorBase {
code: typeof ZodErrorCode.too_big;

@@ -79,6 +78,3 @@ maximum: number;

}
interface InvalidIntersectionTypesError extends ZodSuberrorBase {
code: typeof ZodErrorCode.invalid_intersection_types;
}
export interface CustomError extends ZodSuberrorBase {
export interface ZodCustomError extends ZodSuberrorBase {
code: typeof ZodErrorCode.custom_error;

@@ -89,3 +85,3 @@ params?: {

}
export declare type ZodSuberrorOptionalMessage = InvalidTypeError | NonEmptyArrayIsEmptyError | UnrecognizedKeysError | InvalidUnionError | InvalidLiteralValueError | InvalidEnumValueError | InvalidArgumentsError | InvalidReturnTypeError | InvalidDateError | InvalidStringError | TooSmallError | TooBigError | InvalidIntersectionTypesError | CustomError;
export declare type ZodSuberrorOptionalMessage = ZodInvalidTypeError | ZodNonEmptyArrayIsEmptyError | ZodUnrecognizedKeysError | ZodInvalidUnionError | ZodInvalidLiteralValueError | ZodInvalidEnumValueError | ZodInvalidArgumentsError | ZodInvalidReturnTypeError | ZodInvalidDateError | ZodInvalidStringError | ZodTooSmallError | ZodTooBigError | ZodCustomError;
export declare type ZodSuberror = ZodSuberrorOptionalMessage & {

@@ -103,2 +99,8 @@ message: string;

addErrors: (subs?: ZodSuberror[]) => void;
flatten: () => {
formErrors: string[];
fieldErrors: {
[k: string]: string[];
};
};
readonly formErrors: {

@@ -111,2 +113,1 @@ formErrors: string[];

}
export {};

48

lib/src/ZodError.js

@@ -31,3 +31,2 @@ "use strict";

'too_big',
'invalid_intersection_types',
]);

@@ -51,2 +50,17 @@ exports.quotelessJson = function (obj) {

};
_this.flatten = function () {
var fieldErrors = {};
var formErrors = [];
for (var _i = 0, _a = _this.errors; _i < _a.length; _i++) {
var sub = _a[_i];
if (sub.path.length > 0) {
fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
fieldErrors[sub.path[0]].push(sub.message);
}
else {
formErrors.push(sub.message);
}
}
return { formErrors: formErrors, fieldErrors: fieldErrors };
};
// restore prototype chain

@@ -60,13 +74,13 @@ var actualProto = _newTarget.prototype;

get: function () {
var errorMessage = [this.errors.length + " validation issue(s)", ''];
for (var _i = 0, _a = this.errors; _i < _a.length; _i++) {
var err = _a[_i];
errorMessage.push(" Issue #" + this.errors.indexOf(err) + ": " + err.code + " at " + err.path.join('.'));
errorMessage.push(" " + err.message);
errorMessage.push('');
}
return errorMessage.join('\n');
return JSON.stringify(this.errors, null, 2);
// const errorMessage: string[] = [`${this.errors.length} validation issue(s)`, ''];
// for (const err of this.errors) {
// errorMessage.push(` Issue #${this.errors.indexOf(err)}: ${err.code} at ${err.path.join('./index')}`);
// errorMessage.push(` ` + err.message);
// errorMessage.push('');
// }
// return errorMessage.join('\n');
// return quotelessJson(this);
// .map(({ path, message }) => {
// return path.length ? `${path.join('.')}: ${message}` : `${message}`;
// return path.length ? `${path.join('./index')}: ${message}` : `${message}`;
// })

@@ -87,15 +101,3 @@ // .join('\n');

get: function () {
var fieldErrors = {};
var formErrors = [];
for (var _i = 0, _a = this.errors; _i < _a.length; _i++) {
var sub = _a[_i];
if (sub.path.length > 0) {
fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
fieldErrors[sub.path[0]].push(sub.message);
}
else {
formErrors.push(sub.message);
}
}
return { formErrors: formErrors, fieldErrors: fieldErrors };
return this.flatten();
},

@@ -102,0 +104,0 @@ enumerable: true,

5

package.json
{
"name": "zod",
"version": "1.11.0-alpha.6",
"version": "1.11.0",
"description": "TypeScript-first schema declaration and validation library with static type inference",

@@ -39,2 +39,3 @@ "main": "./lib/src/index.js",

"build": "yarn run clean && tsc --p tsconfig.package.json",
"buildall": "yarn add typescript@3.4 && yarn build && yarn add typescript@3.5 && yarn build && yarn add typescript@3.6 && yarn build && yarn add typescript@3.7 && yarn build && yarn add typescript@3.8 && yarn build && yarn add typescript@3.9 && yarn build && yarn add typescript@4 && yarn build && yarn add typescript@3.3 && yarn build",
"format": "prettier --write \"src/**/*.ts\" \"src/**/*.js\"",

@@ -59,2 +60,2 @@ "lint": "tslint -p tsconfig.json",

}
}
}

261

README.md

@@ -6,6 +6,8 @@ <p align="center">

<p align="center">
<a href="https://opensource.org/licenses/MIT" rel="nofollow"><img src="https://img.shields.io/github/license/vriad/zod" alt="License"></a>
<a href="https://www.npmjs.com/package/zod" rel="nofollow"><img src="https://img.shields.io/npm/dw/zod.svg" alt="npm"></a>
<a href="https://www.npmjs.com/package/zod" rel="nofollow"><img src="https://img.shields.io/github/stars/vriad/zod" alt="stars"></a>
<a href="./src/__tests__" rel="nofollow"><img src="./coverage.svg" alt="coverage"></a>
<a href="https://twitter.com/vriad" rel="nofollow"><img src="https://img.shields.io/badge/created%20by-@vriad-4BBAAB.svg" alt="Created by Colin McDonnell"></a>
<a href="https://opensource.org/licenses/MIT" rel="nofollow"><img src="https://img.shields.io/github/license/vriad/zod" alt="License"></a>
<a href="https://www.npmjs.com/package/zod" rel="nofollow"><img src="https://img.shields.io/npm/dw/zod.svg" alt="npm"></a>
<a href="https://www.npmjs.com/package/zod" rel="nofollow"><img src="https://img.shields.io/github/stars/vriad/zod" alt="stars"></a>
<a href="./src/__tests__" rel="nofollow"><img src="./coverage.svg" alt="coverage"></a>
</p>

@@ -24,2 +26,4 @@ <p align="center">

> ⚠️ You might be encountering issues building your project if you're using zod@<1.10.2. This is the result of a bug in the TypeScript compiler. To solve this without updating, set `"skipLibCheck": true` in your tsconfig.json "compilerOptions". This issue is resolved in zod@1.10.2 and later.
# What is Zod

@@ -41,12 +45,20 @@

Hi! 👋
<table>
<tr>
<td align="center">
<a href="https://github.com/kevinsimper">
<img src="https://avatars0.githubusercontent.com/u/3084745" width="100px;" alt="" />
</a>
<br>
<b>Colin McDonnell</b>
<br>
<a href="https://twitter.com/vriad">@vriad</a>,
<span>creator of Zod</span>
</td>
<td>
I work on Zod in my free time, so if you're making money from a product that is built with Zod, I'd massively appreciate sponsorship at any level. For solo devs, I recommend the [Chipotle Bowl tier](https://github.com/sponsors/vriad) or the [Cup of Coffee tier](https://github.com/sponsors/vriad). If you're a freelancer or entrepreneur, get listed below and enjoy Zod can [help you with that](https://github.com/sponsors/vriad). Check out my GitHub Sponsors profile at [github.com/sponsors/vriad](github.com/sponsors/vriad).
</td>
</tr>
</table>
I'm Colin (AKA [@vriad](https://twitter.com/vriad)), creator/maintainer of Zod. Currently I work on Zod in my spare time, but I'd love to drop my other commitments and work on it (and other OSS projects) full time. To that end, I recently applied and was accepted into the GitHub Sponsors program, which I hope will provide the resources I need to focus on open-source full time.
If you make money from the software you build with Zod, I would massively appreciate a sponsorship at any level! 🙏 https://github.com/sponsors/vriad
<p align="right">
— Colin
</p>
### Sponsors

@@ -56,6 +68,21 @@

<tr>
<td align="center">
<a href="https://github.com/kevinsimper">
<img src="https://avatars1.githubusercontent.com/u/1126497?s=460&v=4" width="100px;" alt="" />
</a>
<br>
<b>Kevin Simper</b>
<br>
<a href="https://github.com/kevinsimper">@kevinsimper</a>
</td>
<td align="center">
<a href="https://twitter.com/flybayer"><img src="https://avatars2.githubusercontent.com/u/8813276?s=460&u=4ff8beb9a67b173015c4b426a92d89cab960af1b&v=4" width="100px;" alt=""/><br /><b>Brandon Bayer</b></a><br/>
<span>Creator of <a href="https://blitzjs.com">Blitz.js</a></span>
<br />
<a href="https://twitter.com/flybayer">
<img src="https://avatars2.githubusercontent.com/u/8813276?s=460&u=4ff8beb9a67b173015c4b426a92d89cab960af1b&v=4" width="100px;" alt=""/>
</a>
<br>
<b>Brandon Bayer</b>
<br/>
<a href="https://twitter.com/flybayer">@flybayer</a>,
<span>creator of <a href="https://blitzjs.com">Blitz.js</a></span>
<br />
</td>

@@ -67,12 +94,2 @@ </tr>

<!--
| | |
|---|-|
| <p align="center"> Brandon Bayer<br>[@flybayer](https://twitter.com/flybayer)</p> | _To get your name + Twitter + website here, <br/>sponsor Zod at the [Freelancer](https://github.com/sponsors/vriad) or [Consultancy](https://github.com/sponsors/vriad) tier._ |
| | -->
<!-- ### Sponsors who know Zod
_To get your name + Twitter + website here, sponsor Zod at the [Freelancer](https://github.com/sponsors/vriad) or [Consultancy](https://github.com/sponsors/vriad) tier._ -->
# Table of contents

@@ -93,5 +110,6 @@

- [.extend](#extending-objects)
- [.pick/.omit](#masking)
- [.pick/.omit](#pick-and-omit)
- [.partial/.deepPartial](#partials)
- [.nonstrict](#unknown-keys)
- [.primitives/.nonprimitives](#primitives-and-nonprimitives)
- [Records](#records)

@@ -103,3 +121,3 @@ - [Arrays](#arrays)

- [.nullable](#nullable-types)
- [.enum](#enums)
- [Enums](#enums)
- [Intersections](#intersections)

@@ -136,3 +154,5 @@ - [Tuples](#tuples)

1. Zod 1.x requires TypeScript 3.3+
> Support for TS 3.2 was dropped with the release of zod@1.10 on 19 July 2020
2. You must enable `strictNullChecks` or use `strict` mode which includes `strictNullChecks`. Otherwise Zod can't correctly infer the types of your schemas!

@@ -142,2 +162,3 @@ ```ts

{
// ...
"compilerOptions": {

@@ -204,7 +225,7 @@ // ...

`.parse(data:unknown)`
`.parse(data:unknown): T`
Given any Zod schema, you can call its `.parse` method to check `data` is valid. If it is, a value is returned with full type information! Otherwise, an error is thrown.
> IMPORTANT: As of Zod 1.4, the value returned by `.parse` is _the same variable you passed in_. Previously it returned a deep clone. The only exception to this is `Promise` schemas, which return a new Promise for reasons explained in the documentation.
> IMPORTANT: After Zod 1.11, the value returned by `.parse` is a _deep clone_ of the variable you passed in. This was also the case in zod@1.4 and earlier. The only exception to this is `Union` and `Intersection` schemas, which return the same value you pass in.

@@ -217,2 +238,32 @@ ```ts

### Safe parse
`.safeParse(data:unknown): { success: true; data: T; } | { success: false; error: ZodError; }`
If you don't want Zod to throw when validation errors occur, you can use `.safeParse`. This method returns an object, even if validation errors occur:
```ts
stringSchema.safeParse(12);
// => { successs: false; error: ZodError }
stringSchema.safeParse('billie');
// => { successs: true; data: 'billie' }
```
Because the result is a _discriminated union_ you can handle errors very conveniently:
```ts
const result = stringSchema.safeParse('billie');
if (!result.success) {
// handle error then return
return;
}
// underneath the if statement, TypeScript knows
// that validation passed
console.log(result.data);
```
> Errors thrown from within refinement functions will _not_ be caught.
### Type guards

@@ -235,3 +286,3 @@

```ts
````ts
const stringSchema = z.string();

@@ -261,3 +312,3 @@

});
```
````

@@ -283,3 +334,3 @@ As you can see, `.refine` takes two arguments.

These params let you define powerful custom behavior. Zod is commonly used for form validation. If you want to verify that "password" and "confirmPassword" match, you can do so like this:
These params let you define powerful custom behavior. Zod is commonly used for form validation. If you want to verify that "password" and "confirm" match, you can do so like this:

@@ -291,7 +342,7 @@ ```ts

})
.refine(data => data.confirm === data.password, {
.refine(data => data.password === data.confirm, {
message: "Passwords don't match",
path: ['confirm'],
path: ['confirm'], // set path of error
})
.parse({ password: 'asdf', confirmPassword: 'qwer' });
.parse({ password: 'asdf', confirm: 'qwer' });
```

@@ -340,2 +391,3 @@

z.string().uuid();
z.string().regex(regex);
```

@@ -492,3 +544,3 @@

#### Masking
#### Pick and omit

@@ -527,2 +579,38 @@ Object masking is one of Zod's killer features. It lets you create slight variations of your object schemas easily and succinctly. Inspired by TypeScript's built-in `Pick` and `Omit` utility types, all Zod object schemas have `.pick` and `.omit` methods that return a "masked" version of the schema.

#### Primitives and nonprimitives
Zod provides a convenience method for automatically picking all primitive or non-primitive fields from an object schema.
```ts
const Post = z.object({
title: z.string()
});
const User = z.object({
id: z.number(),
name: z.string(),
posts: z.array(Post)
});
const UserFields = User.primitives();
typeof UserFields = z.infer<typeof UserFields>;
// => { id: number; name; string; }
const UserRelations = User.nonprimitives();
typeof UserFields = z.infer<typeof UserFields>;
// => { posts: Post[] }
```
These schemas are considering "primitive":
- string
- number
- boolean
- bigint
- date
- null/undefined
- enums
- any array of the above types
- any union of the above types
#### Partials

@@ -862,4 +950,8 @@

An enum is just a union of string literals, so you can "build your own enum" like this:
There are two ways to define enums in Zod.
#### Zod enums
An enum is just a union of string literals, so you _could_ define an enum like this:
```ts

@@ -872,6 +964,7 @@ const FishEnum = z.union([z.literal('Salmon'), z.literal('Tuna'), z.literal('Trout')]);

But for convenience Zod provides a built-in `z.enum()` function, like so:
For convenience Zod provides a built-in `z.enum()` function. Here's is the equivalent code:
```ts
const FishEnum = z.enum(['Salmon', 'Tuna', 'Trout']);
type FishEnum = z.infer<typeof FishEnum>;

@@ -881,13 +974,7 @@ // 'Salmon' | 'Tuna' | 'Trout'

> You need to pass the literal array directly into z.enum():
>
> ```ts
> const FishEnum = z.enum(['Salmon', 'Tuna', 'Trout']);
> ```
>
> If you define the array as a separate variable, then pass it into z.enum, type inference won't work properly.
> Important! You need to pass the literal array _directly_ into z.enum(). Do not define it separately, than pass it in as a variable! This is required for proper type inference.
#### Autocompletion
**Autocompletion**
You can autocomplete the enum values with the `.enum` property of an enum schema:
To get autocompletion with a Zod enum, use the `.enum` property of your schema:

@@ -913,2 +1000,66 @@ ```ts

#### Native enums
> ⚠️ `nativeEnum()` requires TypeScript 3.6 or higher!
Zod enums are the recommended approach to defining and validating enums. But there may be scenarios where you need to validate against an enum from a third-party library, or perhaps you don't want to rewrite your existing enums. For this you can use `z.nativeEnum()`.
**Numeric enums**
```ts
enum Fruits {
Apple,
Banana,
}
const FruitEnum = z.nativeEnum(Fruits);
type FruitEnum = z.infer<typeof FruitEnum>; // Fruits
FruitEnum.parse(Fruits.Apple); // passes
FruitEnum.parse(Fruits.Banana); // passes
FruitEnum.parse(0); // passes
FruitEnum.parse(1); // passes
FruitEnum.parse(3); // fails
```
**String enums**
```ts
enum Fruits {
Apple = 'apple',
Banana = 'banana',
Cantaloupe, // you can mix numerical and string enums
}
const FruitEnum = z.nativeEnum(Fruits);
type FruitEnum = z.infer<typeof FruitEnum>; // Fruits
FruitEnum.parse(Fruits.Apple); // passes
FruitEnum.parse(Fruits.Cantaloupe); // passes
FruitEnum.parse('apple'); // passes
FruitEnum.parse('banana'); // passes
FruitEnum.parse(0); // passes
FruitEnum.parse('Cantaloupe'); // fails
```
**Const enums**
The `.nativeEnum()` function works for `as const` objects as well. ⚠️ `as const` required TypeScript 3.4+!
```ts
const Fruits = {
Apple: 'apple',
Banana: 'banana',
Cantaloupe: 3,
} as const;
const FruitEnum = z.nativeEnum(Fruits);
type FruitEnum = z.infer<typeof FruitEnum>; // "apple" | "banana" | 3
FruitEnum.parse('apple'); // passes
FruitEnum.parse('banana'); // passes
FruitEnum.parse(3); // passes
FruitEnum.parse('Cantaloupe'); // fails
```
## Intersections

@@ -929,14 +1080,14 @@

Intersections in Zod are not smart. Whatever data you pass into `.parse()` gets passed into the two intersected schemas. Because Zod object schemas don't allow any unknown keys by default, there are some unintuitive behavior surrounding intersections of object schemas.
This is particularly useful for defining "schema mixins" that you can apply to multiple schemas.
```ts
const A = z.object({
a: z.string(),
const HasId = z.object({
id: z.string(),
});
const B = z.object({
b: z.string(),
const BaseTeacher = z.object({
name: z.string(),
});
const AB = z.intersection(A, B);
const Teacher = z.intersection(BaseTeacher, HasId);

@@ -1113,3 +1264,3 @@ type Teacher = z.infer<typeof Teacher>;

> You can the special `z.void()` option if your function doesn't return anything. This will let Zod properly infer the type of void-returning functions. (Void-returning function can actually return either undefined or null.)
> You can use the special `z.void()` option if your function doesn't return anything. This will let Zod properly infer the type of void-returning functions. (Void-returning function can actually return either undefined or null.)

@@ -1116,0 +1267,0 @@ ```ts

lib/src/types/transformer.d.ts
lib/src/types/transformer.js
lib/src/types/transformer.js.map
lib/src/codegen.js.map

Sorry, the diff of this file is not supported yet

lib/src/defaultErrorMap.js.map

Sorry, the diff of this file is not supported yet

lib/src/helpers/objectUtil.js.map

Sorry, the diff of this file is not supported yet

lib/src/helpers/util.js.map

Sorry, the diff of this file is not supported yet

lib/src/index.js.map

Sorry, the diff of this file is not supported yet

lib/src/parser.js.map

Sorry, the diff of this file is not supported yet

lib/src/types/array.js.map

Sorry, the diff of this file is not supported yet

lib/src/types/base.js.map

Sorry, the diff of this file is not supported yet

lib/src/types/function.js.map

Sorry, the diff of this file is not supported yet

lib/src/types/number.js.map

Sorry, the diff of this file is not supported yet

lib/src/types/object.js.map

Sorry, the diff of this file is not supported yet

lib/src/types/string.js.map

Sorry, the diff of this file is not supported yet

lib/src/types/union.js.map

Sorry, the diff of this file is not supported yet

lib/src/ZodError.js.map

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc