data-defender - npm Package Compare versions

Comparing version 0.0.3 to 1.0.0

lib/error.js

 'use strict';
 
+var willThrow = true;
+
 exports.CODE = {
@@ -13,46 +15,110 @@ SCHEMA_LOCKED: 'SCHEMA_LOCKED',
 	INVAL_MAX: 'INVALID_MAX_CONSTRAINT',
-	INVAL_MIN: 'INVALID_MIN_CONSTRAINT'
+	INVAL_MIN: 'INVALID_MIN_CONSTRAINT',
+	INVAL_SCHEMA: 'INVALID_SCHEMA_GIVEN',
+	INVAL_VALIDATION: 'INVALID_PROPERY_VALIDATION_FUNC'
 };
 
-exports.DUP_SCHEMA_CREATE = function (msg) {
-	return exports.CODE.DUP_SCHEMA + ': The schema "' + msg + '" already exists';
+exports.returnError = function () {
+	willThrow = false;
 };
 
-exports.INVAL_TYPE = function (msg) {
-	return exports.CODE.INVAL_TYPE + ': The data type must follow: ' +
+exports.INVAL_VALIDATION = function (struct, msg) {
+	var m = exports.CODE.INVAL_VALIDATION + ': The validation function "' + msg + '" is invalid';
+	var error = new Error(m);
+	error.code = exports.CODE.INVAL_VALIDATION;
+	return handleError(struct, error);
+};
+
+exports.DUP_SCHEMA_CREATE = function (struct, msg) {
+	var m = exports.CODE.DUP_SCHEMA + ': The schema "' + msg + '" already exists';
+	var error = new Error(m);
+	error.code = exports.CODE.DUP_SCHEMA;
+	return handleError(struct, error);
+};
+
+exports.INVAL_TYPE = function (struct, msg) {
+	var m = exports.CODE.INVAL_TYPE + ': The data type must follow: ' +
 		'0: number, 1: string, 2: array, 3: object, 4: unique, 5: date, 6: boolean -> ' +
 		'But "' + msg + '" given';
+	var error = new Error(m);
+	error.code = exports.CODE.INVAL_TYPE;
+	return handleError(struct, error);
 };
 
-exports.PROP_NOT_DEF = function (msg) {
-	return exports.CODE.PROP_NOT_DEF + ': The property "' + msg + '" must be defined by .define()';
+exports.PROP_NOT_DEF = function (struct, msg) {
+	var m = exports.CODE.PROP_NOT_DEF + ': The property "' + msg + '" must be defined by .define()';
+	var error = new Error(m);
+	error.code = exports.CODE.PROP_NOT_DEF;
+	return handleError(struct, error);
 };
 
-exports.INVAL_VAL = function (msg) {
-	return exports.CODE.INVAL_PROP_VAL + ': The property value is invalid "' + msg + '"';
+exports.INVAL_VAL = function (struct, msg) {
+	var m = exports.CODE.INVAL_PROP_VAL + ': The property value is invalid "' + msg + '"';
+	var error = new Error(m);
+	error.code = exports.CODE.INVAL_PROP_VAL;
+	return handleError(struct, error);
 };
 
-exports.SCHEMA_NOT_FOUND = function (msg) {
-	return exports.CODE.SCHEMA_NOT_FOUND + ': The schema "' + msg + '" has not been ceated';
+exports.SCHEMA_NOT_FOUND = function (struct, msg) {
+	var m = exports.CODE.SCHEMA_NOT_FOUND + ': The schema "' + msg + '" has not been ceated';
+	var error = new Error(m);
+	error.code = exports.CODE.SCHEMA_NOT_FOUND;
+	return handleError(struct, error);
 };
 
-exports.VAL_CHANGE_NOT_ALLOWED = function () {
-	return exports.CODE.VAL_CHANGE_NOT_ALLOWED + ': The UNIQUE data type cannot be changed';
+exports.VAL_CHANGE_NOT_ALLOWED = function (struct) {
+	var m = exports.CODE.VAL_CHANGE_NOT_ALLOWED + ': The UNIQUE data type cannot be changed';
+	var error = new Error(m);
+	error.code = exports.CODE.VAL_CHANGE_NOT_ALLOWED;
+	return handleError(struct, error);
 };
 
-exports.SCHEMA_LOCKED = function () {
-	return exports.CODE.SCHEMA_LOCKED + ': The schema has already been locked and it cannot be changed';
+exports.SCHEMA_LOCKED = function (struct) {
+	var m = exports.CODE.SCHEMA_LOCKED + ': The schema has already been locked and it cannot be changed';
+	var error = new Error(m);
+	error.code = exports.CODE.SCHEMA_LOCKED;
+	return handleError(struct, error);
 };
 
-exports.INVAL_DEFAULT = function (msg) {
-	return exports.CODE.INVAL_DEF + ': The default "' + msg + '" value is invalid';
+exports.INVAL_DEFAULT = function (struct, msg) {
+	var m = exports.CODE.INVAL_DEF + ': The default "' + msg + '" value is invalid';
+	var error = new Error(m);
+	error.code = exports.CODE.INVAL_DEF;
+	return handleError(struct, error);
 };
 
-exports.INVAL_MAX = function (msg) {
-	return exports.CODE.INVAL_MAX + ': The defined max value is invalid "' + msg + '"';
+exports.INVAL_MAX = function (struct, msg) {
+	var m = exports.CODE.INVAL_MAX + ': The defined max value is invalid "' + msg + '"';
+	var error = new Error(m);
+	error.code = exports.CODE.INVAL_MAX;
+	return handleError(struct, error);
 };
 
-exports.INVAL_MIN = function (msg) {
-	return exports.CODE.INVAL_MIN + ': The defined min value is invalid "' + msg + '"';
+exports.INVAL_MIN = function (struct, msg) {
+	var m = exports.CODE.INVAL_MIN + ': The defined min value is invalid "' + msg + '"';
+	var error = new Error(m);
+	error.code = exports.CODE.INVAL_MIN;
+	return handleError(struct, error);
 };
 
+exports.INVAL_SCHEMA = function (struct, msg) {
+	var m = exports.CODE.INVAL_SCHEMA + ': The schema must be an instance of Struct (data-defender.create()) "' + msg + '"';
+	var error = new Error(m);
+	error.code = exports.CODE.INVAL_SCHEMA;
+	return handleError(struct, error);
+};
+
+function handleError(struct, error) {
+
+	if (willThrow) {
+		throw error;
+	}
+
+	// dispatch event
+	//struct.emit('error', error);
+	//struct.emit(error.code, error);
+
+	// return error
+	return error;
+}
+

package.json

 {
 	"name": "data-defender",
 	"description": "A database-agnostic simple data schema enforcer for node.js",
-	"version": "0.0.3",
+	"version": "1.0.0",
 	"author": "Nobuyori Takahashi <[e-mail]>",
@@ -6,0 +6,0 @@ "repository": {

README.md

@@ -9,4 +9,12 @@ # data-defender
 
+## How To Install
+
+`npm install data-defencer`
+
 ## API
 
+### .returnError()
+
+Enable the module to return errors instead of throwing exceptions.
+
 ### .create(schemaName [string])
@@ -16,3 +24,3 @@
 
-It will throw an error if trying to create a schema that has already been created.
+It will return an error if trying to create a schema that has already been created.
 
@@ -40,3 +48,3 @@ **Example**:
 
-It will throw an exception if trying to get a schema that has not been created.
+It will return an error if trying to get a schema that has not been created.
 
@@ -57,3 +65,3 @@ **Example**:
 
-If there is an error, it will throw an exception.
+If there is an error, it will return an error.
 
@@ -130,3 +138,3 @@ **constraints**:
 
-If the given values do not meet the constraints defined by the schema, it will throw an exception.
+If the given values do not meet the constraints defined by the schema, it will return an error.
 
@@ -133,0 +141,0 @@ **NOTE**: If you define a property that is `UNIQUE` and pass nothing to `.load()`, it will auto-generate a unique ID as a string.

src/schema/data.js

@@ -18,3 +18,6 @@ 'use strict';
 		for (var name in data) {
-			this._update(name, data[name]);
+			var err = this._update(name, data[name]);
+			if (err instanceof Error) {
+				return err;
+			}
 		}
@@ -26,3 +29,8 @@ this.emit('load', data);
 Data.prototype.update = function (name, value) {
-	this._update(name, value);
+	var err = this._update(name, value);
+
+	if (err instanceof Error) {
+		return err;
+	}
+	
 	var list = this._struct._getModtimeList();
@@ -38,6 +46,11 @@ for (var i = 0, len = list.length; i < len; i++) {
 	var data = this._struct._update(name, value);
+
+	if (data instanceof Error) {
+		return data;
+	}	
+
 	var hasProp = this._props.hasOwnProperty(name);
 
 	if (data.noChange && hasProp && this._props[name] !== value) {
-		throw new Error(ERROR.VAL_CHANGE_NOT_ALLOWED(name));
+		return ERROR.VAL_CHANGE_NOT_ALLOWED(this, name);
 	}
@@ -44,0 +57,0 @@

src/schema/index.js

@@ -10,5 +10,9 @@ 'use strict';
 
+exports.returnError = function () {
+	ERROR.returnError();
+};
+
 exports.create = function (name) {
 	if (data.hasOwnProperty(name)) {
-		throw new Error(ERROR.DUP_SCHEMA_CREATE(name));
+		return ERROR.DUP_SCHEMA_CREATE(this, name);
 	}
@@ -22,5 +26,5 @@ var struct = new Struct(name);
 	if (!data.hasOwnProperty(name)) {
-		throw new Error(ERROR.SCHEMA_NOT_FOUND(name));
+		return ERROR.SCHEMA_NOT_FOUND(this, name);
 	}
 	return data[name];
 };

src/schema/struct.js

@@ -31,10 +31,10 @@ 'use strict';
 	if (this._lock) {
-		throw new Error(ERROR.SCHEMA_LOCKED());
+		return ERROR.SCHEMA_LOCKED(this);
 	}
 	// schema constraints check
 	if (this._constraints.hasOwnProperty(name)) {
-		throw new Error(ERROR.DUP_STRUCT_PROP(name));
+		return ERROR.DUP_STRUCT_PROP(this, name);
 	}
 	if (!DATATYPE.isValidType(valMap.type)) {
-		throw new Error(ERROR.INVAL_TYPE(valMap.type));
+		return ERROR.INVAL_TYPE(this, valMap.type);
 	}
@@ -45,3 +45,3 @@ if (valMap.max && typeof valMap.max !== 'number') {
 		} else {
-			throw new Error(ERROR.INVAL_MAX(valMap.max));
+			return ERROR.INVAL_MAX(this, valMap.max);
 		}
@@ -53,3 +53,3 @@ }
 		} else {
-			throw new Error(ERROR.INVAL_MIN(valMap.min));
+			return ERROR.INVAL_MIN(this, valMap.min);
 		}
@@ -60,3 +60,3 @@ }
 	if (valMap.max && maxIsNum && minIsNum && valMap.max < valMap.min) {
-		throw new Error(ERROR.INVAL_MAX(valMap.max));
+		return ERROR.INVAL_MAX(this, valMap.max);
 	}
@@ -81,7 +81,17 @@ if (valMap.max && valMap.type === DATATYPE.DATE) {
 	if (valMap.default !== undefined && !isValid(valMap, valMap.default)) {
-		throw new Error(ERROR.INVAL_DEFAULT(valMap.default));
+		return ERROR.INVAL_DEFAULT(this, valMap.default);
 	}
+	// validate schema if given
+	if (valMap.hasOwnProperty('schema') && !valMap.schema instanceof Struct) {
+		return ERROR.INVAL_SCHEMA(this, name);
+	}
+	// validation validation function
+	if (valMap.hasOwnProperty('validation') && typeof valMap.validation !== 'function') {
+		return ERROR.INVAL_VALIDATION(this, name);
+	}
 	this._constraints[name] = {
 		type: valMap.type,
 		default: valMap.default || null,
+		schema: valMap.schema || null,
+		validation: valMap.validation || null,
 		max: valMap.max || null,
@@ -125,3 +135,6 @@ min: valMap.min || null
 
-	data.load(values);
+	var err = data.load(values);
+	if (err instanceof Error) {
+		return err;
+	}
 	return data;
@@ -132,3 +145,3 @@ };
 	if (!this._constraints.hasOwnProperty(name)) {
-		throw new Error(ERROR.PROP_NOT_DEF(name));
+		return ERROR.PROP_NOT_DEF(this, name);
 	}
@@ -144,6 +157,6 @@ var constraint = this._constraints[name];
 	if (!this._constraints.hasOwnProperty(name)) {
-		throw new Error(ERROR.PROP_NOT_DEF(name));
+		return ERROR.PROP_NOT_DEF(this, name);
 	}
 	if (!isValid(this._constraints[name], value)) {
-		throw new Error(ERROR.INVAL_VAL(value));
+		return ERROR.INVAL_VAL(this, value);
 	}
@@ -249,5 +262,6 @@ if (this._constraints[name].type === DATATYPE.UNIQUE) {
 		default:
-			throw new Error(ERROR.INVAL_TYPE(constraints.type));
+			//return ERROR.INVAL_TYPE(this, constraints.type);
+			return false;
 	}
-	
+
 	// validation of maximum and minimum value allowed
@@ -260,4 +274,8 @@ if (constraints.hasOwnProperty('max') && constraints.max !== null && len > constraints.max) {
 	}
+
+	if (constraints.hasOwnProperty('validation') && constraints.validation !== null && !constraints.validation(value)) {
+		return false;
+	}
 	
 	return true;
 }

test/index.js

@@ -647,2 +647,26 @@ var assert = require('assert');
 
+	it('can disable exception throwing', function () {
+		defender.returnError();
+	});
+
+	it('can define a property w/ value validation function and it can fail to update and it can successfully update', function () {
+		var boo = defender.create('boo');
+		boo.define('name', {
+			type: defender.DATATYPE.STR,
+			validation: function (value) {
+				return value === 'good name';
+			}
+		});
+		var data = boo.load();
+		var err = data.update('name', 'bad name');
+		assert.equal(err instanceof Error, true);
+		var success = data.update('name', 'good name');
+		assert.equal(success instanceof Error, false);
+	});
+
+	it('can handle error w/o throwing and it can catch and/or detect the error from the return value', function () {
+		var d = test.load({ boo: 100 });
+		assert.equal((d instanceof Error), true);
+	});
+
 });

Fixed alerts

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

37483

increased by11.12%

Lines of code

1076

increased by11.16%

Number of low quality alerts

1

decreased by-50%

Number of lines in readme file

208

increased by4%

No dependency changes