zod-invertible
Version:
declare zod schemas that can be inverted to format from output to input
171 lines (170 loc) • 8.09 kB
JavaScript
;
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.ZodInvertible = exports.IgnoreEffect = void 0;
exports.ignoreEffect = ignoreEffect;
exports.invert = invert;
exports.invertible = invertible;
var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
var _zod = _interopRequireDefault(require("zod"));
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(t).constructor) : o.apply(t, e)); }
function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
var ZodInvertible = exports.ZodInvertible = /*#__PURE__*/function (_z$ZodPipeline) {
function ZodInvertible(inputSchema, parse, outputSchema, format) {
(0, _classCallCheck2["default"])(this, ZodInvertible);
return _callSuper(this, ZodInvertible, [_objectSpread(_objectSpread({}, inputSchema.transform(parse).pipe(outputSchema)._def), {}, {
inputSchema: inputSchema,
outputSchema: outputSchema,
parse: parse,
format: format
})]);
}
(0, _inherits2["default"])(ZodInvertible, _z$ZodPipeline);
return (0, _createClass2["default"])(ZodInvertible);
}(_zod["default"].ZodPipeline);
function invertible(schema, parse, outSchema, format) {
return new ZodInvertible(schema, parse, outSchema, format);
}
var IgnoreEffect = exports.IgnoreEffect = Symbol('IgnoreEffect');
function ignoreEffect(schema) {
;
schema[IgnoreEffect] = true;
return schema;
}
function invert(schema) {
switch (schema._def.typeName) {
case _zod["default"].ZodFirstPartyTypeKind.ZodArray:
return _zod["default"].array(invert(schema.element));
case _zod["default"].ZodFirstPartyTypeKind.ZodObject:
{
var _ref = schema,
shape = _ref.shape,
_def = _ref._def;
var invertedShape = Object.fromEntries(Object.entries(shape).map(function (_ref2) {
var _ref3 = (0, _slicedToArray2["default"])(_ref2, 2),
key = _ref3[0],
value = _ref3[1];
return [key, invert(value)];
}));
return new _zod["default"].ZodObject(_objectSpread(_objectSpread({}, _def), {}, {
catchall: invert(_def.catchall),
shape: function shape() {
return invertedShape;
}
}));
}
case _zod["default"].ZodFirstPartyTypeKind.ZodUnion:
return _zod["default"].union(schema.options.map(invert));
case _zod["default"].ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
{
var _ref4 = schema,
discriminator = _ref4.discriminator,
options = _ref4.options;
return _zod["default"].discriminatedUnion(discriminator, options.map(invert));
}
case _zod["default"].ZodFirstPartyTypeKind.ZodIntersection:
{
var _def2 = schema._def,
left = _def2.left,
right = _def2.right;
return _zod["default"].intersection(invert(left), invert(right));
}
case _zod["default"].ZodFirstPartyTypeKind.ZodTuple:
{
var _ref5 = schema,
items = _ref5.items,
rest = _ref5._def.rest;
var result = _zod["default"].tuple(items.map(invert));
return rest ? result.rest(invert(rest)) : result;
}
case _zod["default"].ZodFirstPartyTypeKind.ZodRecord:
{
var _ref6 = schema,
keySchema = _ref6.keySchema,
valueSchema = _ref6.valueSchema;
return _zod["default"].record(invert(keySchema), invert(valueSchema));
}
case _zod["default"].ZodFirstPartyTypeKind.ZodMap:
{
var _ref7 = schema,
_keySchema = _ref7.keySchema,
_valueSchema = _ref7.valueSchema;
return _zod["default"].map(invert(_keySchema), invert(_valueSchema));
}
case _zod["default"].ZodFirstPartyTypeKind.ZodSet:
return _zod["default"].set(invert(schema._def.valueType));
case _zod["default"].ZodFirstPartyTypeKind.ZodFunction:
{
var _ref8 = schema,
_ref8$_def = _ref8._def,
args = _ref8$_def.args,
returns = _ref8$_def.returns;
return _zod["default"]["function"](args.map(invert), invert(returns));
}
case _zod["default"].ZodFirstPartyTypeKind.ZodLazy:
return _zod["default"].lazy(function () {
return invert(schema.schema);
});
case _zod["default"].ZodFirstPartyTypeKind.ZodEffects:
{
var _ref9 = schema,
_ref9$_def = _ref9._def,
effect = _ref9$_def.effect,
innerType = _ref9$_def.schema;
switch (effect.type) {
case 'refinement':
{
var refinement = effect.refinement;
return _zod["default"].any().superRefine(refinement).pipe(invert(innerType));
}
case 'preprocess':
case 'transform':
if (schema[IgnoreEffect]) {
return invert(innerType);
}
throw new Error("effect not supported: ".concat(effect.type));
}
break;
}
case _zod["default"].ZodFirstPartyTypeKind.ZodOptional:
return invert(schema.unwrap()).optional();
case _zod["default"].ZodFirstPartyTypeKind.ZodNullable:
return invert(schema.unwrap()).nullable();
case _zod["default"].ZodFirstPartyTypeKind.ZodDefault:
return invert(schema.removeDefault());
case _zod["default"].ZodFirstPartyTypeKind.ZodCatch:
return invert(schema.removeCatch());
case _zod["default"].ZodFirstPartyTypeKind.ZodPromise:
return _zod["default"].promise(invert(schema._def.type));
case _zod["default"].ZodFirstPartyTypeKind.ZodBranded:
return invert(schema._def.type);
case _zod["default"].ZodFirstPartyTypeKind.ZodPipeline:
{
if (schema instanceof ZodInvertible) {
var _schema$_def = schema._def,
inputSchema = _schema$_def.inputSchema,
outputSchema = _schema$_def.outputSchema,
parse = _schema$_def.parse,
format = _schema$_def.format;
return invertible(invert(outputSchema), format, invert(inputSchema), parse);
}
var _ref0 = schema,
_def3 = _ref0._def;
return invert(_def3.out).pipe(invert(_def3["in"]));
}
case _zod["default"].ZodFirstPartyTypeKind.ZodReadonly:
return invert(schema._def.innerType).readonly();
}
return schema;
}
//# sourceMappingURL=index.js.map