@pothos/plugin-zod
Version:
A Pothos plugin for adding argument validation
216 lines (215 loc) • 7.6 kB
JavaScript
import { PothosSchemaError } from '@pothos/core';
import * as zod from 'zod';
const baseValidations = [
'refine',
'schema'
];
const numberValidations = [
...baseValidations,
'int',
'max',
'min',
'negative',
'nonnegative',
'nonpositive',
'positive',
'type'
];
const bigIntValidations = [
...baseValidations,
'type'
];
const booleanValidations = [
...baseValidations,
'type'
];
const dateValidations = [
...baseValidations,
'type'
];
const stringValidations = [
...baseValidations,
'email',
'length',
'maxLength',
'minLength',
'regex',
'type',
'url',
'uuid'
];
const arrayValidations = [
...baseValidations,
'items',
'length',
'maxLength',
'minLength',
'type'
];
const objectValidations = [
...baseValidations,
'type'
];
// biome-ignore lint/suspicious/noExplicitAny: this is fine
function validatorCreator(type, validationNames, create) {
function check(options) {
if (typeof options !== 'object' || options.type && options.type !== type) {
return false;
}
const validations = Object.keys(options);
return validations.every((validation)=>validationNames.includes(validation));
}
return (options)=>{
if (check(options)) {
return create(options);
}
return null;
};
}
export function refine(originalValidator, options) {
var _options_refine;
if (!options) {
return originalValidator;
}
if (typeof options === 'function') {
return originalValidator.refine(options);
}
if (Array.isArray(options)) {
return refine(originalValidator, {
refine: options
});
}
let validator = originalValidator;
if (options.schema) {
validator = options.schema.pipe(originalValidator);
}
if (!options.refine) {
return validator;
}
if (typeof options.refine === 'function') {
return validator.refine(options.refine);
}
if (typeof ((_options_refine = options.refine) === null || _options_refine === void 0 ? void 0 : _options_refine[0]) === 'function') {
return validator.refine(...options.refine);
}
const refinements = options.refine;
return refinements.reduce((prev, [refineFn, opts])=>prev.refine(refineFn, opts), validator);
}
export const createNumberValidator = validatorCreator('number', numberValidations, (options)=>{
let validator = zod.number();
if (options.min) {
validator = Array.isArray(options.min) ? validator.min(Number(options.min[0]), options.min[1]) : validator.min(Number(options.min));
}
if (options.max) {
validator = Array.isArray(options.max) ? validator.max(Number(options.max[0]), options.max[1]) : validator.max(Number(options.max));
}
const booleanConstraints = [
'int',
'negative',
'nonnegative',
'positive',
'nonpositive'
];
for (const constraint of booleanConstraints){
if (options[constraint]) {
const value = options[constraint];
validator = validator[constraint](Array.isArray(value) ? value[1] : {});
}
}
return refine(validator, options);
});
export const createBigintValidator = validatorCreator('bigint', bigIntValidations, (options)=>refine(zod.bigint(), options));
export const createBooleanValidator = validatorCreator('boolean', booleanValidations, (options)=>refine(zod.boolean(), options));
export const createDateValidator = validatorCreator('date', dateValidations, (options)=>refine(zod.date(), options));
export const createStringValidator = validatorCreator('string', stringValidations, (options)=>{
let validator = zod.string();
if (options.length !== undefined) {
validator = Array.isArray(options.length) ? validator.length(options.length[0], options.length[1]) : validator.length(options.length);
}
if (options.minLength) {
validator = Array.isArray(options.minLength) ? validator.min(options.minLength[0], options.minLength[1]) : validator.min(options.minLength);
}
if (options.maxLength) {
validator = Array.isArray(options.maxLength) ? validator.max(options.maxLength[0], options.maxLength[1]) : validator.max(options.maxLength);
}
if (options.regex) {
validator = Array.isArray(options.regex) ? validator.regex(options.regex[0], options.regex[1]) : validator.regex(options.regex);
}
const booleanConstraints = [
'email',
'url',
'uuid'
];
for (const constraint of booleanConstraints){
if (options[constraint]) {
const value = options[constraint];
validator = validator[constraint](Array.isArray(value) ? value[1] : {});
}
}
return refine(validator, options);
});
export function isArrayValidator(options) {
if (typeof options !== 'object' || options.type && options.type !== 'array') {
return false;
}
const validations = Object.keys(options);
return validations.every((validation)=>arrayValidations.includes(validation));
}
export function createArrayValidator(options, items) {
let validator = items.array();
if (options.length !== undefined) {
validator = Array.isArray(options.length) ? validator.length(options.length[0], options.length[1].message) : validator.length(options.length);
}
if (options.minLength) {
validator = Array.isArray(options.minLength) ? validator.min(options.minLength[0], options.minLength[1]) : validator.min(options.minLength);
}
if (options.maxLength) {
validator = Array.isArray(options.maxLength) ? validator.max(options.maxLength[0], options.maxLength[1]) : validator.max(options.maxLength);
}
return refine(validator, options);
}
export const createObjectValidator = validatorCreator('object', objectValidations, (options)=>refine(zod.looseObject({}), options));
const validationCreators = [
createNumberValidator,
createBigintValidator,
createBooleanValidator,
createDateValidator,
createStringValidator,
createObjectValidator
];
export function isBaseValidator(options) {
if (typeof options === 'function') {
return true;
}
const validations = Object.keys(options);
return validations.every((validation)=>baseValidations.includes(validation));
}
export function combine(validators, required) {
const union = validators.length > 1 ? zod.union(validators) : validators[0];
return required ? union : union.optional().nullable();
}
export default function createZodSchema(optionsOrConstraint, required = false) {
const options = Array.isArray(optionsOrConstraint) || typeof optionsOrConstraint === 'function' ? {
refine: optionsOrConstraint
} : optionsOrConstraint;
if (!options) {
return zod.unknown();
}
if (isBaseValidator(options)) {
return combine([
refine(zod.unknown(), options)
], required);
}
const typeValidators = validationCreators.map((create)=>create(options)).filter(Boolean);
if (isArrayValidator(options)) {
const items = options.items ? createZodSchema(options.items) : zod.unknown();
typeValidators.push(createArrayValidator(options, items));
}
if (typeValidators.length === 0) {
throw new PothosSchemaError(`No type validator can implement every constraint in (${Object.keys(options)})`);
}
return combine([
...typeValidators
], required);
}
//# sourceMappingURL=createZodSchema.js.map