@pothos/plugin-zod
Version:
A Pothos plugin for adding argument validation
305 lines (304 loc) • 10.1 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: Object.getOwnPropertyDescriptor(all, name).get
});
}
_export(exports, {
get combine () {
return combine;
},
get createArrayValidator () {
return createArrayValidator;
},
get createBigintValidator () {
return createBigintValidator;
},
get createBooleanValidator () {
return createBooleanValidator;
},
get createDateValidator () {
return createDateValidator;
},
get createNumberValidator () {
return createNumberValidator;
},
get createObjectValidator () {
return createObjectValidator;
},
get createStringValidator () {
return createStringValidator;
},
get default () {
return createZodSchema;
},
get isArrayValidator () {
return isArrayValidator;
},
get isBaseValidator () {
return isBaseValidator;
},
get refine () {
return refine;
}
});
const _core = require("@pothos/core");
const _zod = /*#__PURE__*/ _interop_require_wildcard(require("zod"));
function _getRequireWildcardCache(nodeInterop) {
if (typeof WeakMap !== "function") return null;
var cacheBabelInterop = new WeakMap();
var cacheNodeInterop = new WeakMap();
return (_getRequireWildcardCache = function(nodeInterop) {
return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
})(nodeInterop);
}
function _interop_require_wildcard(obj, nodeInterop) {
if (!nodeInterop && obj && obj.__esModule) {
return obj;
}
if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
return {
default: obj
};
}
var cache = _getRequireWildcardCache(nodeInterop);
if (cache && cache.has(obj)) {
return cache.get(obj);
}
var newObj = {
__proto__: null
};
var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
for(var key in obj){
if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
if (desc && (desc.get || desc.set)) {
Object.defineProperty(newObj, key, desc);
} else {
newObj[key] = obj[key];
}
}
}
newObj.default = obj;
if (cache) {
cache.set(obj, newObj);
}
return newObj;
}
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;
};
}
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);
}
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);
});
const createBigintValidator = validatorCreator('bigint', bigIntValidations, (options)=>refine(_zod.bigint(), options));
const createBooleanValidator = validatorCreator('boolean', booleanValidations, (options)=>refine(_zod.boolean(), options));
const createDateValidator = validatorCreator('date', dateValidations, (options)=>refine(_zod.date(), options));
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);
});
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));
}
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);
}
const createObjectValidator = validatorCreator('object', objectValidations, (options)=>refine(_zod.looseObject({}), options));
const validationCreators = [
createNumberValidator,
createBigintValidator,
createBooleanValidator,
createDateValidator,
createStringValidator,
createObjectValidator
];
function isBaseValidator(options) {
if (typeof options === 'function') {
return true;
}
const validations = Object.keys(options);
return validations.every((validation)=>baseValidations.includes(validation));
}
function combine(validators, required) {
const union = validators.length > 1 ? _zod.union(validators) : validators[0];
return required ? union : union.optional().nullable();
}
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 _core.PothosSchemaError(`No type validator can implement every constraint in (${Object.keys(options)})`);
}
return combine([
...typeValidators
], required);
}
//# sourceMappingURL=createZodSchema.js.map