feature-lifecycle

karma.start.js

@@ -1,5 +1,7 @@
 // Setup global test variables
-var $rootScope, $q, $log, DS, app, $httpBackend, p1, p2, p3, p4;
+var $rootScope, $q, $log, DSProvider, DS, app, $httpBackend, p1, p2, p3, p4;
+
+var lifecycle = {};
 
 // Helper globals
 var fail = function (msg) {
@@ -27,20 +29,66 @@ angular.module('app', ['ng', 'jmdobry.angular-data']);
 
 // Setup before each test
 beforeEach(function (done) {
-	module('app');
+	lifecycle.beforeValidate = function (resourceName, attrs, cb) {
+		lifecycle.beforeValidate.callCount += 1;
+		cb(null, attrs);
+	};
+	lifecycle.validate = function (resourceName, attrs, cb) {
+		lifecycle.validate.callCount += 1;
+		cb(null, attrs);
+	};
+	lifecycle.afterValidate = function (resourceName, attrs, cb) {
+		lifecycle.afterValidate.callCount += 1;
+		cb(null, attrs);
+	};
+	lifecycle.beforeCreate = function (resourceName, attrs, cb) {
+		lifecycle.beforeCreate.callCount += 1;
+		cb(null, attrs);
+	};
+	lifecycle.afterCreate = function (resourceName, attrs, cb) {
+		lifecycle.afterCreate.callCount += 1;
+		cb(null, attrs);
+	};
+	lifecycle.beforeUpdate = function (resourceName, attrs, cb) {
+		lifecycle.beforeUpdate.callCount += 1;
+		cb(null, attrs);
+	};
+	lifecycle.afterUpdate = function (resourceName, attrs, cb) {
+		lifecycle.afterUpdate.callCount += 1;
+		cb(null, attrs);
+	};
+	lifecycle.beforeDestroy = function (resourceName, attrs, cb) {
+		lifecycle.beforeDestroy.callCount += 1;
+		cb(null, attrs);
+	};
+	lifecycle.afterDestroy = function (resourceName, attrs, cb) {
+		lifecycle.afterDestroy.callCount += 1;
+		cb(null, attrs);
+	};
+	module('app', function (_DSProvider_) {
+		DSProvider = _DSProvider_;
+		DSProvider.config({
+			baseUrl: 'http://test.angular-cache.com',
+			beforeValidate: lifecycle.beforeValidate,
+			validate: lifecycle.validate,
+			afterValidate: lifecycle.afterValidate,
+			beforeCreate: lifecycle.beforeCreate,
+			afterCreate: lifecycle.afterCreate,
+			beforeUpdate: lifecycle.beforeUpdate,
+			afterUpdate: lifecycle.afterUpdate,
+			beforeDestroy: lifecycle.beforeDestroy,
+			afterDestroy: lifecycle.afterDestroy
+		});
+	});
 	inject(function (_$rootScope_, _$q_, _$httpBackend_, _DS_) {
 		// Setup global mocks
 		$q = _$q_;
 		$rootScope = _$rootScope_;
 		DS = _DS_;
 		$httpBackend = _$httpBackend_;
-		app = {
-			baseUrl: 'http://test.angular-cache.com'
-		};
 		DS.defineResource({
 			name: 'post',
-			endpoint: '/posts',
-			baseUrl: app.baseUrl
+			endpoint: '/posts'
 		});
 		$log = {
 			warn: function () {
@@ -61,6 +109,16 @@ beforeEach(function (done) {
 		sinon.spy($log, 'info');
 		sinon.spy($log, 'error');
 		sinon.spy($log, 'debug');
+
+		lifecycle.beforeValidate.callCount = 0;
+		lifecycle.validate.callCount = 0;
+		lifecycle.afterValidate.callCount = 0;
+		lifecycle.beforeCreate.callCount = 0;
+		lifecycle.afterCreate.callCount = 0;
+		lifecycle.beforeUpdate.callCount = 0;
+		lifecycle.afterUpdate.callCount = 0;
+		lifecycle.beforeDestroy.callCount = 0;
+		lifecycle.afterDestroy.callCount = 0;
 	});
 
 	p1 = { author: 'John', age: 30, id: 5 };
@@ -79,6 +137,7 @@ afterEach(function () {
 	$log.info.restore();
 	$log.error.restore();
 	$log.debug.restore();
+
 	$httpBackend.verifyNoOutstandingExpectation();
 	$httpBackend.verifyNoOutstandingRequest();
 });

src/datastore/async_methods/create/index.js

@@ -45,47 +45,48 @@ var utils = require('utils'),
  * - `{UnhandledError}`
  */
 function create(resourceName, attrs) {
-	var deferred = $q.defer();
+	var deferred = services.$q.defer(),
+		promise = deferred.promise;
+
 	if (!services.store[resourceName]) {
 		deferred.reject(new errors.RuntimeError(errorPrefix + resourceName + ' is not a registered resource!'));
 	} else if (!utils.isObject(attrs)) {
 		deferred.reject(new errors.IllegalArgumentError(errorPrefix + 'attrs: Must be an object!', { attrs: { actual: typeof attrs, expected: 'object' } }));
-	}
-
-	try {
-		var resource = services.store[resourceName],
-			_this = this,
-			url = utils.makePath(resource.baseUrl || services.config.baseUrl, resource.endpoint || resource.name);
+	} else {
+		try {
+			var resource = services.store[resourceName],
+				_this = this;
 
-		if (resource.validate) {
-			resource.validate(attrs, null, function (err) {
-				if (err) {
-					deferred.reject(err);
-				} else {
+			promise = promise
+				.then(function (attrs) {
+					return services.$q.promisify(resource.beforeValidate)(resourceName, attrs);
+				})
+				.then(function (attrs) {
+					return services.$q.promisify(resource.validate)(resourceName, attrs);
+				})
+				.then(function (attrs) {
+					return services.$q.promisify(resource.afterValidate)(resourceName, attrs);
+				})
+				.then(function (attrs) {
+					return services.$q.promisify(resource.beforeCreate)(resourceName, attrs);
+				})
+				.then(function (attrs) {
+					return _this.POST(utils.makePath(resource.baseUrl, resource.endpoint), attrs, null);
+				})
+				.then(function (data) {
+					return services.$q.promisify(resource.afterCreate)(resourceName, data);
+				})
+				.then(function (data) {
+					return _this.inject(resource.name, data);
+				});
 
-					_this.POST(url, attrs, null).then(function (data) {
-						try {
-							deferred.resolve(_this.inject(resource.name, data));
-						} catch (err) {
-							deferred.reject(err);
-						}
-					}, deferred.reject);
-				}
-			});
-		} else {
-			_this.POST(url, attrs, null).then(function (data) {
-				try {
-					deferred.resolve(_this.inject(resource.name, data));
-				} catch (err) {
-					deferred.reject(err);
-				}
-			}, deferred.reject);
+			deferred.resolve(attrs);
+		} catch (err) {
+			deferred.reject(new errors.UnhandledError(err));
 		}
-	} catch (err) {
-		deferred.reject(new errors.UnhandledError(err));
 	}
 
-	return deferred.promise;
+	return promise;
 }
 
 module.exports = create;

src/datastore/async_methods/destroy/index.js

@@ -45,31 +45,36 @@ var utils = require('utils'),
  * - `{UnhandledError}`
  */
 function destroy(resourceName, id) {
-	var deferred = $q.defer();
+	var deferred = services.$q.defer(),
+		promise = deferred.promise;
+
 	if (!services.store[resourceName]) {
 		deferred.reject(new errors.RuntimeError(errorPrefix + resourceName + ' is not a registered resource!'));
 	} else if (!utils.isString(id) && !utils.isNumber(id)) {
 		deferred.reject(new errors.IllegalArgumentError(errorPrefix + 'id: Must be a string or a number!', { id: { actual: typeof id, expected: 'string|number' } }));
-	}
-
-	try {
+	} else {
 		var resource = services.store[resourceName],
-			_this = this,
-			url = utils.makePath(resource.baseUrl || services.config.baseUrl, resource.endpoint || resource.name, id);
+			_this = this;
 
-		_this.DEL(url, null).then(function () {
-			try {
+		promise = promise
+			.then(function (attrs) {
+				return services.$q.promisify(resource.beforeDestroy)(resourceName, attrs);
+			})
+			.then(function () {
+				return _this.DEL(utils.makePath(resource.baseUrl, resource.endpoint, id), null);
+			})
+			.then(function () {
+				return services.$q.promisify(resource.afterDestroy)(resourceName, resource.index[id]);
+			})
+			.then(function () {
 				_this.eject(resourceName, id);
-				deferred.resolve(id);
-			} catch (err) {
-				deferred.reject(err);
-			}
-		}, deferred.reject);
-	} catch (err) {
-		deferred.reject(new errors.UnhandledError(err));
+				return id;
+			});
+
+		deferred.resolve(resource.index[id]);
 	}
 
-	return deferred.promise;
+	return promise;
 }
 
 module.exports = destroy;

src/datastore/async_methods/find/index.js

@@ -1,7 +1,6 @@
 var utils = require('utils'),
 	errors = require('errors'),
 	services = require('services'),
-	GET = require('../../http').GET,
 	errorPrefix = 'DS.find(resourceName, id[, options]): ';
 
 /**
@@ -49,7 +48,9 @@ var utils = require('utils'),
  * - `{UnhandledError}`
  */
 function find(resourceName, id, options) {
-	var deferred = $q.defer();
+	var deferred = services.$q.defer(),
+		promise = deferred.promise;
+
 	options = options || {};
 
 	if (!services.store[resourceName]) {
@@ -59,43 +60,35 @@ function find(resourceName, id, options) {
 	} else if (!utils.isObject(options)) {
 		deferred.reject(new errors.IllegalArgumentError(errorPrefix + 'options: Must be an object!', { options: { actual: typeof options, expected: 'object' } }));
 	} else {
-		var _this = this;
-
 		try {
-			var resource = services.store[resourceName];
+			var resource = services.store[resourceName],
+				_this = this;
 
-			if (id in resource.index && !options.bypassCache) {
-				deferred.resolve(_this.get(resourceName, id));
-			} else {
-				var url = utils.makePath(resource.baseUrl || services.config.baseUrl, resource.endpoint || resource.name, id),
-					config = null;
+			if (options.bypassCache) {
+				delete resource.completedQueries[id];
+			}
 
-				if (options.bypassCache) {
-					config = {
-						headers: {
-							'Last-Modified': new Date(resource.modified[id])
-						}
-					};
+			if (!(id in resource.completedQueries)) {
+				if (!(id in resource.pendingQueries)) {
+					promise = resource.pendingQueries[id] = _this.GET(utils.makePath(resource.baseUrl, resource.endpoint, id), null)
+						.then(function (data) {
+							// Query is no longer pending
+							delete resource.pendingQueries[id];
+							resource.completedQueries[id] = new Date().getTime();
+							return _this.inject(resourceName, data);
+						});
 				}
-				GET(url, config).then(function (data) {
-					try {
-						_this.inject(resourceName, data);
-						deferred.resolve(_this.get(resourceName, id));
-					} catch (err) {
-						deferred.reject(err);
-					}
-				}, deferred.reject);
-			}
-		} catch (err) {
-			if (!(err instanceof errors.UnhandledError)) {
-				deferred.reject(new errors.UnhandledError(err));
+
+				return resource.pendingQueries[id];
 			} else {
-				deferred.reject(err);
+				deferred.resolve(_this.get(resourceName, id));
 			}
+		} catch (err) {
+			deferred.reject(err);
 		}
 	}
 
-	return deferred.promise;
+	return promise;
 }
 
 module.exports = find;