@aeriajs/validation 0.0.162 → 0.0.163

package/dist/validate.d.ts

@@ -1,4 +1,5 @@
-import type { JsonSchema, Property, InferSchema, Description, PropertyValidationError, ValidationError } from '@aeriajs/types';
+import type { JsonSchema, Property, InferSchema, Description, PropertyValidationError, ValidationError, CollectionModel } from '@aeriajs/types';
+import type { ObjectId } from 'mongodb';
 import { Result } from '@aeriajs/types';
 export type ValidateOptions = {
     tolerateExtraneous?: boolean;
@@ -7,10 +8,16 @@ export type ValidateOptions = {
     coerce?: boolean;
     parentProperty?: Property | Description;
     descriptions?: Record<string, Description>;
+    objectIdConstructor?: new (arg: unknown) => ObjectId;
+    context?: {
+        collections: Record<string, {
+            model: CollectionModel<Description>;
+        }>;
+    };
 };
 export declare const makeValidationError: <TValidationError extends ValidationError>(error: TValidationError) => TValidationError;
 export declare const validateProperty: <TWhat>(what: TWhat, property: Property | undefined, options?: ValidateOptions) => Result.Either<PropertyValidationError | ValidationError, unknown>;
-export declare const validateRefs: <TWhat>(what: TWhat, property: Property | Description | undefined, options?: ValidateOptions) => Promise<Result.Either<PropertyValidationError | ValidationError, unknown>>;
+export declare const validateRefs: <TWhat>(what: TWhat, property: Property | Description, options?: ValidateOptions) => Promise<Result.Either<PropertyValidationError | ValidationError, unknown>>;
 export declare const validateWholeness: (what: Record<string, unknown>, schema: Omit<JsonSchema, "$id">) => {
     code: "MISSING_PROPERTIES";
     details: {
@@ -37,6 +44,7 @@ export declare const validateWithRefs: <TWhat, const TJsonSchema extends Propert
     readonly error: undefined;
     readonly result: InferSchema<TJsonSchema, {}>;
 }>;
+export declare const validatePropertyWithRefs: <TWhat>(what: TWhat | undefined, property: Property, options?: ValidateOptions) => Promise<Result.Either<PropertyValidationError | ValidationError, unknown>>;
 export declare const validator: <const TJsonSchema extends Property | Description>(schema: TJsonSchema, options?: ValidateOptions) => readonly [InferSchema<TJsonSchema>, <TWhat>(what: TWhat) => {
     readonly _tag: "Error";
     readonly error: PropertyValidationError | ValidationError;

package/dist/validate.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validator = exports.validateWithRefs = exports.validate = exports.validateWholeness = exports.validateRefs = exports.validateProperty = exports.makeValidationError = void 0;
+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");
@@ -212,53 +212,93 @@ const validateProperty = (what, property, options = {}) => {
 };
 exports.validateProperty = validateProperty;
 const validateRefs = async (what, property, options = {}) => {
-    if (property) {
-        if ('$ref' in property) {
-            let description;
-            if (options.descriptions) {
-                description = options.descriptions[property.$ref];
+    if ('$ref' in property) {
+        if (options.checkObjectIds) {
+            if (!options.context || !options.objectIdConstructor) {
+                throw new Error;
             }
-            else {
-                const collection = await (0, entrypoint_1.getCollection)(property.$ref);
-                if (!collection) {
-                    throw new Error;
-                }
-                description = collection.description;
+            if (what === null) {
+                return types_1.Result.result({});
             }
-            if (typeof what !== 'object') {
+            if (!isValidObjectId(String(what))) {
                 return types_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.Unmatching, {
-                    expected: 'object',
+                    expected: 'objectid',
                     got: typeof what,
                 }));
             }
-            return (0, exports.validate)(what, description, options);
+            let query;
+            if (property.constraints) {
+                query = {
+                    $and: [
+                        {
+                            _id: new options.objectIdConstructor(what),
+                        },
+                        (0, common_1.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 types_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.ReferenceConstraint, {
+                    expected: 'objectid',
+                    got: 'invalid_objectid',
+                }));
+            }
+            return types_1.Result.result({});
+        }
+        let description;
+        if (options.descriptions) {
+            description = options.descriptions[property.$ref];
         }
-        else if ('items' in property) {
-            if (!Array.isArray(what)) {
+        else {
+            const collection = await (0, entrypoint_1.getCollection)(property.$ref);
+            if (!collection) {
                 throw new Error;
             }
-            for (const elem of what) {
-                const { error } = await (0, exports.validateRefs)(elem, property.items, options);
-                if (error) {
-                    return types_1.Result.error(error);
-                }
-            }
+            description = collection.description;
         }
-        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 (error) {
-                    details[propName] = error;
-                }
+        if (typeof what !== 'object') {
+            return types_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.Unmatching, {
+                expected: 'object',
+                got: typeof what,
+            }));
+        }
+        return (0, exports.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);
+            if (error) {
+                return types_1.Result.error(error);
             }
-            if (Object.keys(details).length > 0) {
-                return types_1.Result.error((0, exports.makeValidationError)({
-                    code: types_1.ValidationErrorCode.InvalidProperties,
-                    details,
-                }));
+        }
+    }
+    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 (error) {
+                details[propName] = error;
             }
         }
+        if (Object.keys(details).length > 0) {
+            return types_1.Result.error((0, exports.makeValidationError)({
+                code: types_1.ValidationErrorCode.InvalidProperties,
+                details,
+            }));
+        }
     }
     return types_1.Result.result({});
 };
@@ -337,6 +377,14 @@ const validateWithRefs = async (what, schema, options = {}) => {
     return (0, exports.validate)(what, schema, options);
 };
 exports.validateWithRefs = validateWithRefs;
+const validatePropertyWithRefs = async (what, property, options = {}) => {
+    const { error: refsError } = await (0, exports.validateRefs)(what, property, options);
+    if (refsError) {
+        return types_1.Result.error(refsError);
+    }
+    return (0, exports.validateProperty)(what, property, options);
+};
+exports.validatePropertyWithRefs = validatePropertyWithRefs;
 const validator = (schema, options = {}) => {
     return [
         {},

package/dist/validate.mjs

@@ -1,5 +1,5 @@
 "use strict";
-import { getMissingProperties } from "@aeriajs/common";
+import { convertConditionToQuery, getMissingProperties } from "@aeriajs/common";
 import { Result, ValidationErrorCode, PropertyValidationErrorCode } from "@aeriajs/types";
 import { getCollection } from "@aeriajs/entrypoint";
 const isValidObjectId = (what) => {
@@ -198,50 +198,89 @@ export const validateProperty = (what, property, options = {}) => {
   return Result.result(what);
 };
 export const validateRefs = async (what, property, options = {}) => {
-  if (property) {
-    if ("$ref" in property) {
-      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 ("$ref" in property) {
+    if (options.checkObjectIds) {
+      if (!options.context || !options.objectIdConstructor) {
+        throw new Error();
       }
-      if (typeof what !== "object") {
+      if (what === null) {
+        return Result.result({});
+      }
+      if (!isValidObjectId(String(what))) {
         return Result.error(makePropertyError(PropertyValidationErrorCode.Unmatching, {
-          expected: "object",
+          expected: "objectid",
           got: typeof what
         }));
       }
-      return validate(what, description, options);
-    } else if ("items" in property) {
-      if (!Array.isArray(what)) {
-        throw new Error();
+      let query;
+      if (property.constraints) {
+        query = {
+          $and: [
+            {
+              _id: new options.objectIdConstructor(what)
+            },
+            convertConditionToQuery(property.constraints)
+          ]
+        };
+      } else {
+        query = {
+          _id: new options.objectIdConstructor(what)
+        };
       }
-      for (const elem of what) {
-        const { error } = await validateRefs(elem, property.items, options);
-        if (error) {
-          return Result.error(error);
+      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"
+        }));
       }
-    } 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;
-        }
+      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();
       }
-      if (Object.keys(details).length > 0) {
-        return Result.error(makeValidationError({
-          code: ValidationErrorCode.InvalidProperties,
-          details
-        }));
+      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({});
 };
@@ -314,6 +353,13 @@ export const validateWithRefs = async (what, schema, options = {}) => {
   }
   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 [
     {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aeriajs/validation",
-  "version": "0.0.162",
+  "version": "0.0.163",
   "description": "## Installation",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -24,13 +24,14 @@
   "devDependencies": {
     "@aeriajs/common": "link:../common",
     "@aeriajs/entrypoint": "link:../entrypoint",
-    "@aeriajs/types": "link:../types"
+    "@aeriajs/types": "link:../types",
+    "mongodb": "^6.16.0"
   },
   "peerDependencies": {
-    "@aeriajs/common": "^0.0.144",
-    "@aeriajs/entrypoint": "^0.0.149",
-    "@aeriajs/types": "^0.0.126",
-    "mongodb": "^6.5.0"
+    "@aeriajs/common": "^0.0.145",
+    "@aeriajs/entrypoint": "^0.0.150",
+    "@aeriajs/types": "^0.0.127",
+    "mongodb": "^6.16.0"
   },
   "scripts": {
     "test": "vitest run",