@polylith/core 0.1.9 → 0.1.11

package/Defer.js

@@ -0,0 +1,11 @@
+
+export default class Defer {
+	constructor()
+	{
+		this.promise = new Promise(function(resolve, reject)
+		{
+			this.resolve = resolve;
+			this.reject = reject;
+		}.bind(this));
+	}
+}

package/EventBus.js

@@ -7,7 +7,7 @@ export class EventBus {
 	}
 
 	listen (eventName, cb) {
-		var listenerId = uuid.v1();
+		var listenerId = uuid.v4();
 		var name = this.prefix + eventName;
 
 		this.listeners[name] = this.listeners[name] || [];

package/Registry.js

@@ -1,31 +1,76 @@
 import { ServiceOject } from "./ServiceObject.js";
 import { makeEventable} from "./Eventable.js";
+import Defer from "./Defer.js";
 
+/**
+ * This calls is the implementation of the serices registry. There will be a
+ * single global instance of this class.
+ */
 export class Registry {
+	/** Constructor for the registry */
 	constructor () {
 		this.services = {};
+		this.deferreds = {};
 
 		makeEventable(this);
 	}
 
+	/**
+	 * Call this  method to construct a new service object.
+	 * @param {String} [name] if pass this is the name of the sercice object
+	 * 		service objects can be anonymous
+	 * @returns the newly created sercice object
+	 */
 	createServiceObject(name) {
 		var result = new ServiceOject(name);
 
 		return result;
 	}
 
+	/**
+	 * Call this method to register a new service object. The serice object can '
+	 * be subscribed to fromn the registry by the given name.
+	 *
+	 * @param {String} name the namke of the object being registered.
+	 * @param {ServiceOject} serviceObject the service object being registered.
+	 */
 	register(name, serviceObject) {
 		this.services[name] = serviceObject;
 	}
 
+	/**
+	 * Call this method to remove the service object from the registry. Any
+	 * references thos this service will be retained.
+	 *
+	 * @param {String} name the name of the service to remove
+	 */
 	unregister(name) {
 		delete this.services[name];
 	}
 
+	/**
+	 * Call this method to get a reference to the service object.
+	 *
+	 * @param {String} name the registered name of the service object
+	 * @returns {ServiceOject} the registered service object, ot false if it was
+	 * 		not found.
+	 */
 	subscribe(name) {
 		return this.services[name];
 	}
 
+	/**
+	 * Call this method to create and register a service object and then
+	 * implement methods on it. The created service object will be added as a
+	 * member of the implementation object named serviceObject and the methods
+	 * fire, listen and unlisten will be added as well. When called these
+	 * methods will operate directly on the service object.
+	 *
+	 * @param {String} serviceName the name of the service being implemented.
+	 * @param {Object} obj the implementation object for the given methods
+	 * @param {Array.<String>} methodList the list of methods to add. These will
+	 * 		be bound to the passed implementation object.
+	 */
 	makeService(serviceName, obj, methodList) {
 		obj.serviceObject = new ServiceOject(serviceName);
 
@@ -52,6 +97,17 @@ export class Registry {
 		}
 	}
 
+	/**
+	 * Call this method to extend the service object with a new list of methods.
+	 * If not already impementated the methods fire, listen and unlisten will be
+	 * added to the implementation object. If the service doesn't exist, it will
+	 * be created. It will not be registered.
+	 *
+	 * @param {String} serviceName the name of the service being extended
+	 * @param {*} obj the object implementing the methods
+	 * @param {Array.<String>} methodList the list of methods to add. These will
+	 * 		be bound to the passed implementation object.
+	 */
 	extendService(serviceName, obj, methodList) {
 		var serviceObject = this.subscribe(serviceName);
 
@@ -76,14 +132,40 @@ export class Registry {
 		}
 	}
 
-	callAll(serviceNames, which, ...args) {
+	/**
+	 * Call this method to invoke an event on every service in the list
+	 *
+	 * @param {*} serviceNames the list of services to act on
+	 * @param {*} event the event to fire
+	 * @param {*} [preprocess] if provided, this method will be called on all
+	 * 	services before firing the events
+	 * @param {*} [processResult] if provided, this method will be called,
+	 * 	passing the result for every event call
+	 * @returns {Promise.<any>} an array of any promises that were returned from
+	 * 		the called methods.
+	 */
+	callAll(serviceNames, event, preprocess, processResult, ...args ) {
 		var promises = [];
 
+		// run the preprocess callback on each service
+		if (preprocess) {
+			serviceNames.forEach(function (name) {
+				var serviceObject = this.services[name];
+				preprocess(serviceObject);
+			}, this);
+		}
+
+		// invoke the event on all services
 		serviceNames.forEach(function (name) {
 			var serviceObject = this.services[name];
 			if (!serviceObject) return;
 
-			var result = serviceObject.invoke.apply(serviceObject, [which, ...args]);
+			var result = serviceObject.invoke.apply(serviceObject, [event, ...args]);
+
+			// now thta we have a result, let the post process have it
+			if (processResult) processResult(serviceObject, result)
+
+			// if the result is a promise, then we add ot the list to
 			if (result && result.then) {
 				promises.push(result);
 			}
@@ -92,17 +174,92 @@ export class Registry {
 		return promises;
 	}
 
+	/**
+	 * Call this method handle the service start deferreds
+	 *
+	 * @param {ServiceOject} serviceObject the service object to add the method
+	 * 		to
+	 * @param {*} result the result of the start method
+	 */
+	resolveDeferred(serviceObject, result) {
+		var promise = result?.then ? result : Promise.resolve(true);
+
+		// wait for the promise to finish to resolve the deferred
+		promise.then(function(result) {
+			this.deferreds[serviceObject.name].resolve(result)
+		}.bind(this)).catch(function(error) {
+			this.deferreds[serviceObject.name].reject(result)
+		}.bind(this))
+	}
+
+	addWaitMethod(serviceObject) {
+		this.deferreds[serviceObject.name] = new Defer()
+
+		serviceObject.waitStarted = function() {
+			// wait on
+			return this.deferreds[serviceObject.name].promise;
+		}.bind(this)
+	}
+
+	/**
+	 * Call this method to verify that all services have their required services
+	 * registered. Any services that does not have all requirements will be
+	 * removed from the registry
+	 */
+	checkRequirements() {
+		var more = true;
+
+		while (!more) {
+			let names = Object.keys(this.services);
+			let toRemove = [];
+
+			names.forEach(function(name) {
+				var service = this.services[name];
+				var required = service.required;
+
+				var missing = required.some(function(requirement) {
+					if (!requirement in this.services) {
+						console.error(`reqiuirement ${requirement} for service ${name} missing. Service removed`)
+					}
+					return !(requirement in this.services);
+				});
+
+				if (missing) toRemove.push(name);
+			}, this);
+
+			more = toRemove.length != 0;
+			toRemove.forEach(function(name) {
+				delete this.services[name];
+			})
+		}
+	}
+
+	/**
+	 * Call this method to initiate the startup sequence. The startup sequence
+	 * is to first invoke the start method on all the specified registered
+	 * services. Then, after all returtned promises have settled, the ready
+	 * method will be invoked. The ready method is assumed to be synchronous
+	 *
+	 * @param {String} [prefix] if passed, only sevice that start with the
+	 * 		given prefix will have the start process run.
+	 *
+	 * @returns a promise that will be resolved when the startup sequence is
+	 * 		completed.
+	 */
 	async start(prefix = '') {
 		var names = Object.keys(this.services);
 
+		this.checkRequirements();
+
+
 		var services = names.filter(function(name) {
 			return name.indexOf(prefix) === 0;
 		}, this);
 
-		var promises = this.callAll(services, 'start');
+		var promises = this.callAll(services, 'start', this.addWaitMethod.bind(this), this.resolveDeferred.bind(this));
 		return Promise.allSettled(promises)
 			.then(function () {
-				this.callAll(services, 'ready');
+				this.callAll(services, 'ready', null, null);
 				this.fire('ready', prefix);
 			}.bind(this));
 	}

package/ServiceObject.js

@@ -1,14 +1,36 @@
 import { EventBus } from './EventBus.js';
 
+/**
+ * The registry creates an instance of this class for every created service.
+ * Service implementations will extend this object by adding methods and events.
+ * Service objects are eventable objects, and inherit from the EventBus object
+ */
 export class ServiceOject extends EventBus {
+	/**
+	 * Constructor for the service object
+	 * @param {String} name the name of the service being registered.
+	 */
 	constructor(name) {
 		super('service:');
 
 		this.name = name;
 		this.bound = true;
 		this.methods = [];
+		this.required = [];
 	}
 
+	/**
+	 * Call this method to add a method to the serviceobject that will directly
+	 * call the event listener for an event. This is a much faster
+	 * implementation of event handling in the case where there is a single
+	 * listener. If there is more than a single listener this method will
+	 * fallback to calling fire.
+	 *
+	 * @private
+	 * @param {String} name the name of the event being bound to a listener.
+	 * 		This will be the name of the creted method
+	 * @param {Function} method the function to call when the method is called
+	 */
 	assignMethod(name, method) {
 	// if there is already a listener, unbind and force invoking
 		var bind = this.bound || !this.listeners[name];
@@ -23,12 +45,21 @@ export class ServiceOject extends EventBus {
 		this.methods.push(name);
 	}
 
+	/**
+	 * Call this method to unbind the method and make it instead fire an event.
+	 * when called
+	 *
+	 * @param {String} name the name of the method to unbind
+	 */
 	unbindMethod(name) {
 		if (this[name]) {
 			this[name] = this.invoke.bind(this, name)
 		}
 	}
 
+	/**
+	 * Call this method to unbind all methods and prevent future binding.
+	 */
 	unbind() {
 		this.bound = false;
 		this.methods.forEach(function(name) {
@@ -36,6 +67,13 @@ export class ServiceOject extends EventBus {
 		}, this)
 	}
 
+	/**
+	 * Call this method to bind a number of methods  to the service object.
+	 *
+	 * @param {Object} methods a map of methods to implement. The key is the
+	 * 		method name, the value is the method to call.
+	 *
+	 */
 	implement(methods) {
 		var names = Object.keys(methods);
 
@@ -49,7 +87,31 @@ export class ServiceOject extends EventBus {
 		}, this);
 	}
 
+	/**
+	 * Call this method to safely invoke a method. This is a semantic function
+	 * 		to conceptually separate methods from events, although they are
+	 * 		implemented the same.
+	 *
+	 * @param {String} name the name of the method
+	 * @param  {...any} args the paramaters to pass
+	 * @returns
+	 */
 	invoke(name, ...args) {
 		return this.fire(name, ...args);
 	}
+
+	/**
+	 * Call this method to add a list of service names that this service
+	 * depends on
+	 *
+	 * @param {*} services array of services
+	 */
+	require(services) {
+		this.required = [...this.required, ...services];
+
+		this.required = [...new Set(this.required)];
+	}
+
+
+
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@polylith/core",
   "access": "public",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Core of the client-side polylith framework",
   "main": "index.js",
   "repository": {