Ok one last question for the brain trust.
The repo I just put up "discovers" these things I'm calling "nodules" in specified directories, then initializes them. The nodules are basically analogous to an HTML page, or partial page, or JSON call. In the Java world they would be a JSP.
I'm wrestling with a kind of messy syntax that's needed to fire up each of these things. Any ideas are appreciated.
One important detail is that we need the filename and path for various "magic" things like if you put a template in the same folder with the same name the framework will just use that template w/o the developer having to specify it (but this can be easily overridden of course, and templates can even be chosen at request time if desired).
So here is the function which finds and initializes them using standard AMD:
Code:
function loadNodules(dir) {
glob.sync('./**/*.js', { cwd: dir })
.forEach(function(nodule) { require(nodule)(app); });
}
This is what the initNodule method looks like inside the nodules themselves, (notice the first parameter - the built-in node variable __filename - we need this):
Code:
module.exports = function(app) {
app.initNodule(__filename, {
route: '/home',
apiPath: '/cms/page',
etc.
someFunction: function() {...},
... everything except util functions and constants lives inside here ...
};
}
So for those not totally familiar with node or AMD, what's happening here is the require function in the first block is basically loading and parsing the file in block 2, and executing everything outside module.exports. When (app) is called on the result of the require(...) closure, that calls the module.exports function.
And here is the initNodule function which each nodule actually calls when it is initialized by the framework. It's probably not too important to get mired in the details of this function. Just know that it needs the file argument, and that it sets up the routes to be registered with express by the framework.
Code:
// create seedNodule (cloned at the start of each request) for each nodule and set up routes in order that they should be registered with express
app.initModule = function initModule(file, config) {
var seedNodule = _.extend(_.cloneDeep(defaultConfig), config); // merge config properties onto default config
seedNodule.path = path.dirname(file);
seedNodule.name = path.basename(file, '.js');
// nodules can have multiple routes
var routeArray = (typeof seedNodule.route === 'string') || (seedNodule.route instanceof RegExp) ? [seedNodule.route] : seedNodule.route;
_.each(routeArray, function(routePath) {
seedNodules[routePath] = seedNodule; // routes must me unique
// use routeIndex to control what order routes are initialized with express
if (!routes[seedNodule.routeIndex])
routes[seedNodule.routeIndex] = [];
routes[seedNodule.routeIndex].push({path:routePath, verb:seedNodule.routeVerb});
});
}
The whole idea is to make these things "self discoverable" meaning they never have to be specified in a config file somewhere, and can be moved around or deleted with no problem - just like say a JSP would be. Except in this case the route is not tied to the filename or folder structure - which is a drastic improvement over JSPs imo.
(Yes I know Java web app routes don't have to be tied to the JSP filename and path -it's just they usually start out that way and then things get messy.)
It all works really well. I'm just kind of worried that the wonky syntax inside the nodules might turn people off. Ideally I'd like to figure out a way to get each of the nodules to look like this:
Code:
module.exports = function(app) {
route: '/home',
apiPath: '/cms/page',
etc.
someFunction: function() {...},
... everything except util functions and constants lives inside here ...
}
without the extra function wrapped inside. I wonder if there's some kind of clever way I could wrap the insides of the module programmatically before initializing, w/o touching the actual file. I think that __filename parameter is the big sticking point though.
Last edited by suzzer99; 12-28-2014 at 01:01 AM.
