Updated from version 1.1.0 to 1.2.0

Author: ardalanamini

CHANGELOG.md

@@ -12,9 +12,13 @@
 
 ---
 
-## [next](https://github.com/foxifyjs/schema/releases/tag/next) - _(2018-**-**)_
+## [v1.2.0](https://github.com/foxifyjs/schema/releases/tag/v1.2.0) - _(2018-07-02)_
 
 - :boom: All methods are functions now (`.required` => `.required()`)
+- :boom: All error messages are changed
+- :zap: Made `validate` method in all schema types publicly accessible
+- :zap: Added `details` property to all schema types to make some inside details publicly accessible
+- :zap: Added `unknown` method to object schema type
 - :zap: Added `min` method to object schema type
 - :zap: Added `max` method to object schema type
 - :zap: Added `length` method to object schema type

README.md

@@ -48,11 +48,15 @@ npm i -s @foxify/schema
 const Schema = require("@foxify/schema");
 
 const schema = {
-  username: Schema.string().alphanum().required(),
+  username: Schema.string()
+    .alphanum()
+    .required(),
   name: {
-    first: Schema.string().min(3).required(),
+    first: Schema.string()
+      .min(3)
+      .required(),
     last: Schema.string().min(3),
-  },
+  }, // since "name" has a required field, "name" itself would become required too
   datetime: Schema.date().default(Date.now),
 };
 
@@ -70,7 +74,7 @@ We use [SemVer](http://semver.org) for versioning. For the versions available, s
 
 ## Authors
 
-- **Ardalan Amini** - *Core Maintainer* - [@ardalanamini](https://github.com/ardalanamini)
+- **Ardalan Amini** - _Core Maintainer_ - [@ardalanamini](https://github.com/ardalanamini)
 
 See also the list of [contributors](https://github.com/foxifyjs/schema/contributors) who participated in this project.
 

docs/README.md

@@ -27,6 +27,7 @@ TypeScript ready object schema validation
     - [`.multipliedBy(num: number)`](#multipliedBynum-number)
   - [Object](#Object)
     - [`object(obj: object)`](#objectobj-object)
+    - [`unknown()`](#unknown)
     - [`min(n: number)`](#minn-number)
     - [`max(n: number)`](#maxn-number)
     - [`length(n: number)`](#lengthn-number)
@@ -282,6 +283,24 @@ const schema = {
 };
 ```
 
+##### `unknown()`
+
+Determines that the unknown keys should be included in the resulted object too (without any validation of course)
+
+```typescript
+const schema = {
+  foo: Schema.object({ bar: Schema.number() }).unknown(),
+};
+```
+
+Please note that it won't be necessary if you're not specifying the object keys like the example below:
+
+```typescript
+const schema = {
+  foo: Schema.object(),
+};
+```
+
 ##### `min(n: number)`
 
 Insures that the given object has at least `n` key(s)
@@ -479,9 +498,24 @@ Validates the given value according to the given schema
 ```typescript
 const result = Schema.validate(schema, value);
 /*
- * {
+ * interface {
  *   errors: { [path to the wrong value]: Array<error string> } | null,
  *   value: object,
  * }
  */
 ```
+
+You can also validate any schema type directly like the example below
+
+```typescript
+const result = Schema.number()
+  .min(22)
+  .required()
+  .validate(value);
+/*
+ * interface {
+ *   errors: { [path to the wrong value]: Array<error string> } | null,
+ *   value: number,
+ * }
+ */
+```

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foxify/schema",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "TypeScript schema validation",
   "author": {
     "name": "Ardalan Amini",
@@ -21,7 +21,41 @@
     "javascript",
     "typescript",
     "schema",
-    "validation"
+    "validation",
+    "default",
+    "required",
+    "array",
+    "min",
+    "max",
+    "length",
+    "items",
+    "boolean",
+    "date",
+    "number",
+    "port",
+    "integer",
+    "positive",
+    "negative",
+    "precision",
+    "multipliedBy",
+    "object",
+    "keys",
+    "unknown",
+    "string",
+    "token",
+    "alphanum",
+    "numeral",
+    "ip",
+    "ipv4",
+    "ipv6",
+    "email",
+    "credit",
+    "card",
+    "credit-card",
+    "regex",
+    "enum",
+    "truncate",
+    "replace"
   ],
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

src/Any.ts

@@ -1,117 +1,106 @@
 import assert from "assert";
-import { func, object, string, TYPE } from "./utils";
+import { func, mergeErrors, NULL, TYPE } from "./utils";
 
 const { isFunction } = func;
-const { forEach } = object;
-const { isString } = string;
 
 namespace Type {
-  export type PipelineItem<T> = (
-    value: T,
-    path: string,
-  ) => { value: T; errors: string | { [key: string]: string } };
+  export type Error<T> =
+    | string[]
+    | string
+    | null
+    | (T extends object
+        ? { [key in string | number]: string[] }
+        : T extends any[]
+        ? { [key: string]: string[] }
+        : null);
+
+  export type PipelineItem<T> = (value: T) => { value: T; errors: Error<T> };
+
+  export interface ValidationResult<T> {
+    value: T;
+    errors: Error<T>;
+  }
 
   export interface Options<T> {
     def: () => T | undefined;
     required: boolean;
   }
 }
 
-abstract class Type<T = any> {
+abstract class Type<T = any, O extends object = {}> {
   public static isType = (value: any): value is Type => value instanceof Type;
 
   protected static type: string = TYPE.ANY;
 
-  protected _options: Type.Options<T> = {
+  public details: Type.Options<T> & O = {
     def: () => undefined,
     required: false,
-  };
+  } as Type.Options<T> & O;
 
   protected _pipeline: Array<Type.PipelineItem<T>> = [];
 
   public default(value: T | (() => T)) {
     if (isFunction(value)) {
-      this._options.def = value;
+      this.details.def = value;
 
       return this;
     }
 
     assert(
       !this._base(value),
-      `The given value must be of "${
-        (this.constructor as typeof Type).type
-      }" type`,
+      `Expected value to be ${(this.constructor as typeof Type).type}`,
     );
 
-    this._options.def = () => value;
+    this.details.def = () => value;
 
     return this;
   }
 
   public required(required = true) {
-    this._options.required = required;
+    this.details.required = required;
 
     return this;
   }
 
-  protected _pipe(...items: Array<Type.PipelineItem<T>>) {
-    this._pipeline = this._pipeline.concat(items);
-
-    return this;
-  }
-
-  protected _validate(
-    path: string,
-    value: any,
-  ): { value: T; errors: { [key: string]: string[] } } {
-    const { def, required } = this._options;
+  public validate(value: any): Type.ValidationResult<T> {
+    const { def, required } = this.details;
 
     if (value == null) {
       value = def();
 
       if (value == null) {
         if (required) {
-          return { value, errors: { [path]: ["Must be provided"] } };
+          return {
+            value,
+            errors: ["Expected to be provided"],
+          };
         }
 
-        return { value, errors: {} };
+        return { value, errors: NULL };
       }
     }
 
     const baseError = this._base(value);
-    if (baseError) return { value, errors: { [path]: [baseError] } };
+    if (baseError) return { value, errors: [baseError] };
 
-    const errors = this._pipeline.reduce(
+    return this._pipeline.reduce(
       (prev, tester) => {
-        const result = tester(value, path);
-
-        value = result.value;
-
-        let errs = result.errors;
+        const result = tester(prev.value);
 
-        if (isString(errs)) errs = { [path]: errs };
+        prev.value = result.value;
 
-        forEach(errs, (err: any, key) => {
-          if (!Array.isArray(err)) err = [err];
-
-          if (prev[key]) {
-            prev[key] = prev[key].concat(err);
-
-            return;
-          }
-
-          prev[key] = err;
-        });
+        prev.errors = mergeErrors<T>(prev.errors, result.errors);
 
         return prev;
       },
-      {} as { [key: string]: string[] },
+      { value, errors: NULL as Type.ValidationResult<T>["errors"] },
     );
+  }
 
-    return {
-      errors,
-      value,
-    };
+  protected _pipe(...items: Array<Type.PipelineItem<T>>) {
+    this._pipeline = this._pipeline.concat(items);
+
+    return this;
   }
 
   protected abstract _base(value: any): string | null;