alchemymvc 1.3.21 → 1.4.0-alpha.1

package/lib/stages/05-load_app.js

@@ -0,0 +1,57 @@
+const libpath = require('path');
+
+/**
+ * The "load_app" stage
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const load_app = STAGES.createStage('load_app');
+
+/**
+ * The "load_app.core_app" stage
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const core_app = load_app.createStage('core_app', () => {
+	alchemy.useAppPath(libpath.resolve(PATH_CORE, 'app'), {weight: 1});
+});
+
+/**
+ * The "load_app.plugins" stage
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const plugins = load_app.createStage('plugins', async () => {
+
+	// Make sure all the constitutions of the core classes are loaded
+	Blast.doLoaded();
+
+	// Now all the plugins will load
+	// (they registered themselves as a `post` task)
+});
+
+/**
+ * The "load_app.main_app" stage
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const main_app = load_app.createStage('main_app', () => {
+	// Load in the app
+	alchemy.useAppPath(PATH_APP, {weight: 20, skip: ['routes']});
+});

package/lib/stages/10-datasource.js

@@ -0,0 +1,61 @@
+const libpath = require('path');
+
+/**
+ * The "datasource" stage
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const datasource = STAGES.createStage('datasource');
+
+/**
+ * The "datasource.connect" stage:
+ * Make a connection to all the datasources.
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const connect = datasource.createStage('connect', () => {
+
+	// Force Blast to load
+	try {
+		Blast.doLoaded();
+	} catch (err) {
+		alchemy.printLog('error', ['Failed to load application:', err.message], {err: err, level: 1});
+		return
+	}
+
+	let environment = alchemy.getSetting('environment');
+
+	// Require the environment datasources configuration
+	try {
+		require(libpath.resolve(PATH_ROOT, 'app', 'config', environment, 'database'));
+	} catch (err) {
+
+		if (err.code == 'MODULE_NOT_FOUND') {
+			if (!alchemy.getSetting('client_mode')) {
+				// Only output a warning when not in client mode
+				log.warn('Could not find ' + environment + ' database settings');
+			}
+		} else {
+			log.warn('Could not load ' + environment + ' database settings:', err);
+		}
+
+		return;
+	}
+
+	let tasks = [];
+
+	// Get all available datasources
+	Object.each(Datasource.get(), function eachDatasource(datasource, key) {
+		tasks.push(datasource.setup());
+	});
+
+	return Function.parallel(tasks);
+});

package/lib/stages/15-tasks.js

@@ -0,0 +1,27 @@
+/**
+ * The "tasks" stage
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const tasks = STAGES.createStage('tasks');
+
+// Do not start any task stage before the datasources are connected
+tasks.dependsOn('datasource.connect');
+
+/**
+ * "tasks.start_service"
+ * Start the task service
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const start_service = tasks.createStage('start_service', () => {
+	alchemy.task_service = new Classes.Alchemy.Task.TaskService();
+});

package/lib/stages/20-settings.js

@@ -0,0 +1,68 @@
+/**
+ * The "settings" stage.
+ * The settings definitions should already be loaded.
+ * The hard-coded settings too.
+ * In this stage, we load the settings from the database.
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const settings = STAGES.createStage('settings');
+
+// Do not start this stage before the datasources are connected
+settings.dependsOn('datasource.connect');
+
+/**
+ * "settings.load"
+ * Load the settings from the database
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const load = settings.createStage('load', async () => {
+
+	let records = await Model.get('System.Setting').find('all');
+
+	if (!records.length) {
+		return;
+	}
+
+	for (let record of records) {
+		await record.applySetting(false);
+	}
+});
+
+/**
+ * "settings.perform_actions"
+ * Do all the setting-associated actions.
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const perform_actions = settings.createStage('perform_actions', async () => {
+	await alchemy.system_settings.performAllActions();
+});
+
+/**
+ * "settings.to_object"
+ * Convert the `alchemy.settings` property to a simple object
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const to_object = settings.createStage('to_object', async () => {
+	// Create the settings object
+	alchemy.settings = alchemy.system_settings.toObject();
+});

package/lib/stages/50-routes.js

@@ -0,0 +1,218 @@
+const libpath = require('path');
+
+/**
+ * The "routes" stage
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const routes = STAGES.createStage('routes');
+
+/**
+ * The "routes.hawkejs" stage:
+ * Setup the Hawkejs routes
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const hawkejs = routes.createStage('hawkejs', () => {
+
+	// Set the correct asset paths
+	alchemy.hawkejs.style_path = 'stylesheets/';
+	alchemy.hawkejs.script_path = 'scripts/';
+
+	// Serve the hawkejs file
+	Router.use('/hawkejs/hawkejs-client.js', function getHawkejs(req, res, next) {
+
+		var retries = 0;
+
+		Blast.getClientPath({
+			modify_prototypes : true,
+			ua                : req.conduit.headers.useragent,
+			create_source_map : alchemy.getSetting('debugging.create_source_map'),
+			enable_coverage   : !!global.__coverage__,
+			debug             : alchemy.getSetting('debugging.debug'),
+		}).done(gotClientFile);
+
+		function gotClientFile(err, path) {
+
+			if (err) {
+				console.log(err)
+				return retryFnc(err);
+			}
+
+			let options = {};
+
+			if (req.conduit && req.conduit.supports('async') === false) {
+				options.add_async_support = true;
+			}
+
+			alchemy.minifyScript(path, options, function gotMinifiedPath(err, mpath) {
+
+				var options;
+
+				if (!retries) {
+					options = {
+						onError: retryFnc
+					}
+				}
+
+				req.conduit.serveFile(mpath || path, options);
+			});
+		}
+
+		function retryFnc(err) {
+
+			if (retries > 0) {
+				return req.conduit.error(new Error('Failed to serve client file'));
+			}
+
+			retries++;
+
+			Blast.getClientPath({
+				refresh           : true,
+				modify_prototypes : true,
+				ua                : req.conduit.headers.useragent,
+				create_source_map : alchemy.getSetting('debugging.create_source_map'),
+				debug             : alchemy.getSetting('debugging.debug'),
+			}).done(gotClientFile);
+		}
+	});
+
+	// Serve the static file with exposed variables
+	Router.use('/hawkejs/static.js', function getHawkejs(req, res, next) {
+		alchemy.hawkejs.getStaticExposedPath((err, path) => {
+
+			if (err) {
+				return req.conduit.error(err);
+			}
+
+			req.conduit.serveFile(path);
+		});
+	});
+
+	// Serve multiple template files
+	Router.use('/hawkejs/templates', function onGetTemplates(req, res) {
+
+		var names = req.conduit.param('name');
+
+		if (!names) {
+			return req.conduit.error(new Error('No template names have been given'));
+		}
+
+		alchemy.hawkejs.getFirstAvailableSource(names, function gotResult(err, result) {
+
+			if (err) {
+				return req.conduit.error(err);
+			}
+
+			if (!result || !result.name) {
+				return req.conduit.notFound('Could not find any of the given templates');
+			}
+
+			req.conduit.setHeader('cache-control', 'public, max-age=3600, must-revalidate');
+
+			// Don't use json dry, hawkejs expects regular json
+			req.conduit.json_dry = false;
+
+			req.conduit.end(result);
+		});
+	}, {methods: ['get'], weight: 19});
+
+	// Serve single template files
+	Router.use('/hawkejs/template', function onGetTemplate(req, res) {
+
+		var name = req.conduit.param('name');
+
+		if (!name) {
+			return req.conduit.error(new Error('No template name has been given'));
+		}
+
+		alchemy.hawkejs.getTemplatePath(name, function gotTemplate(err, path) {
+
+			if (err) {
+				return req.conduit.error(err);
+			}
+
+			if (!path) {
+				req.conduit.notFound('Could not find ' + name);
+			} else {
+				req.conduit.serveFile(path);
+			}
+		});
+	}, {methods: ['get'], weight: 19});
+});
+
+/**
+ * The "routes.middleware" stage:
+ * Setup all the middleware routes
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const middleware = routes.createStage('middleware', () => {
+
+	// Serve public files
+	Router.use('/public/', alchemy.publicMiddleware, 50);
+
+	// Serve stylesheets
+	Router.use('/stylesheets/', alchemy.styleMiddleware, 50);
+
+	// Serve scripts
+	Router.use('/scripts/', alchemy.scriptMiddleware, 50);
+
+	// Serve fonts
+	Router.use('/fonts/', alchemy.fontMiddleware, 50);
+
+	// Serve root files
+	Router.use('/', alchemy.rootMiddleware, 49);
+
+	if (alchemy.getSetting('debugging.debug')) {
+		// Serve sourcemap files
+		Router.use('/_sourcemaps/', alchemy.sourcemapMiddleware, 50);
+	}
+
+	// Parse body (form-data & json, no multipart)
+	// @todo: not all routes require body parsing
+	Router.use(function parseBody(req, res, next) {
+
+		// Don't re-check internal redirects, they always should have a body set
+		if (req.original.body != null || (req.conduit && req.conduit instanceof Classes.Alchemy.Conduit.Loopback)) {
+			return next();
+		}
+
+		alchemy.parseRequestBody(req, res, next);
+
+	}, {methods: ['post'], weight: 99999});
+
+});
+
+/**
+ * The "routes.app_routes" stage:
+ * Setup the routes of the main app.
+ *
+ * @author   Jelle De Loecker <jelle@elevenways.be>
+ * @since    1.4.0
+ * @version  1.4.0
+ *
+ * @type     {Alchemy.Stages.Stage}
+ */
+const app_routes = routes.createStage('app_routes', () => {
+	try {
+		alchemy.useOnce(libpath.resolve(PATH_APP, 'config', 'routes.js'));
+	} catch (err) {
+		// Only output warning when not in client mode
+		if (!alchemy.getSetting('client_mode')) {
+			log.warn('No app routes were found:', err);
+		}
+	}
+});