@aeriajs/validation 0.0.61 → 0.0.63

package/dist/validate.d.ts

@@ -1,4 +1,5 @@
-import type { Either, JsonSchema, Property, InferSchema, Description, PropertyValidationError, ValidationError } from '@aeriajs/types';
+import type { JsonSchema, Property, InferSchema, Description, PropertyValidationError, ValidationError } from '@aeriajs/types';
+import { Result } from '@aeriajs/common';
 import { ValidationErrorCode } from '@aeriajs/types';
 export type ValidateOptions = {
     extraneous?: string[] | boolean;
@@ -7,7 +8,7 @@ export type ValidateOptions = {
     coerce?: boolean;
 };
 export declare const makeValidationError: <TValidationError extends ValidationError>(error: TValidationError) => TValidationError;
-export declare const validateProperty: <TWhat>(propName: string, what: TWhat, property: Property | undefined, options?: ValidateOptions) => Either<PropertyValidationError | ValidationError, unknown>;
+export declare const validateProperty: <TWhat>(propName: string, what: TWhat, property: Property | undefined, options?: ValidateOptions) => Result.Either<PropertyValidationError | ValidationError, unknown>;
 export declare const validateWholeness: (what: Record<string, any>, schema: Omit<JsonSchema, '$id'>) => {
     code: ValidationErrorCode.MissingProperties;
     errors: {
@@ -16,5 +17,21 @@ export declare const validateWholeness: (what: Record<string, any>, schema: Omit
         };
     };
 } | undefined;
-export declare const validate: <TWhat, const TJsonSchema extends Property | Omit<Description, "$id">>(what: TWhat | undefined, schema: TJsonSchema, options?: ValidateOptions) => import("@aeriajs/types").Left<PropertyValidationError | ValidationError> | import("@aeriajs/types").Right<InferSchema<TJsonSchema>>;
-export declare const validator: <const TJsonSchema extends Property | Omit<Description, "$id">>(schema: TJsonSchema, options?: ValidateOptions) => readonly [InferSchema<TJsonSchema>, <TWhat>(what: TWhat) => import("@aeriajs/types").Left<PropertyValidationError | ValidationError> | import("@aeriajs/types").Right<InferSchema<TJsonSchema>>];
+export declare const validate: <TWhat, const TJsonSchema extends Property | Omit<Description, "$id">>(what: TWhat | undefined, schema: TJsonSchema, options?: ValidateOptions) => {
+    readonly _tag: "Error";
+    readonly error: PropertyValidationError | ValidationError;
+    readonly result: undefined;
+} | {
+    readonly _tag: "Result";
+    readonly error: undefined;
+    readonly result: InferSchema<TJsonSchema>;
+};
+export declare const validator: <const TJsonSchema extends Property | Omit<Description, "$id">>(schema: TJsonSchema, options?: ValidateOptions) => readonly [InferSchema<TJsonSchema>, <TWhat>(what: TWhat) => {
+    readonly _tag: "Error";
+    readonly error: PropertyValidationError | ValidationError;
+    readonly result: undefined;
+} | {
+    readonly _tag: "Result";
+    readonly error: undefined;
+    readonly result: InferSchema<TJsonSchema>;
+}];

package/dist/validate.js

@@ -42,93 +42,92 @@ exports.makeValidationError = makeValidationError;
 const validateProperty = (propName, what, property, options = {}) => {
     const { extraneous, filterOutExtraneous, coerce } = options;
     if (what === undefined) {
-        return (0, common_1.right)(what);
+        return common_1.Result.result(what);
     }
     if (!property) {
         if (extraneous || (Array.isArray(extraneous) && extraneous.includes(propName))) {
             if (filterOutExtraneous) {
-                return (0, common_1.right)(undefined);
+                return common_1.Result.result(undefined);
             }
-            return (0, common_1.right)(what);
+            return common_1.Result.result(what);
         }
-        return (0, common_1.left)(makePropertyError(types_1.PropertyValidationErrorCode.Extraneous, {
+        return common_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.Extraneous, {
             expected: 'undefined',
             got: getValueType(what),
         }));
     }
     if ('getter' in property) {
-        return (0, common_1.right)(undefined);
+        return common_1.Result.result(undefined);
     }
     if ('properties' in property) {
         return (0, exports.validate)(what, property, options);
     }
     if ('const' in property) {
         if (what !== property.const) {
-            return (0, common_1.left)(makePropertyError(types_1.PropertyValidationErrorCode.Unmatching, {
+            return common_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.Unmatching, {
                 expected: property.const,
                 got: what,
             }));
         }
-        return (0, common_1.right)(what);
+        return common_1.Result.result(what);
     }
     const expectedType = getPropertyType(property);
     const actualType = getValueType(what);
     if ('enum' in property && property.enum.length === 0) {
-        return (0, common_1.right)(what);
+        return common_1.Result.result(what);
     }
     if (actualType !== expectedType
         && !('items' in property && actualType === 'array')
         && !(actualType === 'number' && expectedType === 'integer')) {
         if (expectedType === 'datetime' && what instanceof Date) {
-            return (0, common_1.right)(what);
+            return common_1.Result.result(what);
         }
         if (expectedType === 'boolean' && !what) {
-            return (0, common_1.right)(what);
+            return common_1.Result.result(what);
         }
         if ('$ref' in property && typeof what === 'string') {
             if (/^[0-9a-fA-F]{24}$/.test(what)) {
-                return (0, common_1.right)(what);
+                return common_1.Result.result(what);
             }
         }
         if (coerce) {
             if (expectedType === 'number' && typeof what === 'string') {
                 const coerced = parseFloat(what);
                 if (!isNaN(coerced)) {
-                    return (0, common_1.right)(coerced);
+                    return common_1.Result.result(coerced);
                 }
             }
             if (expectedType === 'integer' && typeof what === 'string') {
                 const coerced = parseInt(what);
                 if (!isNaN(coerced)) {
-                    return (0, common_1.right)(coerced);
+                    return common_1.Result.result(coerced);
                 }
             }
             if (expectedType === 'string' && typeof what === 'number') {
-                return (0, common_1.right)(String(what));
+                return common_1.Result.result(String(what));
             }
         }
-        return (0, common_1.left)(makePropertyError(types_1.PropertyValidationErrorCode.Unmatching, {
+        return common_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.Unmatching, {
             expected: expectedType,
             got: actualType,
         }));
     }
     if ('items' in property) {
         if (!Array.isArray(what)) {
-            return (0, common_1.left)(makePropertyError(types_1.PropertyValidationErrorCode.Unmatching, {
+            return common_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.Unmatching, {
                 expected: expectedType,
                 got: actualType,
             }));
         }
         let i = 0;
         for (const elem of what) {
-            const resultEither = (0, exports.validateProperty)(propName, elem, property.items, options);
-            if ((0, common_1.isLeft)(resultEither)) {
-                const result = (0, common_1.unwrapEither)(resultEither);
-                if ('errors' in result) {
+            const { error } = (0, exports.validateProperty)(propName, elem, property.items, options);
+            if (error) {
+                if ('errors' in error) {
                     continue;
                 }
-                result.index = i;
-                return (0, common_1.left)(result);
+                error.index = i;
+                return common_1.Result.error(error);
             }
             i++;
         }
@@ -136,7 +135,7 @@ const validateProperty = (propName, what, property, options = {}) => {
     else if ('type' in property) {
         if (property.type === 'integer') {
             if (!Number.isInteger(what)) {
-                return (0, common_1.left)(makePropertyError(types_1.PropertyValidationErrorCode.NumericConstraint, {
+                return common_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.NumericConstraint, {
                     expected: 'integer',
                     got: 'invalid_number',
                 }));
@@ -144,7 +143,7 @@ const validateProperty = (propName, what, property, options = {}) => {
         }
         if (property.type === 'integer' || property.type === 'number') {
             if (typeof what !== 'number') {
-                return (0, common_1.left)(makePropertyError(types_1.PropertyValidationErrorCode.Unmatching, {
+                return common_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.Unmatching, {
                     expected: expectedType,
                     got: actualType,
                 }));
@@ -153,7 +152,7 @@ const validateProperty = (propName, what, property, options = {}) => {
                 || (property.minimum && property.minimum > what)
                 || (property.exclusiveMaximum && property.exclusiveMaximum <= what)
                 || (property.exclusiveMinimum && property.exclusiveMinimum >= what)) {
-                return (0, common_1.left)(makePropertyError(types_1.PropertyValidationErrorCode.NumericConstraint, {
+                return common_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.NumericConstraint, {
                     expected: 'number',
                     got: 'invalid_number',
                 }));
@@ -162,13 +161,13 @@ const validateProperty = (propName, what, property, options = {}) => {
     }
     else if ('enum' in property) {
         if (!property.enum.includes(what)) {
-            return (0, common_1.left)(makePropertyError(types_1.PropertyValidationErrorCode.ExtraneousElement, {
+            return common_1.Result.error(makePropertyError(types_1.PropertyValidationErrorCode.ExtraneousElement, {
                 expected: property.enum,
                 got: what,
             }));
         }
     }
-    return (0, common_1.right)(what);
+    return common_1.Result.result(what);
 };
 exports.validateProperty = validateProperty;
 const validateWholeness = (what, schema) => {
@@ -192,30 +191,28 @@ const validateWholeness = (what, schema) => {
 exports.validateWholeness = validateWholeness;
 const validate = (what, schema, options = {}) => {
     if (!what) {
-        return (0, common_1.left)((0, exports.makeValidationError)({
+        return common_1.Result.error((0, exports.makeValidationError)({
             code: types_1.ValidationErrorCode.EmptyTarget,
             errors: {},
         }));
     }
     if (!('properties' in schema)) {
-        const resultEither = (0, exports.validateProperty)('', what, schema);
-        return (0, common_1.isLeft)(resultEither)
-            ? resultEither
-            : (0, common_1.right)(what);
+        const { error } = (0, exports.validateProperty)('', what, schema);
+        return error
+            ? common_1.Result.error(error)
+            : common_1.Result.result(what);
     }
     const wholenessError = (0, exports.validateWholeness)(what, schema);
     if (wholenessError) {
-        return (0, common_1.left)(wholenessError);
+        return common_1.Result.error(wholenessError);
     }
     const errors = {};
     const resultCopy = {};
     for (const propName in what) {
-        const resultEither = (0, exports.validateProperty)(propName, what[propName], schema.properties[propName], options);
-        if ((0, common_1.isLeft)(resultEither)) {
-            const result = (0, common_1.unwrapEither)(resultEither);
-            errors[propName] = result;
+        const { error, result: parsed } = (0, exports.validateProperty)(propName, what[propName], schema.properties[propName], options);
+        if (error) {
+            errors[propName] = error;
         }
-        const parsed = (0, common_1.unwrapEither)(resultEither);
         if (parsed !== undefined) {
             resultCopy[propName] = parsed;
         }
@@ -228,12 +225,12 @@ const validate = (what, schema, options = {}) => {
             });
             throw error;
         }
-        return (0, common_1.left)((0, exports.makeValidationError)({
+        return common_1.Result.error((0, exports.makeValidationError)({
             code: types_1.ValidationErrorCode.InvalidProperties,
             errors,
         }));
     }
-    return (0, common_1.right)(resultCopy);
+    return common_1.Result.result(resultCopy);
 };
 exports.validate = validate;
 const validator = (schema, options = {}) => {

package/dist/validate.mjs

@@ -1,5 +1,5 @@
 "use strict";
-import { isLeft, left, right, unwrapEither, getMissingProperties } from "@aeriajs/common";
+import { Result, getMissingProperties } from "@aeriajs/common";
 import { ValidationErrorCode, PropertyValidationErrorCode } from "@aeriajs/types";
 const getValueType = (value) => {
   return Array.isArray(value) ? "array" : typeof value;
@@ -35,98 +35,97 @@ export const makeValidationError = (error) => {
 export const validateProperty = (propName, what, property, options = {}) => {
   const { extraneous, filterOutExtraneous, coerce } = options;
   if (what === void 0) {
-    return right(what);
+    return Result.result(what);
   }
   if (!property) {
     if (extraneous || Array.isArray(extraneous) && extraneous.includes(propName)) {
       if (filterOutExtraneous) {
-        return right(void 0);
+        return Result.result(void 0);
       }
-      return right(what);
+      return Result.result(what);
     }
-    return left(makePropertyError(PropertyValidationErrorCode.Extraneous, {
+    return Result.error(makePropertyError(PropertyValidationErrorCode.Extraneous, {
       expected: "undefined",
       got: getValueType(what)
     }));
   }
   if ("getter" in property) {
-    return right(void 0);
+    return Result.result(void 0);
   }
   if ("properties" in property) {
     return validate(what, property, options);
   }
   if ("const" in property) {
     if (what !== property.const) {
-      return left(makePropertyError(PropertyValidationErrorCode.Unmatching, {
+      return Result.error(makePropertyError(PropertyValidationErrorCode.Unmatching, {
         expected: property.const,
         got: what
       }));
     }
-    return right(what);
+    return Result.result(what);
   }
   const expectedType = getPropertyType(property);
   const actualType = getValueType(what);
   if ("enum" in property && property.enum.length === 0) {
-    return right(what);
+    return Result.result(what);
   }
   if (actualType !== expectedType && !("items" in property && actualType === "array") && !(actualType === "number" && expectedType === "integer")) {
     if (expectedType === "datetime" && what instanceof Date) {
-      return right(what);
+      return Result.result(what);
     }
     if (expectedType === "boolean" && !what) {
-      return right(what);
+      return Result.result(what);
     }
     if ("$ref" in property && typeof what === "string") {
       if (/^[0-9a-fA-F]{24}$/.test(what)) {
-        return right(what);
+        return Result.result(what);
       }
     }
     if (coerce) {
       if (expectedType === "number" && typeof what === "string") {
         const coerced = parseFloat(what);
         if (!isNaN(coerced)) {
-          return right(coerced);
+          return Result.result(coerced);
         }
       }
       if (expectedType === "integer" && typeof what === "string") {
         const coerced = parseInt(what);
         if (!isNaN(coerced)) {
-          return right(coerced);
+          return Result.result(coerced);
         }
       }
       if (expectedType === "string" && typeof what === "number") {
-        return right(String(what));
+        return Result.result(String(what));
       }
     }
-    return left(makePropertyError(PropertyValidationErrorCode.Unmatching, {
+    return Result.error(makePropertyError(PropertyValidationErrorCode.Unmatching, {
       expected: expectedType,
       got: actualType
     }));
   }
   if ("items" in property) {
     if (!Array.isArray(what)) {
-      return left(makePropertyError(PropertyValidationErrorCode.Unmatching, {
+      return Result.error(makePropertyError(PropertyValidationErrorCode.Unmatching, {
         expected: expectedType,
         got: actualType
       }));
     }
     let i = 0;
     for (const elem of what) {
-      const resultEither = validateProperty(propName, elem, property.items, options);
-      if (isLeft(resultEither)) {
-        const result = unwrapEither(resultEither);
-        if ("errors" in result) {
+      const { error } = validateProperty(propName, elem, property.items, options);
+      if (error) {
+        if ("errors" in error) {
           continue;
         }
-        result.index = i;
-        return left(result);
+        error.index = i;
+        return Result.error(error);
       }
       i++;
     }
   } else if ("type" in property) {
     if (property.type === "integer") {
       if (!Number.isInteger(what)) {
-        return left(makePropertyError(PropertyValidationErrorCode.NumericConstraint, {
+        return Result.error(makePropertyError(PropertyValidationErrorCode.NumericConstraint, {
           expected: "integer",
           got: "invalid_number"
         }));
@@ -134,13 +133,13 @@ export const validateProperty = (propName, what, property, options = {}) => {
     }
     if (property.type === "integer" || property.type === "number") {
       if (typeof what !== "number") {
-        return left(makePropertyError(PropertyValidationErrorCode.Unmatching, {
+        return Result.error(makePropertyError(PropertyValidationErrorCode.Unmatching, {
           expected: expectedType,
           got: actualType
         }));
       }
       if (property.maximum && property.maximum < what || property.minimum && property.minimum > what || property.exclusiveMaximum && property.exclusiveMaximum <= what || property.exclusiveMinimum && property.exclusiveMinimum >= what) {
-        return left(makePropertyError(PropertyValidationErrorCode.NumericConstraint, {
+        return Result.error(makePropertyError(PropertyValidationErrorCode.NumericConstraint, {
           expected: "number",
           got: "invalid_number"
         }));
@@ -148,13 +147,13 @@ export const validateProperty = (propName, what, property, options = {}) => {
     }
   } else if ("enum" in property) {
     if (!property.enum.includes(what)) {
-      return left(makePropertyError(PropertyValidationErrorCode.ExtraneousElement, {
+      return Result.error(makePropertyError(PropertyValidationErrorCode.ExtraneousElement, {
         expected: property.enum,
         got: what
       }));
     }
   }
-  return right(what);
+  return Result.result(what);
 };
 export const validateWholeness = (what, schema) => {
   const required = schema.required ? schema.required : Object.keys(schema.properties);
@@ -173,33 +172,31 @@ export const validateWholeness = (what, schema) => {
 };
 export const validate = (what, schema, options = {}) => {
   if (!what) {
-    return left(makeValidationError({
+    return Result.error(makeValidationError({
       code: ValidationErrorCode.EmptyTarget,
       errors: {}
     }));
   }
   if (!("properties" in schema)) {
-    const resultEither = validateProperty("", what, schema);
-    return isLeft(resultEither) ? resultEither : right(what);
+    const { error } = validateProperty("", what, schema);
+    return error ? Result.error(error) : Result.result(what);
   }
   const wholenessError = validateWholeness(what, schema);
   if (wholenessError) {
-    return left(wholenessError);
+    return Result.error(wholenessError);
   }
   const errors = {};
   const resultCopy = {};
   for (const propName in what) {
-    const resultEither = validateProperty(
+    const { error, result: parsed } = validateProperty(
       propName,
       what[propName],
       schema.properties[propName],
       options
     );
-    if (isLeft(resultEither)) {
-      const result = unwrapEither(resultEither);
-      errors[propName] = result;
+    if (error) {
+      errors[propName] = error;
     }
-    const parsed = unwrapEither(resultEither);
     if (parsed !== void 0) {
       resultCopy[propName] = parsed;
     }
@@ -212,12 +209,12 @@ export const validate = (what, schema, options = {}) => {
       });
       throw error;
     }
-    return left(makeValidationError({
+    return Result.error(makeValidationError({
       code: ValidationErrorCode.InvalidProperties,
       errors
     }));
   }
-  return right(resultCopy);
+  return Result.result(resultCopy);
 };
 export const validator = (schema, options = {}) => {
   return [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aeriajs/validation",
-  "version": "0.0.61",
+  "version": "0.0.63",
   "description": "## Installation",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -26,8 +26,8 @@
     "@aeriajs/types": "link:../types"
   },
   "peerDependencies": {
-    "@aeriajs/common": "^0.0.58",
-    "@aeriajs/types": "^0.0.54"
+    "@aeriajs/common": "^0.0.60",
+    "@aeriajs/types": "^0.0.56"
   },
   "scripts": {
     "test": "env TS_NODE_COMPILER_OPTIONS=\"$(cat ../compilerOptions.json)\" mocha -r ts-node/register tests/*.spec.ts",