@aeriajs/validation 0.0.178 → 0.0.180

package/dist/index.js

@@ -1,17 +1 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./validate.js"), exports);
+export * from './validate.js';

package/dist/validate.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validator = exports.validatePropertyWithRefs = exports.validateWithRefs = exports.validate = exports.validateWholeness = exports.validateRefs = exports.validateProperty = exports.makeValidationError = void 0;
-const common_1 = require("@aeriajs/common");
-const types_1 = require("@aeriajs/types");
-const entrypoint_1 = require("@aeriajs/entrypoint");
+import { convertConditionToQuery, getMissingProperties } from '@aeriajs/common';
+import { Result, ValidationErrorCode, PropertyValidationErrorCode } from '@aeriajs/types';
+import { getCollection } from '@aeriajs/entrypoint';
 const isValidObjectId = (what) => {
     return /^[0-9a-f]{24}$/.test(what);
 };
@@ -38,28 +35,27 @@ const makePropertyError = (type, details) => {
         details,
     };
 };
-const makeValidationError = (error) => {
+export const makeValidationError = (error) => {
     return error;
 };
-exports.makeValidationError = makeValidationError;
-const validateProperty = (what, property, options = {}) => {
+export const validateProperty = (what, property, options = {}) => {
     if (!property) {
         if (options.parentProperty && 'additionalProperties' in options.parentProperty) {
             if (options.parentProperty.additionalProperties === true) {
-                return types_1.Result.result(what);
+                return Result.result(what);
             }
-            return (0, exports.validateProperty)(what, options.parentProperty.additionalProperties);
+            return validateProperty(what, options.parentProperty.additionalProperties);
         }
         if (options.tolerateExtraneous) {
-            return types_1.Result.result(undefined);
+            return Result.result(undefined);
         }
-        return types_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.Extraneous));
+        return Result.error(makePropertyError(PropertyValidationErrorCode.Extraneous));
     }
     if (what === null || what === undefined) {
-        return types_1.Result.result(what);
+        return Result.result(what);
     }
     if ('getter' in property) {
-        return types_1.Result.result(undefined);
+        return Result.result(undefined);
     }
     const expectedType = getPropertyType(property);
     const actualType = Array.isArray(what)
@@ -68,15 +64,15 @@ const validateProperty = (what, property, options = {}) => {
     if (actualType !== expectedType
         && !(actualType === 'number' && expectedType === 'integer')) {
         if (expectedType === 'datetime' && what instanceof Date) {
-            return types_1.Result.result(what);
+            return Result.result(what);
         }
         if ('$ref' in property) {
             switch (typeof what) {
                 case 'string': {
                     if (isValidObjectId(what)) {
-                        return types_1.Result.result(what);
+                        return Result.result(what);
                     }
-                    return types_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.Unmatching, {
+                    return Result.error(makePropertyError(PropertyValidationErrorCode.Unmatching, {
                         expected: expectedType,
                         got: actualType,
                     }));
@@ -87,28 +83,28 @@ const validateProperty = (what, property, options = {}) => {
             if (expectedType === 'number' && typeof what === 'string') {
                 const coerced = parseFloat(what);
                 if (!isNaN(coerced)) {
-                    return types_1.Result.result(coerced);
+                    return Result.result(coerced);
                 }
             }
             if (expectedType === 'integer' && typeof what === 'string') {
                 const coerced = parseInt(what);
                 if (!isNaN(coerced)) {
-                    return types_1.Result.result(coerced);
+                    return Result.result(coerced);
                 }
             }
             if (expectedType === 'string' && typeof what === 'number') {
-                return types_1.Result.result(String(what));
+                return Result.result(String(what));
             }
             if (expectedType === 'datetime' && typeof what === 'string') {
-                return types_1.Result.result(new Date(what));
+                return Result.result(new Date(what));
             }
         }
         if ((options.coerce || options.coerceObjectIds) && options.objectIdConstructor) {
             if (('$ref' in property || 'format' in property && property.format === 'objectid') && typeof what === 'string') {
-                return types_1.Result.result(new options.objectIdConstructor(what));
+                return Result.result(new options.objectIdConstructor(what));
             }
         }
-        return types_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.Unmatching, {
+        return Result.error(makePropertyError(PropertyValidationErrorCode.Unmatching, {
             expected: expectedType,
             got: actualType,
         }));
@@ -122,7 +118,7 @@ const validateProperty = (what, property, options = {}) => {
                             throw new Error;
                         }
                         if (!(what instanceof options.objectIdConstructor)) {
-                            return types_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.StringConstraint, {
+                            return Result.error(makePropertyError(PropertyValidationErrorCode.StringConstraint, {
                                 expected: 'objectid',
                                 got: 'invalid_objectid',
                             }));
@@ -131,14 +127,14 @@ const validateProperty = (what, property, options = {}) => {
                     }
                     default: {
                         if (typeof what !== 'string') {
-                            return types_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.Unmatching, {
+                            return Result.error(makePropertyError(PropertyValidationErrorCode.Unmatching, {
                                 expected: expectedType,
                                 got: actualType,
                             }));
                         }
                         if ((typeof property.minLength === 'number' && property.minLength > what.length)
                             || (typeof property.maxLength === 'number' && property.maxLength < what.length)) {
-                            return types_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.StringConstraint, {
+                            return Result.error(makePropertyError(PropertyValidationErrorCode.StringConstraint, {
                                 expected: 'string',
                                 got: 'invalid_string',
                             }));
@@ -149,7 +145,7 @@ const validateProperty = (what, property, options = {}) => {
             }
             case 'integer': {
                 if (!Number.isInteger(what)) {
-                    return types_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.NumericConstraint, {
+                    return Result.error(makePropertyError(PropertyValidationErrorCode.NumericConstraint, {
                         expected: 'integer',
                         got: 'invalid_number',
                     }));
@@ -157,7 +153,7 @@ const validateProperty = (what, property, options = {}) => {
             }
             case 'number': {
                 if (typeof what !== 'number') {
-                    return types_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.Unmatching, {
+                    return Result.error(makePropertyError(PropertyValidationErrorCode.Unmatching, {
                         expected: expectedType,
                         got: actualType,
                     }));
@@ -166,7 +162,7 @@ const validateProperty = (what, property, options = {}) => {
                     || (typeof property.minimum === 'number' && property.minimum > what)
                     || (typeof property.exclusiveMaximum === 'number' && property.exclusiveMaximum <= what)
                     || (typeof property.exclusiveMinimum === 'number' && property.exclusiveMinimum >= what)) {
-                    return types_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.NumericConstraint, {
+                    return Result.error(makePropertyError(PropertyValidationErrorCode.NumericConstraint, {
                         expected: 'number',
                         got: 'invalid_number',
                     }));
@@ -175,39 +171,39 @@ const validateProperty = (what, property, options = {}) => {
             }
             case 'object': {
                 if ('properties' in property) {
-                    return (0, exports.validate)(what, property, options);
+                    return validate(what, property, options);
                 }
                 switch (typeof property.additionalProperties) {
-                    case 'object': return (0, exports.validate)(what, property.additionalProperties, options);
-                    case 'boolean': return types_1.Result.result(what);
+                    case 'object': return validate(what, property.additionalProperties, options);
+                    case 'boolean': return Result.result(what);
                 }
             }
             case 'array': {
                 if (!Array.isArray(what)) {
-                    return types_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.Unmatching, {
+                    return Result.error(makePropertyError(PropertyValidationErrorCode.Unmatching, {
                         expected: expectedType,
                         got: actualType,
                     }));
                 }
                 if (property.minItems) {
                     if (what.length < property.minItems) {
-                        return types_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.MoreItemsExpected));
+                        return Result.error(makePropertyError(PropertyValidationErrorCode.MoreItemsExpected));
                     }
                 }
                 if (property.maxItems) {
                     if (what.length > property.maxItems) {
-                        return types_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.LessItemsExpected));
+                        return Result.error(makePropertyError(PropertyValidationErrorCode.LessItemsExpected));
                     }
                 }
                 let i = 0;
                 for (const elem of what) {
-                    const { error } = (0, exports.validateProperty)(elem, property.items, options);
+                    const { error } = validateProperty(elem, property.items, options);
                     if (error) {
                         if ('code' in error) {
                             continue;
                         }
                         error.index = i;
-                        return types_1.Result.error(error);
+                        return Result.error(error);
                     }
                     i++;
                 }
@@ -216,7 +212,7 @@ const validateProperty = (what, property, options = {}) => {
     }
     else if ('enum' in property) {
         if (!property.enum.includes(what)) {
-            return types_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.ExtraneousElement, {
+            return Result.error(makePropertyError(PropertyValidationErrorCode.ExtraneousElement, {
                 expected: property.enum,
                 got: what,
             }));
@@ -224,26 +220,25 @@ const validateProperty = (what, property, options = {}) => {
     }
     else if ('const' in property) {
         if (what !== property.const) {
-            return types_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.Unmatching, {
+            return Result.error(makePropertyError(PropertyValidationErrorCode.Unmatching, {
                 expected: property.const,
                 got: what,
             }));
         }
     }
-    return types_1.Result.result(what);
+    return Result.result(what);
 };
-exports.validateProperty = validateProperty;
-const validateRefs = async (what, property, options = {}) => {
+export const validateRefs = async (what, property, options = {}) => {
     if ('$ref' in property) {
         if (options.checkObjectIds) {
             if (!options.context || !options.objectIdConstructor) {
                 throw new Error;
             }
             if (what === null) {
-                return types_1.Result.result({});
+                return Result.result({});
             }
             if (!isValidObjectId(String(what))) {
-                return types_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.Unmatching, {
+                return Result.error(makePropertyError(PropertyValidationErrorCode.Unmatching, {
                     expected: 'objectid',
                     got: typeof what,
                 }));
@@ -255,7 +250,7 @@ const validateRefs = async (what, property, options = {}) => {
                         {
                             _id: new options.objectIdConstructor(what),
                         },
-                        (0, common_1.convertConditionToQuery)(property.constraints),
+                        convertConditionToQuery(property.constraints),
                     ],
                 };
             }
@@ -270,69 +265,71 @@ const validateRefs = async (what, property, options = {}) => {
                 },
             });
             if (!exists) {
-                return types_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.ReferenceConstraint, {
+                return Result.error(makePropertyError(PropertyValidationErrorCode.ReferenceConstraint, {
                     expected: 'objectid',
                     got: 'invalid_objectid',
                 }));
             }
-            return types_1.Result.result({});
+            return Result.result({});
         }
         let description;
         if (options.descriptions) {
             description = options.descriptions[property.$ref];
         }
         else {
-            const collection = await (0, entrypoint_1.getCollection)(property.$ref);
+            const collection = await getCollection(property.$ref);
             if (!collection) {
                 throw new Error;
             }
             description = collection.description;
         }
         if (typeof what !== 'object') {
-            return types_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.Unmatching, {
+            return Result.error(makePropertyError(PropertyValidationErrorCode.Unmatching, {
                 expected: 'object',
                 got: typeof what,
             }));
         }
-        return (0, exports.validate)(what, description, options);
+        return validate(what, description, options);
     }
     else if ('items' in property) {
         if (!Array.isArray(what)) {
             throw new Error;
         }
         for (const elem of what) {
-            const { error } = await (0, exports.validateRefs)(elem, property.items, options);
+            const { error } = await validateRefs(elem, property.items, options);
             if (error) {
-                return types_1.Result.error(error);
+                return Result.error(error);
             }
         }
     }
     else if ('properties' in property) {
         const details = {};
         for (const propName in what) {
-            const { error } = await (0, exports.validateRefs)(what[propName], property.properties[propName], options);
+            if (!(propName in property.properties)) {
+                continue;
+            }
+            const { error } = await validateRefs(what[propName], property.properties[propName], options);
             if (error) {
                 details[propName] = error;
             }
         }
         if (Object.keys(details).length > 0) {
-            return types_1.Result.error((0, exports.makeValidationError)({
-                code: types_1.ValidationErrorCode.InvalidProperties,
+            return Result.error(makeValidationError({
+                code: ValidationErrorCode.InvalidProperties,
                 details,
             }));
         }
     }
-    return types_1.Result.result({});
+    return Result.result({});
 };
-exports.validateRefs = validateRefs;
-const validateWholeness = (what, schema) => {
+export const validateWholeness = (what, schema) => {
     const required = schema.required
         ? schema.required
         : Object.keys(schema.properties);
-    const missingProps = (0, common_1.getMissingProperties)(what, schema, required);
+    const missingProps = getMissingProperties(what, schema, required);
     if (missingProps.length > 0) {
-        return (0, exports.makeValidationError)({
-            code: types_1.ValidationErrorCode.MissingProperties,
+        return makeValidationError({
+            code: ValidationErrorCode.MissingProperties,
             details: Object.fromEntries(missingProps.map((error) => [
                 error,
                 {
@@ -342,38 +339,37 @@ const validateWholeness = (what, schema) => {
         });
     }
 };
-exports.validateWholeness = validateWholeness;
-const validate = (what, schema, options = {}) => {
+export const validate = (what, schema, options = {}) => {
     if (what === undefined) {
-        return types_1.Result.error((0, exports.makeValidationError)({
-            code: types_1.ValidationErrorCode.EmptyTarget,
+        return Result.error(makeValidationError({
+            code: ValidationErrorCode.EmptyTarget,
             details: {},
         }));
     }
     if (!('properties' in schema)) {
-        const { error } = (0, exports.validateProperty)(what, schema);
+        const { error } = validateProperty(what, schema);
         if (error) {
-            return types_1.Result.error(error);
+            return Result.error(error);
         }
-        return types_1.Result.result(what);
+        return Result.result(what);
     }
-    const wholenessError = (0, exports.validateWholeness)(what, schema);
+    const wholenessError = validateWholeness(what, schema);
     if (wholenessError) {
         if (options.throwOnError) {
-            throw new TypeError(types_1.ValidationErrorCode.MissingProperties);
+            throw new TypeError(ValidationErrorCode.MissingProperties);
         }
-        return types_1.Result.error(wholenessError);
+        return Result.error(wholenessError);
     }
     const details = {};
     const resultCopy = {};
     for (const propName in what) {
-        const { error, result: parsed } = (0, exports.validateProperty)(what[propName], schema.properties[propName], {
+        const { error, result: parsed } = validateProperty(what[propName], schema.properties[propName], {
             ...options,
             parentProperty: schema,
         });
         if (error) {
             if (options.throwOnError) {
-                throw new TypeError(types_1.ValidationErrorCode.InvalidProperties);
+                throw new TypeError(ValidationErrorCode.InvalidProperties);
             }
             details[propName] = error;
             continue;
@@ -383,36 +379,32 @@ const validate = (what, schema, options = {}) => {
         }
     }
     if (Object.keys(details).length > 0) {
-        return types_1.Result.error((0, exports.makeValidationError)({
-            code: types_1.ValidationErrorCode.InvalidProperties,
+        return Result.error(makeValidationError({
+            code: ValidationErrorCode.InvalidProperties,
             details,
         }));
     }
-    return types_1.Result.result(resultCopy);
+    return Result.result(resultCopy);
 };
-exports.validate = validate;
-const validateWithRefs = async (what, schema, options = {}) => {
-    const { error: refsError } = await (0, exports.validateRefs)(what, schema, options);
+export const validateWithRefs = async (what, schema, options = {}) => {
+    const { error: refsError } = await validateRefs(what, schema, options);
     if (refsError) {
-        return types_1.Result.error(refsError);
+        return Result.error(refsError);
     }
-    return (0, exports.validate)(what, schema, options);
+    return validate(what, schema, options);
 };
-exports.validateWithRefs = validateWithRefs;
-const validatePropertyWithRefs = async (what, property, options = {}) => {
-    const { error: refsError } = await (0, exports.validateRefs)(what, property, options);
+export const validatePropertyWithRefs = async (what, property, options = {}) => {
+    const { error: refsError } = await validateRefs(what, property, options);
     if (refsError) {
-        return types_1.Result.error(refsError);
+        return Result.error(refsError);
     }
-    return (0, exports.validateProperty)(what, property, options);
+    return validateProperty(what, property, options);
 };
-exports.validatePropertyWithRefs = validatePropertyWithRefs;
-const validator = (schema, options = {}) => {
+export const validator = (schema, options = {}) => {
     return [
         {},
         (what) => {
-            return (0, exports.validate)(what, schema, options);
+            return validate(what, schema, options);
         },
     ];
 };
-exports.validator = validator;

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@aeriajs/validation",
-  "version": "0.0.178",
+  "type": "module",
+  "version": "0.0.180",
   "description": "## Installation",
   "main": "dist/index.js",
-  "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "publishConfig": {
     "access": "public"
@@ -17,8 +17,7 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
+      "default": "./dist/index.js"
     }
   },
   "devDependencies": {
@@ -28,9 +27,9 @@
     "mongodb": "^6.17.0"
   },
   "peerDependencies": {
-    "@aeriajs/common": "^0.0.157",
-    "@aeriajs/entrypoint": "^0.0.163",
-    "@aeriajs/types": "^0.0.135",
+    "@aeriajs/common": "^0.0.158",
+    "@aeriajs/entrypoint": "^0.0.165",
+    "@aeriajs/types": "^0.0.136",
     "mongodb": "^6.17.0"
   },
   "scripts": {
@@ -38,9 +37,6 @@
     "test:typecheck": "tsc -p tsconfig.test.json",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
-    "build": "pnpm build:cjs && pnpm build:esm",
-    "build:cjs": "tsc",
-    "build:esm": "esbuild './src/**/*.ts' --outdir=dist --out-extension:.js=.mjs && pnpm build:esm-transform",
-    "build:esm-transform": "pnpm -w esm-transform $PWD/dist"
+    "build": "tsc"
   }
 }

package/dist/index.mjs

@@ -1,2 +0,0 @@
-"use strict";
-export * from "./validate.mjs";

package/dist/validate.mjs

@@ -1,393 +0,0 @@
-"use strict";
-import { convertConditionToQuery, getMissingProperties } from "@aeriajs/common";
-import { Result, ValidationErrorCode, PropertyValidationErrorCode } from "@aeriajs/types";
-import { getCollection } from "@aeriajs/entrypoint";
-const isValidObjectId = (what) => {
-  return /^[0-9a-f]{24}$/.test(what);
-};
-const getPropertyType = (property) => {
-  if ("type" in property) {
-    if ("format" in property && property.format) {
-      switch (property.format) {
-        case "date":
-        case "date-time":
-          return "datetime";
-        case "objectid":
-          return "object";
-      }
-    }
-    return property.type;
-  }
-  if ("enum" in property) {
-    return typeof property.enum[0];
-  }
-  if ("const" in property) {
-    return typeof property.const;
-  }
-  if ("properties" in property || "additionalProperties" in property || "$ref" in property) {
-    return "object";
-  }
-};
-const makePropertyError = (type, details) => {
-  return {
-    type,
-    details
-  };
-};
-export const makeValidationError = (error) => {
-  return error;
-};
-export const validateProperty = (what, property, options = {}) => {
-  if (!property) {
-    if (options.parentProperty && "additionalProperties" in options.parentProperty) {
-      if (options.parentProperty.additionalProperties === true) {
-        return Result.result(what);
-      }
-      return validateProperty(what, options.parentProperty.additionalProperties);
-    }
-    if (options.tolerateExtraneous) {
-      return Result.result(void 0);
-    }
-    return Result.error(makePropertyError(PropertyValidationErrorCode.Extraneous));
-  }
-  if (what === null || what === void 0) {
-    return Result.result(what);
-  }
-  if ("getter" in property) {
-    return Result.result(void 0);
-  }
-  const expectedType = getPropertyType(property);
-  const actualType = Array.isArray(what) ? "array" : typeof what;
-  if (actualType !== expectedType && !(actualType === "number" && expectedType === "integer")) {
-    if (expectedType === "datetime" && what instanceof Date) {
-      return Result.result(what);
-    }
-    if ("$ref" in property) {
-      switch (typeof what) {
-        case "string": {
-          if (isValidObjectId(what)) {
-            return Result.result(what);
-          }
-          return Result.error(makePropertyError(PropertyValidationErrorCode.Unmatching, {
-            expected: expectedType,
-            got: actualType
-          }));
-        }
-      }
-    }
-    if (options.coerce) {
-      if (expectedType === "number" && typeof what === "string") {
-        const coerced = parseFloat(what);
-        if (!isNaN(coerced)) {
-          return Result.result(coerced);
-        }
-      }
-      if (expectedType === "integer" && typeof what === "string") {
-        const coerced = parseInt(what);
-        if (!isNaN(coerced)) {
-          return Result.result(coerced);
-        }
-      }
-      if (expectedType === "string" && typeof what === "number") {
-        return Result.result(String(what));
-      }
-      if (expectedType === "datetime" && typeof what === "string") {
-        return Result.result(new Date(what));
-      }
-    }
-    if ((options.coerce || options.coerceObjectIds) && options.objectIdConstructor) {
-      if (("$ref" in property || "format" in property && property.format === "objectid") && typeof what === "string") {
-        return Result.result(new options.objectIdConstructor(what));
-      }
-    }
-    return Result.error(makePropertyError(PropertyValidationErrorCode.Unmatching, {
-      expected: expectedType,
-      got: actualType
-    }));
-  }
-  if ("type" in property) {
-    switch (property.type) {
-      case "string": {
-        switch (property.format) {
-          case "objectid": {
-            if (!options.objectIdConstructor) {
-              throw new Error();
-            }
-            if (!(what instanceof options.objectIdConstructor)) {
-              return Result.error(makePropertyError(PropertyValidationErrorCode.StringConstraint, {
-                expected: "objectid",
-                got: "invalid_objectid"
-              }));
-            }
-            break;
-          }
-          default: {
-            if (typeof what !== "string") {
-              return Result.error(makePropertyError(PropertyValidationErrorCode.Unmatching, {
-                expected: expectedType,
-                got: actualType
-              }));
-            }
-            if (typeof property.minLength === "number" && property.minLength > what.length || typeof property.maxLength === "number" && property.maxLength < what.length) {
-              return Result.error(makePropertyError(PropertyValidationErrorCode.StringConstraint, {
-                expected: "string",
-                got: "invalid_string"
-              }));
-            }
-          }
-        }
-        break;
-      }
-      case "integer": {
-        if (!Number.isInteger(what)) {
-          return Result.error(makePropertyError(PropertyValidationErrorCode.NumericConstraint, {
-            expected: "integer",
-            got: "invalid_number"
-          }));
-        }
-      }
-      case "number": {
-        if (typeof what !== "number") {
-          return Result.error(makePropertyError(PropertyValidationErrorCode.Unmatching, {
-            expected: expectedType,
-            got: actualType
-          }));
-        }
-        if (typeof property.maximum === "number" && property.maximum < what || typeof property.minimum === "number" && property.minimum > what || typeof property.exclusiveMaximum === "number" && property.exclusiveMaximum <= what || typeof property.exclusiveMinimum === "number" && property.exclusiveMinimum >= what) {
-          return Result.error(makePropertyError(PropertyValidationErrorCode.NumericConstraint, {
-            expected: "number",
-            got: "invalid_number"
-          }));
-        }
-        break;
-      }
-      case "object": {
-        if ("properties" in property) {
-          return validate(what, property, options);
-        }
-        switch (typeof property.additionalProperties) {
-          case "object":
-            return validate(what, property.additionalProperties, options);
-          case "boolean":
-            return Result.result(what);
-        }
-      }
-      case "array": {
-        if (!Array.isArray(what)) {
-          return Result.error(makePropertyError(PropertyValidationErrorCode.Unmatching, {
-            expected: expectedType,
-            got: actualType
-          }));
-        }
-        if (property.minItems) {
-          if (what.length < property.minItems) {
-            return Result.error(makePropertyError(PropertyValidationErrorCode.MoreItemsExpected));
-          }
-        }
-        if (property.maxItems) {
-          if (what.length > property.maxItems) {
-            return Result.error(makePropertyError(PropertyValidationErrorCode.LessItemsExpected));
-          }
-        }
-        let i = 0;
-        for (const elem of what) {
-          const { error } = validateProperty(elem, property.items, options);
-          if (error) {
-            if ("code" in error) {
-              continue;
-            }
-            error.index = i;
-            return Result.error(error);
-          }
-          i++;
-        }
-      }
-    }
-  } else if ("enum" in property) {
-    if (!property.enum.includes(what)) {
-      return Result.error(makePropertyError(PropertyValidationErrorCode.ExtraneousElement, {
-        expected: property.enum,
-        got: what
-      }));
-    }
-  } else if ("const" in property) {
-    if (what !== property.const) {
-      return Result.error(makePropertyError(PropertyValidationErrorCode.Unmatching, {
-        expected: property.const,
-        got: what
-      }));
-    }
-  }
-  return Result.result(what);
-};
-export const validateRefs = async (what, property, options = {}) => {
-  if ("$ref" in property) {
-    if (options.checkObjectIds) {
-      if (!options.context || !options.objectIdConstructor) {
-        throw new Error();
-      }
-      if (what === null) {
-        return Result.result({});
-      }
-      if (!isValidObjectId(String(what))) {
-        return Result.error(makePropertyError(PropertyValidationErrorCode.Unmatching, {
-          expected: "objectid",
-          got: typeof what
-        }));
-      }
-      let query;
-      if (property.constraints) {
-        query = {
-          $and: [
-            {
-              _id: new options.objectIdConstructor(what)
-            },
-            convertConditionToQuery(property.constraints)
-          ]
-        };
-      } else {
-        query = {
-          _id: new options.objectIdConstructor(what)
-        };
-      }
-      const exists = await options.context.collections[property.$ref].model.findOne(query, {
-        projection: {
-          _id: 1
-        }
-      });
-      if (!exists) {
-        return Result.error(makePropertyError(PropertyValidationErrorCode.ReferenceConstraint, {
-          expected: "objectid",
-          got: "invalid_objectid"
-        }));
-      }
-      return Result.result({});
-    }
-    let description;
-    if (options.descriptions) {
-      description = options.descriptions[property.$ref];
-    } else {
-      const collection = await getCollection(property.$ref);
-      if (!collection) {
-        throw new Error();
-      }
-      description = collection.description;
-    }
-    if (typeof what !== "object") {
-      return Result.error(makePropertyError(PropertyValidationErrorCode.Unmatching, {
-        expected: "object",
-        got: typeof what
-      }));
-    }
-    return validate(what, description, options);
-  } else if ("items" in property) {
-    if (!Array.isArray(what)) {
-      throw new Error();
-    }
-    for (const elem of what) {
-      const { error } = await validateRefs(elem, property.items, options);
-      if (error) {
-        return Result.error(error);
-      }
-    }
-  } else if ("properties" in property) {
-    const details = {};
-    for (const propName in what) {
-      const { error } = await validateRefs(what[propName], property.properties[propName], options);
-      if (error) {
-        details[propName] = error;
-      }
-    }
-    if (Object.keys(details).length > 0) {
-      return Result.error(makeValidationError({
-        code: ValidationErrorCode.InvalidProperties,
-        details
-      }));
-    }
-  }
-  return Result.result({});
-};
-export const validateWholeness = (what, schema) => {
-  const required = schema.required ? schema.required : Object.keys(schema.properties);
-  const missingProps = getMissingProperties(what, schema, required);
-  if (missingProps.length > 0) {
-    return makeValidationError({
-      code: ValidationErrorCode.MissingProperties,
-      details: Object.fromEntries(missingProps.map((error) => [
-        error,
-        {
-          type: "missing"
-        }
-      ]))
-    });
-  }
-};
-export const validate = (what, schema, options = {}) => {
-  if (what === void 0) {
-    return Result.error(makeValidationError({
-      code: ValidationErrorCode.EmptyTarget,
-      details: {}
-    }));
-  }
-  if (!("properties" in schema)) {
-    const { error } = validateProperty(what, schema);
-    if (error) {
-      return Result.error(error);
-    }
-    return Result.result(what);
-  }
-  const wholenessError = validateWholeness(what, schema);
-  if (wholenessError) {
-    if (options.throwOnError) {
-      throw new TypeError(ValidationErrorCode.MissingProperties);
-    }
-    return Result.error(wholenessError);
-  }
-  const details = {};
-  const resultCopy = {};
-  for (const propName in what) {
-    const { error, result: parsed } = validateProperty(what[propName], schema.properties[propName], {
-      ...options,
-      parentProperty: schema
-    });
-    if (error) {
-      if (options.throwOnError) {
-        throw new TypeError(ValidationErrorCode.InvalidProperties);
-      }
-      details[propName] = error;
-      continue;
-    }
-    if (parsed !== void 0) {
-      resultCopy[propName] = parsed;
-    }
-  }
-  if (Object.keys(details).length > 0) {
-    return Result.error(makeValidationError({
-      code: ValidationErrorCode.InvalidProperties,
-      details
-    }));
-  }
-  return Result.result(resultCopy);
-};
-export const validateWithRefs = async (what, schema, options = {}) => {
-  const { error: refsError } = await validateRefs(what, schema, options);
-  if (refsError) {
-    return Result.error(refsError);
-  }
-  return validate(what, schema, options);
-};
-export const validatePropertyWithRefs = async (what, property, options = {}) => {
-  const { error: refsError } = await validateRefs(what, property, options);
-  if (refsError) {
-    return Result.error(refsError);
-  }
-  return validateProperty(what, property, options);
-};
-export const validator = (schema, options = {}) => {
-  return [
-    {},
-    (what) => {
-      return validate(what, schema, options);
-    }
-  ];
-};