Changes package version to 0.5.1

jalik · jalik · commit d7e662273db0 · 2018-02-13T15:15:23.000-10:00
Makes `type` field option optional
Updates README
diff --git a/README.md b/README.md
@@ -455,6 +455,9 @@ catch (err) {
 
 ## Changelog
 
+### v0.5.1
+- Makes `type` field option optional
+
 ### v0.5.0
 - Adds method `SchemaField.getPrepareFunction()`
 - Adds field option `prepare` to execute a function on the field value before `clean` and `check` functions
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "jk-schema",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Validates objects using schemas",
   "license": "MIT",
   "keywords": [
diff --git a/src/index.js b/src/index.js
@@ -22,15 +22,15 @@
  * SOFTWARE.
  */
 
-import RegExp from "./regex";
-import Utils from "./utils";
+import regExp from "./regex";
+import utils from "./utils";
 import {Schema} from "./schema";
 import {SchemaError} from "./schema-error";
 import {SchemaField} from "./schema-field";
 
 export default {
-    Utils,
-    RegExp: RegExp,
+    Utils: utils,
+    RegExp: regExp,
     Schema: Schema,
     SchemaError: SchemaError,
     SchemaField: SchemaField
diff --git a/src/schema-field.js b/src/schema-field.js
@@ -22,7 +22,7 @@
  * SOFTWARE.
  */
 
-import SchemaUtils from "./utils";
+import utils from "./utils";
 import {Schema} from "./schema";
 import {SchemaError} from "./schema-error";
 
@@ -55,7 +55,7 @@ export class SchemaField {
 
     constructor(fieldName, props) {
         // Default properties
-        props = SchemaUtils.extend({
+        props = utils.extend({
             allowed: undefined,
             check: undefined,
             clean: undefined,
@@ -84,7 +84,7 @@ export class SchemaField {
         // Check field properties
         for (let prop in props) {
             if (props.hasOwnProperty(prop)) {
-                if (!SchemaUtils.contains(fieldProperties, prop)) {
+                if (!utils.contains(fieldProperties, prop)) {
                     console.warn(`Unknown schema field property "${fieldName}.${prop}"`);
                 }
                 // Assign property
@@ -93,19 +93,18 @@ export class SchemaField {
         }
 
         // Check field type
-        if (typeof props.type === "undefined" || props.type === null) {
-            throw new TypeError(`${fieldName}.type is missing`);
-        }
-        else if (props.type instanceof Array) {
-            const arrayType = props.type[0];
+        if (typeof props.type !== "undefined" && props.type !== null) {
+            if (props.type instanceof Array) {
+                const arrayType = props.type[0];
 
-            // Check that array type is a function or class
-            if (typeof arrayType !== "function" && typeof arrayType !== "object") {
-                throw new TypeError(`${fieldName}.type[] must contain a class or a function`);
+                // Check that array type is a function or class
+                if (typeof arrayType !== "function" && typeof arrayType !== "object") {
+                    throw new TypeError(`${fieldName}.type[] must contain a class or a function`);
+                }
+            }
+            else if (!utils.contains(["function", "object"], typeof props.type)) {
+                throw new TypeError(`${fieldName}.type = "${props.type}" is not a valid type`);
             }
-        }
-        else if (!SchemaUtils.contains(["function", "object"], typeof props.type)) {
-            throw new TypeError(`${fieldName}.type = "${props.type}" is not a valid type`);
         }
 
         // Check allowed values
@@ -124,7 +123,7 @@ export class SchemaField {
         }
 
         // Check number decimal
-        if (typeof props.decimal !== "undefined" && !SchemaUtils.contains(["function", "boolean"], typeof props.decimal)) {
+        if (typeof props.decimal !== "undefined" && !utils.contains(["function", "boolean"], typeof props.decimal)) {
             throw new TypeError(`${fieldName}.decimal must be a boolean or function`);
         }
 
@@ -134,7 +133,7 @@ export class SchemaField {
         }
 
         // Set default label if missing
-        if (typeof props.label !== "undefined" && !SchemaUtils.contains(["function", "string"], typeof props.label)) {
+        if (typeof props.label !== "undefined" && !utils.contains(["function", "string"], typeof props.label)) {
             throw new TypeError(`${fieldName}.label must be a string or function`);
         }
 
@@ -144,33 +143,33 @@ export class SchemaField {
                 if (props.length.length > 2) {
                     throw new RangeError(`${fieldName}.length must only have 2 values [min, max]`);
                 }
-            } else if (!SchemaUtils.contains(["function", "number"], typeof props.length)) {
+            } else if (!utils.contains(["function", "number"], typeof props.length)) {
                 throw new TypeError(`${fieldName}.length must be a function, a number or an array[min, max]`);
             }
         }
 
         // Check max value
-        if (typeof props.max !== "undefined" && !SchemaUtils.contains(["function", "number", "string"], typeof props.max) && !(props.max instanceof Date)) {
+        if (typeof props.max !== "undefined" && !utils.contains(["function", "number", "string"], typeof props.max) && !(props.max instanceof Date)) {
             throw new TypeError(`${fieldName}.max must be a date, number, string or function`);
         }
 
         // Check max words
-        if (typeof props.maxWords !== "undefined" && !SchemaUtils.contains(["function", "number"], typeof props.maxWords)) {
+        if (typeof props.maxWords !== "undefined" && !utils.contains(["function", "number"], typeof props.maxWords)) {
             throw new TypeError(`${fieldName}.maxWords must be a number or function`);
         }
 
         // Check min value
-        if (typeof props.min !== "undefined" && !SchemaUtils.contains(["function", "number", "string"], typeof props.min) && !(props.min instanceof Date)) {
+        if (typeof props.min !== "undefined" && !utils.contains(["function", "number", "string"], typeof props.min) && !(props.min instanceof Date)) {
             throw new TypeError(`${fieldName}.min must be a date, number, string or function`);
         }
 
         // Check min words
-        if (typeof props.minWords !== "undefined" && !SchemaUtils.contains(["function", "number"], typeof props.minWords)) {
+        if (typeof props.minWords !== "undefined" && !utils.contains(["function", "number"], typeof props.minWords)) {
             throw new TypeError(`${fieldName}.minWords must be a number or function`);
         }
 
         // Check if field is nullable
-        if (typeof props.nullable !== "undefined" && !SchemaUtils.contains(["function", "boolean"], typeof props.nullable)) {
+        if (typeof props.nullable !== "undefined" && !utils.contains(["function", "boolean"], typeof props.nullable)) {
             throw new TypeError(`${fieldName}.nullable must be a boolean or function`);
         }
 
@@ -180,12 +179,12 @@ export class SchemaField {
         }
 
         // Check regular expression
-        if (typeof props.regEx !== "undefined" && !SchemaUtils.contains(["function"], typeof props.regEx) && !(props.regEx instanceof RegExp)) {
+        if (typeof props.regEx !== "undefined" && !utils.contains(["function"], typeof props.regEx) && !(props.regEx instanceof RegExp)) {
             throw new TypeError(`${fieldName}.regEx must be a regular expression or function`);
         }
 
         // Check required
-        if (typeof props.required !== "undefined" && !SchemaUtils.contains(["function", "boolean"], typeof props.required)) {
+        if (typeof props.required !== "undefined" && !utils.contains(["function", "boolean"], typeof props.required)) {
             throw new TypeError(`${fieldName}.required must be a boolean or function`);
         }
     }
@@ -562,10 +561,9 @@ export class SchemaField {
      */
     validate(value, options) {
         const props = this.properties;
-        const type = props.type;
 
         // Default options
-        options = SchemaUtils.extend({
+        options = utils.extend({
             context: {[this.name]: value}
         }, options);
 
@@ -613,7 +611,7 @@ export class SchemaField {
         }
 
         // Check type
-        switch (type) {
+        switch (props.type) {
             case Array:
                 if (!(value instanceof Array)) {
                     this.throwFieldTypeError(label, "array");
@@ -668,10 +666,10 @@ export class SchemaField {
                 break;
 
             default:
-                if (type instanceof Schema) {
-                    type.validate(value, options);
+                if (props.type instanceof Schema) {
+                    props.type.validate(value, options);
                 }
-                else if (type instanceof Array) {
+                else if (props.type instanceof Array) {
                     // Check that value is an array
                     if (!(value instanceof Array)) {
                         this.throwFieldTypeError(label, "array");
@@ -680,7 +678,7 @@ export class SchemaField {
                     else if (value.length === 0 && !isRequired) {
                         return value;
                     }
-                    const arrayType = type[0];
+                    const arrayType = props.type[0];
 
                     // Validate array items
                     if (arrayType instanceof Schema) {
@@ -741,9 +739,9 @@ export class SchemaField {
                         }
                     }
                 }
-                else if (typeof type === "function") {
+                else if (typeof props.type === "function") {
                     // Check if value is an instance of the function
-                    if (!(value instanceof type)) {
+                    if (!(value instanceof props.type)) {
                         this.throwFieldInstanceError(label);
                     }
                 }
@@ -758,12 +756,12 @@ export class SchemaField {
 
             if (value instanceof Array) {
                 for (let i = 0; i < value.length; i += 1) {
-                    if (!SchemaUtils.contains(allowed, value[i])) {
+                    if (!utils.contains(allowed, value[i])) {
                         this.throwFieldBadValueError(label);
                     }
                 }
             }
-            else if (!SchemaUtils.contains(allowed, value)) {
+            else if (!utils.contains(allowed, value)) {
                 this.throwFieldBadValueError(label);
             }
         }
@@ -773,12 +771,12 @@ export class SchemaField {
 
             if (value instanceof Array) {
                 for (let i = 0; i < value.length; i += 1) {
-                    if (SchemaUtils.contains(denied, value[i])) {
+                    if (utils.contains(denied, value[i])) {
                         this.throwFieldDeniedValueError(label);
                     }
                 }
             }
-            else if (SchemaUtils.contains(denied, value)) {
+            else if (utils.contains(denied, value)) {
                 this.throwFieldDeniedValueError(label);
             }
         }
diff --git a/src/schema.js b/src/schema.js
@@ -22,7 +22,7 @@
  * SOFTWARE.
  */
 
-import SchemaUtils from "./utils";
+import utils from "./utils";
 import {SchemaError} from "./schema-error";
 import {SchemaField} from "./schema-field";
 
@@ -56,7 +56,7 @@ export class Schema {
      */
     clean(obj, options) {
         // Default options
-        options = SchemaUtils.extend({
+        options = utils.extend({
             removeUnknown: true
         }, options);
 
@@ -109,7 +109,7 @@ export class Schema {
                 fieldProperties[fieldName] = schemaFields[fieldName].getProperties();
             }
         }
-        return new Schema(SchemaUtils.extend({}, fieldProperties, fields));
+        return new Schema(utils.extend({}, fieldProperties, fields));
     }
 
     /**
@@ -260,7 +260,7 @@ export class Schema {
             if (fields.hasOwnProperty(fieldName)) {
                 const props = fields[fieldName];
                 const field = schemaFields[fieldName].getProperties() || {};
-                this.addField(fieldName, SchemaUtils.extend({}, field, props));
+                this.addField(fieldName, utils.extend({}, field, props));
             }
         }
         return this;
@@ -273,7 +273,7 @@ export class Schema {
      */
     validate(obj, options) {
         // Default options
-        options = SchemaUtils.extend({
+        options = utils.extend({
             clean: true,
             ignoreMissing: false,
             ignoreUnknown: false,

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "jk-schema",`
`3`		`- "version": "0.5.0",`
	`3`	`+ "version": "0.5.1",`
`4`	`4`	`"description": "Validates objects using schemas",`
`5`	`5`	`"license": "MIT",`
`6`	`6`	`"keywords": [`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@`
`22`	`22`	`* SOFTWARE.`
`23`	`23`	`*/`
`24`	`24`
`25`		`-import SchemaUtils from "./utils";`
	`25`	`+import utils from "./utils";`
`26`	`26`	`import {Schema} from "./schema";`
`27`	`27`	`import {SchemaError} from "./schema-error";`
`28`	`28`
`@@ -55,7 +55,7 @@ export class SchemaField {`
`55`	`55`
`56`	`56`	`constructor(fieldName, props) {`
`57`	`57`	`// Default properties`
`58`		`- props = SchemaUtils.extend({`
	`58`	`+ props = utils.extend({`
`59`	`59`	`allowed: undefined,`
`60`	`60`	`check: undefined,`
`61`	`61`	`clean: undefined,`
`@@ -84,7 +84,7 @@ export class SchemaField {`
`84`	`84`	`// Check field properties`
`85`	`85`	`for (let prop in props) {`
`86`	`86`	`if (props.hasOwnProperty(prop)) {`
`87`		`- if (!SchemaUtils.contains(fieldProperties, prop)) {`
	`87`	`+ if (!utils.contains(fieldProperties, prop)) {`
`88`	`88`	console.warn(`Unknown schema field property "${fieldName}.${prop}"`);
`89`	`89`	`}`
`90`	`90`	`// Assign property`
`@@ -93,19 +93,18 @@ export class SchemaField {`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`// Check field type`
`96`		`- if (typeof props.type === "undefined" \|\| props.type === null) {`
`97`		- throw new TypeError(`${fieldName}.type is missing`);
`98`		`- }`
`99`		`- else if (props.type instanceof Array) {`
`100`		`- const arrayType = props.type[0];`
	`96`	`+ if (typeof props.type !== "undefined" && props.type !== null) {`
	`97`	`+ if (props.type instanceof Array) {`
	`98`	`+ const arrayType = props.type[0];`
`101`	`99`
`102`		`- // Check that array type is a function or class`
`103`		`- if (typeof arrayType !== "function" && typeof arrayType !== "object") {`
`104`		- throw new TypeError(`${fieldName}.type[] must contain a class or a function`);
	`100`	`+ // Check that array type is a function or class`
	`101`	`+ if (typeof arrayType !== "function" && typeof arrayType !== "object") {`
	`102`	+ throw new TypeError(`${fieldName}.type[] must contain a class or a function`);
	`103`	`+ }`
	`104`	`+ }`
	`105`	`+ else if (!utils.contains(["function", "object"], typeof props.type)) {`
	`106`	+ throw new TypeError(`${fieldName}.type = "${props.type}" is not a valid type`);
`105`	`107`	`}`
`106`		`- }`
`107`		`- else if (!SchemaUtils.contains(["function", "object"], typeof props.type)) {`
`108`		- throw new TypeError(`${fieldName}.type = "${props.type}" is not a valid type`);
`109`	`108`	`}`
`110`	`109`
`111`	`110`	`// Check allowed values`
`@@ -124,7 +123,7 @@ export class SchemaField {`
`124`	`123`	`}`
`125`	`124`
`126`	`125`	`// Check number decimal`
`127`		`- if (typeof props.decimal !== "undefined" && !SchemaUtils.contains(["function", "boolean"], typeof props.decimal)) {`
	`126`	`+ if (typeof props.decimal !== "undefined" && !utils.contains(["function", "boolean"], typeof props.decimal)) {`
`128`	`127`	throw new TypeError(`${fieldName}.decimal must be a boolean or function`);
`129`	`128`	`}`
`130`	`129`
`@@ -134,7 +133,7 @@ export class SchemaField {`
`134`	`133`	`}`
`135`	`134`
`136`	`135`	`// Set default label if missing`
`137`		`- if (typeof props.label !== "undefined" && !SchemaUtils.contains(["function", "string"], typeof props.label)) {`
	`136`	`+ if (typeof props.label !== "undefined" && !utils.contains(["function", "string"], typeof props.label)) {`
`138`	`137`	throw new TypeError(`${fieldName}.label must be a string or function`);
`139`	`138`	`}`
`140`	`139`
`@@ -144,33 +143,33 @@ export class SchemaField {`
`144`	`143`	`if (props.length.length > 2) {`
`145`	`144`	throw new RangeError(`${fieldName}.length must only have 2 values [min, max]`);
`146`	`145`	`}`
`147`		`- } else if (!SchemaUtils.contains(["function", "number"], typeof props.length)) {`
	`146`	`+ } else if (!utils.contains(["function", "number"], typeof props.length)) {`
`148`	`147`	throw new TypeError(`${fieldName}.length must be a function, a number or an array[min, max]`);
`149`	`148`	`}`
`150`	`149`	`}`
`151`	`150`
`152`	`151`	`// Check max value`
`153`		`- if (typeof props.max !== "undefined" && !SchemaUtils.contains(["function", "number", "string"], typeof props.max) && !(props.max instanceof Date)) {`
	`152`	`+ if (typeof props.max !== "undefined" && !utils.contains(["function", "number", "string"], typeof props.max) && !(props.max instanceof Date)) {`
`154`	`153`	throw new TypeError(`${fieldName}.max must be a date, number, string or function`);
`155`	`154`	`}`
`156`	`155`
`157`	`156`	`// Check max words`
`158`		`- if (typeof props.maxWords !== "undefined" && !SchemaUtils.contains(["function", "number"], typeof props.maxWords)) {`
	`157`	`+ if (typeof props.maxWords !== "undefined" && !utils.contains(["function", "number"], typeof props.maxWords)) {`
`159`	`158`	throw new TypeError(`${fieldName}.maxWords must be a number or function`);
`160`	`159`	`}`
`161`	`160`
`162`	`161`	`// Check min value`
`163`		`- if (typeof props.min !== "undefined" && !SchemaUtils.contains(["function", "number", "string"], typeof props.min) && !(props.min instanceof Date)) {`
	`162`	`+ if (typeof props.min !== "undefined" && !utils.contains(["function", "number", "string"], typeof props.min) && !(props.min instanceof Date)) {`
`164`	`163`	throw new TypeError(`${fieldName}.min must be a date, number, string or function`);
`165`	`164`	`}`
`166`	`165`
`167`	`166`	`// Check min words`
`168`		`- if (typeof props.minWords !== "undefined" && !SchemaUtils.contains(["function", "number"], typeof props.minWords)) {`
	`167`	`+ if (typeof props.minWords !== "undefined" && !utils.contains(["function", "number"], typeof props.minWords)) {`
`169`	`168`	throw new TypeError(`${fieldName}.minWords must be a number or function`);
`170`	`169`	`}`
`171`	`170`
`172`	`171`	`// Check if field is nullable`
`173`		`- if (typeof props.nullable !== "undefined" && !SchemaUtils.contains(["function", "boolean"], typeof props.nullable)) {`
	`172`	`+ if (typeof props.nullable !== "undefined" && !utils.contains(["function", "boolean"], typeof props.nullable)) {`
`174`	`173`	throw new TypeError(`${fieldName}.nullable must be a boolean or function`);
`175`	`174`	`}`
`176`	`175`
`@@ -180,12 +179,12 @@ export class SchemaField {`
`180`	`179`	`}`
`181`	`180`
`182`	`181`	`// Check regular expression`
`183`		`- if (typeof props.regEx !== "undefined" && !SchemaUtils.contains(["function"], typeof props.regEx) && !(props.regEx instanceof RegExp)) {`
	`182`	`+ if (typeof props.regEx !== "undefined" && !utils.contains(["function"], typeof props.regEx) && !(props.regEx instanceof RegExp)) {`
`184`	`183`	throw new TypeError(`${fieldName}.regEx must be a regular expression or function`);
`185`	`184`	`}`
`186`	`185`
`187`	`186`	`// Check required`
`188`		`- if (typeof props.required !== "undefined" && !SchemaUtils.contains(["function", "boolean"], typeof props.required)) {`
	`187`	`+ if (typeof props.required !== "undefined" && !utils.contains(["function", "boolean"], typeof props.required)) {`
`189`	`188`	throw new TypeError(`${fieldName}.required must be a boolean or function`);
`190`	`189`	`}`
`191`	`190`	`}`
`@@ -562,10 +561,9 @@ export class SchemaField {`
`562`	`561`	`*/`
`563`	`562`	`validate(value, options) {`
`564`	`563`	`const props = this.properties;`
`565`		`- const type = props.type;`
`566`	`564`
`567`	`565`	`// Default options`
`568`		`- options = SchemaUtils.extend({`
	`566`	`+ options = utils.extend({`
`569`	`567`	`context: {[this.name]: value}`
`570`	`568`	`}, options);`
`571`	`569`
`@@ -613,7 +611,7 @@ export class SchemaField {`
`613`	`611`	`}`
`614`	`612`
`615`	`613`	`// Check type`
`616`		`- switch (type) {`
	`614`	`+ switch (props.type) {`
`617`	`615`	`case Array:`
`618`	`616`	`if (!(value instanceof Array)) {`
`619`	`617`	`this.throwFieldTypeError(label, "array");`
`@@ -668,10 +666,10 @@ export class SchemaField {`
`668`	`666`	`break;`
`669`	`667`
`670`	`668`	`default:`
`671`		`- if (type instanceof Schema) {`
`672`		`- type.validate(value, options);`
	`669`	`+ if (props.type instanceof Schema) {`
	`670`	`+ props.type.validate(value, options);`
`673`	`671`	`}`
`674`		`- else if (type instanceof Array) {`
	`672`	`+ else if (props.type instanceof Array) {`
`675`	`673`	`// Check that value is an array`
`676`	`674`	`if (!(value instanceof Array)) {`
`677`	`675`	`this.throwFieldTypeError(label, "array");`
`@@ -680,7 +678,7 @@ export class SchemaField {`
`680`	`678`	`else if (value.length === 0 && !isRequired) {`
`681`	`679`	`return value;`
`682`	`680`	`}`
`683`		`- const arrayType = type[0];`
	`681`	`+ const arrayType = props.type[0];`
`684`	`682`
`685`	`683`	`// Validate array items`
`686`	`684`	`if (arrayType instanceof Schema) {`
`@@ -741,9 +739,9 @@ export class SchemaField {`
`741`	`739`	`}`
`742`	`740`	`}`
`743`	`741`	`}`
`744`		`- else if (typeof type === "function") {`
	`742`	`+ else if (typeof props.type === "function") {`
`745`	`743`	`// Check if value is an instance of the function`
`746`		`- if (!(value instanceof type)) {`
	`744`	`+ if (!(value instanceof props.type)) {`
`747`	`745`	`this.throwFieldInstanceError(label);`
`748`	`746`	`}`
`749`	`747`	`}`
`@@ -758,12 +756,12 @@ export class SchemaField {`
`758`	`756`
`759`	`757`	`if (value instanceof Array) {`
`760`	`758`	`for (let i = 0; i < value.length; i += 1) {`
`761`		`- if (!SchemaUtils.contains(allowed, value[i])) {`
	`759`	`+ if (!utils.contains(allowed, value[i])) {`
`762`	`760`	`this.throwFieldBadValueError(label);`
`763`	`761`	`}`
`764`	`762`	`}`
`765`	`763`	`}`
`766`		`- else if (!SchemaUtils.contains(allowed, value)) {`
	`764`	`+ else if (!utils.contains(allowed, value)) {`
`767`	`765`	`this.throwFieldBadValueError(label);`
`768`	`766`	`}`
`769`	`767`	`}`
`@@ -773,12 +771,12 @@ export class SchemaField {`
`773`	`771`
`774`	`772`	`if (value instanceof Array) {`
`775`	`773`	`for (let i = 0; i < value.length; i += 1) {`
`776`		`- if (SchemaUtils.contains(denied, value[i])) {`
	`774`	`+ if (utils.contains(denied, value[i])) {`
`777`	`775`	`this.throwFieldDeniedValueError(label);`
`778`	`776`	`}`
`779`	`777`	`}`
`780`	`778`	`}`
`781`		`- else if (SchemaUtils.contains(denied, value)) {`
	`779`	`+ else if (utils.contains(denied, value)) {`
`782`	`780`	`this.throwFieldDeniedValueError(label);`
`783`	`781`	`}`
`784`	`782`	`}`