Initial PoC to refactor loopback-boot
This commit is contained in:
Raymond Feng
David Cheung
parent
28d58ede8e
commit
3443c8ba1b
17
browser.js
17
browser.js
|
|
@ -3,7 +3,7 @@
|
|||
// This file is licensed under the MIT License.
|
||||
// License text available at https://opensource.org/licenses/MIT
|
||||
|
||||
var execute = require('./lib/executor');
|
||||
var Bootstrapper = require('./lib/bootstrapper').Bootstrapper;
|
||||
|
||||
/**
|
||||
* The browser version of `bootLoopBackApp`.
|
||||
|
|
@ -25,13 +25,20 @@ exports = module.exports = function bootBrowserApp(app, options) {
|
|||
// Only using options.id to identify the browserified bundle to load for
|
||||
// this application. If no Id was provided, load the default bundle.
|
||||
var moduleName = 'loopback-boot#instructions';
|
||||
if (options && typeof options === 'object' && options.appId)
|
||||
moduleName += '-' + options.appId;
|
||||
var appId = options && typeof options === 'object' && options.appId;
|
||||
if (appId)
|
||||
moduleName += '-' + appId;
|
||||
|
||||
// The name of the module containing instructions
|
||||
// is hard-coded in lib/bundler
|
||||
var instructions = require(moduleName);
|
||||
execute(app, instructions);
|
||||
|
||||
var bootstrapper = new Bootstrapper(options);
|
||||
bootstrapper.phases = ['starting', 'start', 'started'];
|
||||
var context = {
|
||||
app: app,
|
||||
instructions: instructions,
|
||||
};
|
||||
bootstrapper.run(context);
|
||||
};
|
||||
|
||||
exports.execute = execute;
|
||||
|
|
|
|||
45
index.js
45
index.js
|
|
@ -7,9 +7,8 @@
|
|||
var SG = require('strong-globalize');
|
||||
SG.SetRootDir(__dirname);
|
||||
|
||||
var ConfigLoader = require('./lib/config-loader');
|
||||
var compile = require('./lib/compiler');
|
||||
var execute = require('./lib/executor');
|
||||
var PluginBase = require('./lib/plugin-base');
|
||||
var Bootstrapper = require('./lib/bootstrapper').Bootstrapper;
|
||||
var addInstructionsToBrowserify = require('./lib/bundler');
|
||||
var utils = require('./lib/utils');
|
||||
|
||||
|
|
@ -150,8 +149,24 @@ exports = module.exports = function bootLoopBackApp(app, options, callback) {
|
|||
// backwards compatibility with loopback's app.boot
|
||||
options.env = options.env || app.get('env');
|
||||
|
||||
var instructions = compile(options);
|
||||
execute(app, instructions, callback);
|
||||
var bootstrapper = require('./lib/bootstrapper')(options);
|
||||
|
||||
var context = {
|
||||
bootstrapper: bootstrapper,
|
||||
app: app,
|
||||
};
|
||||
|
||||
bootstrapper.run(context, callback);
|
||||
};
|
||||
|
||||
exports.compile = function(options) {
|
||||
var bootstrapper = new Bootstrapper(options);
|
||||
bootstrapper.phases = ['load', 'compile'];
|
||||
var context = {};
|
||||
bootstrapper.run(context, function(err) {
|
||||
if (err) throw err;
|
||||
});
|
||||
return context.instructions;
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -165,7 +180,8 @@ exports = module.exports = function bootLoopBackApp(app, options, callback) {
|
|||
* @header boot.compileToBrowserify(options, bundler)
|
||||
*/
|
||||
exports.compileToBrowserify = function(options, bundler) {
|
||||
addInstructionsToBrowserify(compile(options), bundler);
|
||||
var instructions = exports.compile(options);
|
||||
addInstructionsToBrowserify({ instructions: instructions }, bundler);
|
||||
};
|
||||
|
||||
/* -- undocumented low-level API -- */
|
||||
|
|
@ -175,3 +191,20 @@ exports.compile = compile;
|
|||
exports.execute = execute;
|
||||
exports.utils = utils;
|
||||
exports.addInstructionsToBrowserify = addInstructionsToBrowserify;
|
||||
|
||||
exports.Bootstrapper = Bootstrapper;
|
||||
exports.PluginBase = PluginBase;
|
||||
|
||||
exports.execute = function(app, instructions, done) {
|
||||
var bootstrapper = new Bootstrapper(
|
||||
{ phases: ['starting', 'start', 'started'] });
|
||||
var context = {
|
||||
app: app,
|
||||
instructions: instructions,
|
||||
};
|
||||
bootstrapper.run(context, function(err) {
|
||||
if (err) throw err;
|
||||
if (done) done(err);
|
||||
});
|
||||
return context;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -0,0 +1,185 @@
|
|||
var assert = require('assert');
|
||||
var async = require('async');
|
||||
var utils = require('./utils');
|
||||
var debug = require('debug')('loopback:boot:bootstrapper');
|
||||
var Promise = global.Promise || require('bluebird');
|
||||
|
||||
module.exports = function(options) {
|
||||
return new Bootstrapper(options);
|
||||
};
|
||||
|
||||
module.exports.Bootstrapper = Bootstrapper;
|
||||
|
||||
function createPromiseCallback() {
|
||||
var cb;
|
||||
var promise = new Promise(function(resolve, reject) {
|
||||
cb = function(err, data) {
|
||||
if (err) return reject(err);
|
||||
return resolve(data);
|
||||
};
|
||||
});
|
||||
cb.promise = promise;
|
||||
return cb;
|
||||
}
|
||||
|
||||
var builtinPlugins = [
|
||||
'application', 'datasource', 'model', 'mixin',
|
||||
'middleware', 'component', 'boot-script', 'swagger',
|
||||
];
|
||||
|
||||
var builtinPhases = [
|
||||
'load', 'compile', 'starting', 'start', 'started',
|
||||
];
|
||||
|
||||
/**
|
||||
* Create a new Bootstrapper with options
|
||||
* @param options
|
||||
* @constructor
|
||||
*/
|
||||
function Bootstrapper(options) {
|
||||
this.plugins = [];
|
||||
options = options || {};
|
||||
|
||||
if (typeof options === 'string') {
|
||||
options = { appRootDir: options };
|
||||
}
|
||||
|
||||
var appRootDir = options.appRootDir = options.appRootDir || process.cwd();
|
||||
var env = options.env || process.env.NODE_ENV || 'development';
|
||||
|
||||
var appConfigRootDir = options.appConfigRootDir || appRootDir;
|
||||
|
||||
options.rootDir = appConfigRootDir;
|
||||
options.env = env;
|
||||
this.options = options;
|
||||
|
||||
this.phases = options.phases || builtinPhases;
|
||||
this.builtinPlugins = options.plugins || builtinPlugins;
|
||||
assert(Array.isArray(this.phases), 'Invalid phases: ' + this.phases);
|
||||
assert(Array.isArray(this.plugins), 'Invalid plugins: ' +
|
||||
this.builtinPlugins);
|
||||
|
||||
var self = this;
|
||||
self.builtinPlugins.forEach(function(p) {
|
||||
var factory = require('./plugins/' + p);
|
||||
self.use('/boot/' + p, factory(options));
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Register a handler to a given path
|
||||
* @param {String} path
|
||||
* @param {Function} handler
|
||||
*/
|
||||
Bootstrapper.prototype.use = function(path, handler) {
|
||||
var plugin = {
|
||||
path: path,
|
||||
handler: handler,
|
||||
};
|
||||
this.plugins.push(plugin);
|
||||
};
|
||||
|
||||
/**
|
||||
* Get a list of plugins for the given path
|
||||
* @param {String} path
|
||||
* @returns {*}
|
||||
*/
|
||||
Bootstrapper.prototype.getPlugins = function(path) {
|
||||
if (path[path.length - 1] !== '/') {
|
||||
path = path + '/';
|
||||
}
|
||||
return this.plugins.filter(function(p) {
|
||||
return p.path.indexOf(path) === 0;
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Get a list of extensions for the given path
|
||||
* @param {String} path
|
||||
* @returns {*}
|
||||
*/
|
||||
Bootstrapper.prototype.getExtensions = function(path) {
|
||||
if (path[path.length - 1] !== '/') {
|
||||
path = path + '/';
|
||||
}
|
||||
return this.plugins.filter(function(p) {
|
||||
if (p.path.indexOf(path) === -1) return false;
|
||||
var name = p.path.substring(path.length);
|
||||
return name && name.indexOf('/') === -1;
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Add more phases. The order of phases is decided by the sequence of phase
|
||||
* names
|
||||
* @param {String[]} phases An array of phase names
|
||||
* @returns {String[]} New list of phases
|
||||
*/
|
||||
Bootstrapper.prototype.addPhases = function(phases) {
|
||||
this.phases = utils.mergePhaseNameLists(this.phases, phases || []);
|
||||
return this.phases;
|
||||
};
|
||||
|
||||
/**
|
||||
* Invoke the plugins phase by phase with the given context
|
||||
* @param {Object} context Context object
|
||||
* @param {Function} done Callback function. If not provided, a promise will be
|
||||
* returned
|
||||
* @returns {*}
|
||||
*/
|
||||
Bootstrapper.prototype.run = function(context, done) {
|
||||
if (!done) {
|
||||
done = createPromiseCallback();
|
||||
}
|
||||
var options = this.options;
|
||||
var appRootDir = options.appRootDir = options.appRootDir || process.cwd();
|
||||
var env = options.env || process.env.NODE_ENV || 'development';
|
||||
|
||||
var appConfigRootDir = options.appConfigRootDir || appRootDir;
|
||||
|
||||
options.rootDir = appConfigRootDir;
|
||||
options.env = env;
|
||||
|
||||
context = context || {};
|
||||
|
||||
var phases = context.phases || this.phases;
|
||||
var bootPlugins = this.getExtensions('/boot');
|
||||
async.eachSeries(phases, function(phase, done) {
|
||||
debug('Phase %s', phase);
|
||||
async.eachSeries(bootPlugins, function(plugin, done) {
|
||||
var result;
|
||||
if (typeof plugin.handler[phase] === 'function') {
|
||||
debug('Invoking %s.%s', plugin.handler.name, phase);
|
||||
try {
|
||||
if (plugin.handler[phase].length === 2) {
|
||||
plugin.handler[phase](context, done);
|
||||
} else {
|
||||
result = plugin.handler[phase](context);
|
||||
if (typeof Promise !== 'undefined') {
|
||||
if (result && typeof result.then === 'function') {
|
||||
result.then(function(value) {
|
||||
done(null, value);
|
||||
}).catch(function(err) {
|
||||
debug(err);
|
||||
done(err);
|
||||
});
|
||||
} else {
|
||||
done(null, result);
|
||||
}
|
||||
} else {
|
||||
done(null, result);
|
||||
}
|
||||
}
|
||||
} catch (err) {
|
||||
debug(err);
|
||||
done(err);
|
||||
}
|
||||
} else {
|
||||
debug('Skipping %s.%s', plugin.handler.name, phase);
|
||||
return done();
|
||||
}
|
||||
}, done);
|
||||
}, done);
|
||||
return done.promise;
|
||||
};
|
||||
|
||||
|
|
@ -14,39 +14,37 @@ var g = require('strong-globalize')();
|
|||
* @param {Object} instructions Boot instructions.
|
||||
* @param {Object} bundler A browserify object created by `browserify()`.
|
||||
*/
|
||||
|
||||
module.exports = function addInstructionsToBrowserify(instructions, bundler) {
|
||||
bundleModelScripts(instructions, bundler);
|
||||
bundleMixinScripts(instructions, bundler);
|
||||
bundleComponentScripts(instructions, bundler);
|
||||
bundleOtherScripts(instructions, bundler);
|
||||
bundleInstructions(instructions, bundler);
|
||||
module.exports = function addInstructionsToBrowserify(context, bundler) {
|
||||
bundleModelScripts(context, bundler);
|
||||
bundleMixinScripts(context, bundler);
|
||||
bundleComponentScripts(context, bundler);
|
||||
bundleOtherScripts(context, bundler);
|
||||
bundleInstructions(context, bundler);
|
||||
};
|
||||
|
||||
function bundleOtherScripts(instructions, bundler) {
|
||||
for (var key in instructions.files) {
|
||||
addScriptsToBundle(key, instructions.files[key], bundler);
|
||||
}
|
||||
function bundleOtherScripts(context, bundler) {
|
||||
var list = context.instructions.bootScripts;
|
||||
addScriptsToBundle('boot', list, bundler);
|
||||
}
|
||||
|
||||
function bundleModelScripts(instructions, bundler) {
|
||||
bundleSourceFiles(instructions, 'models', bundler);
|
||||
function bundleModelScripts(context, bundler) {
|
||||
bundleSourceFiles(context, 'models', bundler);
|
||||
}
|
||||
|
||||
function bundleMixinScripts(instructions, bundler) {
|
||||
bundleSourceFiles(instructions, 'mixins', bundler);
|
||||
function bundleMixinScripts(context, bundler) {
|
||||
bundleSourceFiles(context, 'mixins', bundler);
|
||||
}
|
||||
|
||||
function bundleComponentScripts(instructions, bundler) {
|
||||
bundleSourceFiles(instructions, 'components', bundler);
|
||||
function bundleComponentScripts(context, bundler) {
|
||||
bundleSourceFiles(context, 'components', bundler);
|
||||
}
|
||||
|
||||
function bundleSourceFiles(instructions, type, bundler) {
|
||||
var files = instructions[type]
|
||||
function bundleSourceFiles(context, type, bundler) {
|
||||
var files = context.instructions[type]
|
||||
.map(function(m) { return m.sourceFile; })
|
||||
.filter(function(f) { return !!f; });
|
||||
|
||||
var instructionToFileMapping = instructions[type]
|
||||
var instructionToFileMapping = context.instructions[type]
|
||||
.map(function(m) { return files.indexOf(m.sourceFile); });
|
||||
|
||||
addScriptsToBundle(type, files, bundler);
|
||||
|
|
@ -54,7 +52,7 @@ function bundleSourceFiles(instructions, type, bundler) {
|
|||
// Update `sourceFile` properties with the new paths
|
||||
instructionToFileMapping.forEach(function(fileIx, sourceIx) {
|
||||
if (fileIx === -1) return;
|
||||
instructions[type][sourceIx].sourceFile = files[fileIx];
|
||||
context.instructions[type][sourceIx].sourceFile = files[fileIx];
|
||||
});
|
||||
}
|
||||
|
||||
|
|
@ -74,14 +72,14 @@ function addScriptsToBundle(name, list, bundler) {
|
|||
// Add the file to the bundle.
|
||||
bundler.require(filepath, { expose: fileid });
|
||||
|
||||
// Rewrite the instructions entry with the new id that will be
|
||||
// Rewrite the context entry with the new id that will be
|
||||
// used to load the file via `require(fileid)`.
|
||||
list[ix] = fileid;
|
||||
}
|
||||
}
|
||||
|
||||
function bundleInstructions(instructions, bundler) {
|
||||
instructions = cloneDeep(instructions);
|
||||
function bundleInstructions(context, bundler) {
|
||||
var instructions = cloneDeep(context.instructions);
|
||||
|
||||
var hasMiddleware = instructions.middleware.phases.length ||
|
||||
instructions.middleware.middleware.length;
|
||||
|
|
|
|||
823
lib/compiler.js
823
lib/compiler.js
|
|
@ -1,823 +0,0 @@
|
|||
// Copyright IBM Corp. 2014,2016. All Rights Reserved.
|
||||
// Node module: loopback-boot
|
||||
// This file is licensed under the MIT License.
|
||||
// License text available at https://opensource.org/licenses/MIT
|
||||
|
||||
var assert = require('assert');
|
||||
var cloneDeep = require('lodash').cloneDeep;
|
||||
var fs = require('fs');
|
||||
var path = require('path');
|
||||
var toposort = require('toposort');
|
||||
var ConfigLoader = require('./config-loader');
|
||||
var utils = require('./utils');
|
||||
var debug = require('debug')('loopback:boot:compiler');
|
||||
var Module = require('module');
|
||||
var _ = require('lodash');
|
||||
var g = require('strong-globalize')();
|
||||
|
||||
var FILE_EXTENSION_JSON = '.json';
|
||||
|
||||
/**
|
||||
* Gather all bootstrap-related configuration data and compile it into
|
||||
* a single object containing instruction for `boot.execute`.
|
||||
*
|
||||
* @options {String|Object} options Boot options; If String, this is
|
||||
* the application root directory; if object, has the properties
|
||||
* described in `bootLoopBackApp` options above.
|
||||
* @return {Object}
|
||||
*
|
||||
* @header boot.compile(options)
|
||||
*/
|
||||
|
||||
module.exports = function compile(options) {
|
||||
options = options || {};
|
||||
|
||||
if (typeof options === 'string') {
|
||||
options = { appRootDir: options };
|
||||
}
|
||||
|
||||
var appRootDir = options.appRootDir = options.appRootDir || process.cwd();
|
||||
var env = options.env || process.env.NODE_ENV || 'development';
|
||||
|
||||
var appConfigRootDir = options.appConfigRootDir || appRootDir;
|
||||
var appConfig = options.config ||
|
||||
ConfigLoader.loadAppConfig(appConfigRootDir, env);
|
||||
assertIsValidConfig('app', appConfig);
|
||||
|
||||
var modelsRootDir = options.modelsRootDir || appRootDir;
|
||||
var modelsConfig = options.models ||
|
||||
ConfigLoader.loadModels(modelsRootDir, env);
|
||||
assertIsValidModelConfig(modelsConfig);
|
||||
|
||||
var dsRootDir = options.dsRootDir || appRootDir;
|
||||
var dataSourcesConfig = options.dataSources ||
|
||||
ConfigLoader.loadDataSources(dsRootDir, env);
|
||||
assertIsValidConfig('data source', dataSourcesConfig);
|
||||
|
||||
var middlewareRootDir = options.middlewareRootDir || appRootDir;
|
||||
|
||||
var middlewareConfig = options.middleware ||
|
||||
ConfigLoader.loadMiddleware(middlewareRootDir, env);
|
||||
var middlewareInstructions =
|
||||
buildMiddlewareInstructions(middlewareRootDir, middlewareConfig);
|
||||
|
||||
var componentRootDir = options.componentRootDir || appRootDir;
|
||||
var componentConfig = options.components ||
|
||||
ConfigLoader.loadComponents(componentRootDir, env);
|
||||
var componentInstructions =
|
||||
buildComponentInstructions(componentRootDir, componentConfig);
|
||||
|
||||
// require directories
|
||||
var bootDirs = options.bootDirs || []; // precedence
|
||||
bootDirs = bootDirs.concat(path.join(appRootDir, 'boot'));
|
||||
resolveRelativePaths(bootDirs, appRootDir);
|
||||
|
||||
var bootScripts = options.bootScripts || [];
|
||||
resolveRelativePaths(bootScripts, appRootDir);
|
||||
|
||||
bootDirs.forEach(function(dir) {
|
||||
bootScripts = bootScripts.concat(findScripts(dir));
|
||||
var envdir = dir + '/' + env;
|
||||
bootScripts = bootScripts.concat(findScripts(envdir));
|
||||
});
|
||||
|
||||
// de-dedup boot scripts -ERS
|
||||
// https://github.com/strongloop/loopback-boot/issues/64
|
||||
bootScripts = _.uniq(bootScripts);
|
||||
|
||||
var modelsMeta = modelsConfig._meta || {};
|
||||
delete modelsConfig._meta;
|
||||
|
||||
var modelSources = options.modelSources || modelsMeta.sources || ['./models'];
|
||||
var modelInstructions = buildAllModelInstructions(
|
||||
modelsRootDir, modelsConfig, modelSources, options.modelDefinitions);
|
||||
|
||||
var mixinDirs = options.mixinDirs || [];
|
||||
var mixinSources = options.mixinSources || modelsMeta.mixins || ['./mixins'];
|
||||
var mixinInstructions = buildAllMixinInstructions(
|
||||
appRootDir, mixinDirs, mixinSources, options, modelInstructions);
|
||||
|
||||
// When executor passes the instruction to loopback methods,
|
||||
// loopback modifies the data. Since we are loading the data using `require`,
|
||||
// such change affects also code that calls `require` for the same file.
|
||||
var instructions = {
|
||||
env: env,
|
||||
config: appConfig,
|
||||
dataSources: dataSourcesConfig,
|
||||
models: modelInstructions,
|
||||
middleware: middlewareInstructions,
|
||||
components: componentInstructions,
|
||||
mixins: mixinInstructions,
|
||||
files: {
|
||||
boot: bootScripts,
|
||||
},
|
||||
};
|
||||
|
||||
if (options.appId)
|
||||
instructions.appId = options.appId;
|
||||
|
||||
return cloneDeep(instructions);
|
||||
};
|
||||
|
||||
function assertIsValidConfig(name, config) {
|
||||
if (config) {
|
||||
assert(typeof config === 'object',
|
||||
g.f('%s config must be a valid JSON object', name));
|
||||
}
|
||||
}
|
||||
|
||||
function assertIsValidModelConfig(config) {
|
||||
assertIsValidConfig('model', config);
|
||||
for (var name in config) {
|
||||
var entry = config[name];
|
||||
var options = entry.options || {};
|
||||
var unsupported = entry.properties ||
|
||||
entry.base || options.base ||
|
||||
entry.plural || options.plural;
|
||||
|
||||
if (unsupported) {
|
||||
throw new Error(
|
||||
g.f('The data in {{model-config.json}}' +
|
||||
' is in the unsupported 1.x format.'));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Find all javascript files (except for those prefixed with _)
|
||||
* and all directories.
|
||||
* @param {String} dir Full path of the directory to enumerate.
|
||||
* @return {Array.<String>} A list of absolute paths to pass to `require()`.
|
||||
* @private
|
||||
*/
|
||||
|
||||
function findScripts(dir, extensions) {
|
||||
assert(dir, g.f('cannot require directory contents without directory name'));
|
||||
|
||||
var files = tryReadDir(dir);
|
||||
extensions = extensions || _.keys(require.extensions);
|
||||
|
||||
// sort files in lowercase alpha for linux
|
||||
files.sort(function(a, b) {
|
||||
a = a.toLowerCase();
|
||||
b = b.toLowerCase();
|
||||
|
||||
if (a < b) {
|
||||
return -1;
|
||||
} else if (b < a) {
|
||||
return 1;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
});
|
||||
|
||||
var results = [];
|
||||
files.forEach(function(filename) {
|
||||
// ignore index.js and files prefixed with underscore
|
||||
if (filename === 'index.js' || filename[0] === '_') {
|
||||
return;
|
||||
}
|
||||
|
||||
var filepath = path.resolve(path.join(dir, filename));
|
||||
var stats = fs.statSync(filepath);
|
||||
|
||||
// only require files supported by require.extensions (.txt .md etc.)
|
||||
if (stats.isFile()) {
|
||||
if (isPreferredExtension(filename))
|
||||
results.push(filepath);
|
||||
else
|
||||
debug('Skipping file %s - unknown extension', filepath);
|
||||
} else {
|
||||
debug('Skipping directory %s', filepath);
|
||||
}
|
||||
});
|
||||
|
||||
return results;
|
||||
}
|
||||
|
||||
function tryReadDir() {
|
||||
try {
|
||||
return fs.readdirSync.apply(fs, arguments);
|
||||
} catch (e) {
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
function buildAllModelInstructions(rootDir, modelsConfig, sources,
|
||||
modelDefinitions) {
|
||||
var registry = verifyModelDefinitions(rootDir, modelDefinitions) ||
|
||||
findModelDefinitions(rootDir, sources);
|
||||
|
||||
var modelNamesToBuild = addAllBaseModels(registry, Object.keys(modelsConfig));
|
||||
|
||||
var instructions = modelNamesToBuild
|
||||
.map(function createModelInstructions(name) {
|
||||
var config = modelsConfig[name];
|
||||
var definition = registry[name] || {};
|
||||
|
||||
debug('Using model "%s"\nConfiguration: %j\nDefinition %j',
|
||||
name, config, definition.definition);
|
||||
|
||||
return {
|
||||
name: name,
|
||||
config: config,
|
||||
definition: definition.definition,
|
||||
sourceFile: definition.sourceFile,
|
||||
};
|
||||
});
|
||||
|
||||
return sortByInheritance(instructions);
|
||||
}
|
||||
|
||||
function addAllBaseModels(registry, modelNames) {
|
||||
var result = [];
|
||||
var visited = {};
|
||||
|
||||
while (modelNames.length) {
|
||||
var name = modelNames.shift();
|
||||
|
||||
if (visited[name]) continue;
|
||||
visited[name] = true;
|
||||
result.push(name);
|
||||
|
||||
var definition = registry[name] && registry[name].definition;
|
||||
if (!definition) continue;
|
||||
|
||||
var base = getBaseModelName(definition);
|
||||
|
||||
// ignore built-in models like User
|
||||
if (!registry[base]) continue;
|
||||
|
||||
modelNames.push(base);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
function getBaseModelName(modelDefinition) {
|
||||
if (!modelDefinition)
|
||||
return undefined;
|
||||
|
||||
return modelDefinition.base ||
|
||||
modelDefinition.options && modelDefinition.options.base;
|
||||
}
|
||||
|
||||
function sortByInheritance(instructions) {
|
||||
// create edges Base name -> Model name
|
||||
var edges = instructions
|
||||
.map(function(inst) {
|
||||
return [getBaseModelName(inst.definition), inst.name];
|
||||
});
|
||||
|
||||
var sortedNames = toposort(edges);
|
||||
|
||||
var instructionsByModelName = {};
|
||||
instructions.forEach(function(inst) {
|
||||
instructionsByModelName[inst.name] = inst;
|
||||
});
|
||||
|
||||
return sortedNames
|
||||
// convert to instructions
|
||||
.map(function(name) {
|
||||
return instructionsByModelName[name];
|
||||
})
|
||||
// remove built-in models
|
||||
.filter(function(inst) {
|
||||
return !!inst;
|
||||
});
|
||||
}
|
||||
|
||||
function verifyModelDefinitions(rootDir, modelDefinitions) {
|
||||
if (!modelDefinitions || modelDefinitions.length < 1) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
var registry = {};
|
||||
modelDefinitions.forEach(function(definition, idx) {
|
||||
if (definition.sourceFile) {
|
||||
var fullPath = path.resolve(rootDir, definition.sourceFile);
|
||||
definition.sourceFile = fixFileExtension(
|
||||
fullPath,
|
||||
tryReadDir(path.dirname(fullPath)),
|
||||
true);
|
||||
if (!definition.sourceFile) {
|
||||
debug('Model source code not found: %s - %s', definition.sourceFile);
|
||||
}
|
||||
}
|
||||
|
||||
debug('Found model "%s" - %s %s',
|
||||
definition.definition.name,
|
||||
'from options',
|
||||
definition.sourceFile ?
|
||||
path.relative(rootDir, definition.sourceFile) :
|
||||
'(no source file)');
|
||||
|
||||
var modelName = definition.definition.name;
|
||||
if (!modelName) {
|
||||
debug('Skipping model definition without Model name ' +
|
||||
'(from options.modelDefinitions @ index %s)',
|
||||
idx);
|
||||
return;
|
||||
}
|
||||
registry[modelName] = definition;
|
||||
});
|
||||
|
||||
return registry;
|
||||
}
|
||||
|
||||
function findModelDefinitions(rootDir, sources) {
|
||||
var registry = {};
|
||||
|
||||
sources.forEach(function(src) {
|
||||
var srcDir = tryResolveAppPath(rootDir, src, { strict: false });
|
||||
if (!srcDir) {
|
||||
debug('Skipping unknown module source dir %j', src);
|
||||
return;
|
||||
}
|
||||
|
||||
var files = tryReadDir(srcDir);
|
||||
|
||||
files
|
||||
.filter(function(f) {
|
||||
return f[0] !== '_' && path.extname(f) === '.json';
|
||||
})
|
||||
.forEach(function(f) {
|
||||
var fullPath = path.resolve(srcDir, f);
|
||||
var entry = loadModelDefinition(rootDir, fullPath, files);
|
||||
var modelName = entry.definition.name;
|
||||
if (!modelName) {
|
||||
debug('Skipping model definition without Model name: %s',
|
||||
path.relative(srcDir, fullPath));
|
||||
return;
|
||||
}
|
||||
registry[modelName] = entry;
|
||||
});
|
||||
});
|
||||
|
||||
return registry;
|
||||
}
|
||||
|
||||
function resolveAppPath(rootDir, relativePath, resolveOptions) {
|
||||
var resolvedPath = tryResolveAppPath(rootDir, relativePath, resolveOptions);
|
||||
if (resolvedPath === undefined && !resolveOptions.optional) {
|
||||
var err = new Error(g.f('Cannot resolve path "%s"', relativePath));
|
||||
err.code = 'PATH_NOT_FOUND';
|
||||
throw err;
|
||||
}
|
||||
return resolvedPath;
|
||||
}
|
||||
|
||||
function tryResolveAppPath(rootDir, relativePath, resolveOptions) {
|
||||
var fullPath;
|
||||
var start = relativePath.substring(0, 2);
|
||||
|
||||
/* In order to retain backward compatibility, we need to support
|
||||
* two ways how to treat values that are not relative nor absolute
|
||||
* path (e.g. `relativePath = 'foobar'`)
|
||||
* - `resolveOptions.strict = true` searches in `node_modules` only
|
||||
* - `resolveOptions.strict = false` attempts to resolve the value
|
||||
* as a relative path first before searching `node_modules`
|
||||
*/
|
||||
resolveOptions = resolveOptions || { strict: true };
|
||||
|
||||
var isModuleRelative = false;
|
||||
if (relativePath[0] === '/') {
|
||||
fullPath = relativePath;
|
||||
} else if (start === './' || start === '..') {
|
||||
fullPath = path.resolve(rootDir, relativePath);
|
||||
} else if (!resolveOptions.strict) {
|
||||
isModuleRelative = true;
|
||||
fullPath = path.resolve(rootDir, relativePath);
|
||||
}
|
||||
|
||||
if (fullPath) {
|
||||
// This check is needed to support paths pointing to a directory
|
||||
if (utils.fileExistsSync(fullPath)) {
|
||||
return fullPath;
|
||||
}
|
||||
|
||||
try {
|
||||
fullPath = require.resolve(fullPath);
|
||||
return fullPath;
|
||||
} catch (err) {
|
||||
if (!isModuleRelative) {
|
||||
debug ('Skipping %s - %s', fullPath, err);
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Handle module-relative path, e.g. `loopback/common/models`
|
||||
|
||||
// Module.globalPaths is a list of globally configured paths like
|
||||
// [ env.NODE_PATH values, $HOME/.node_modules, etc. ]
|
||||
// Module._nodeModulePaths(rootDir) returns a list of paths like
|
||||
// [ rootDir/node_modules, rootDir/../node_modules, etc. ]
|
||||
var modulePaths = Module.globalPaths
|
||||
.concat(Module._nodeModulePaths(rootDir));
|
||||
|
||||
fullPath = modulePaths
|
||||
.map(function(candidateDir) {
|
||||
var absPath = path.join(candidateDir, relativePath);
|
||||
try {
|
||||
// NOTE(bajtos) We need to create a proper String object here,
|
||||
// otherwise we can't attach additional properties to it
|
||||
var filePath = new String(require.resolve(absPath));
|
||||
filePath.unresolvedPath = absPath;
|
||||
return filePath;
|
||||
} catch (err) {
|
||||
return absPath;
|
||||
}
|
||||
})
|
||||
.filter(function(candidate) {
|
||||
return utils.fileExistsSync(candidate.toString());
|
||||
})
|
||||
[0];
|
||||
|
||||
if (fullPath) {
|
||||
if (fullPath.unresolvedPath && resolveOptions.fullResolve === false)
|
||||
return fullPath.unresolvedPath;
|
||||
// Convert String object back to plain string primitive
|
||||
return fullPath.toString();
|
||||
}
|
||||
|
||||
debug ('Skipping %s - module not found', fullPath);
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function loadModelDefinition(rootDir, jsonFile, allFiles) {
|
||||
var definition = require(jsonFile);
|
||||
var basename = path.basename(jsonFile, path.extname(jsonFile));
|
||||
definition.name = definition.name || _.capitalize(_.camelCase(basename));
|
||||
|
||||
// find a matching file with a supported extension like `.js` or `.coffee`
|
||||
var sourceFile = fixFileExtension(jsonFile, allFiles, true);
|
||||
|
||||
if (sourceFile === undefined) {
|
||||
debug('Model source code not found: %s', sourceFile);
|
||||
}
|
||||
|
||||
debug('Found model "%s" - %s %s', definition.name,
|
||||
path.relative(rootDir, jsonFile),
|
||||
sourceFile ? path.relative(rootDir, sourceFile) : '(no source file)');
|
||||
|
||||
return {
|
||||
definition: definition,
|
||||
sourceFile: sourceFile,
|
||||
};
|
||||
}
|
||||
|
||||
function buildMiddlewareInstructions(rootDir, config) {
|
||||
var phasesNames = Object.keys(config);
|
||||
var middlewareList = [];
|
||||
phasesNames.forEach(function(phase) {
|
||||
var phaseConfig = config[phase];
|
||||
Object.keys(phaseConfig).forEach(function(middleware) {
|
||||
var allConfigs = phaseConfig[middleware];
|
||||
if (!Array.isArray(allConfigs))
|
||||
allConfigs = [allConfigs];
|
||||
|
||||
allConfigs.forEach(function(config) {
|
||||
var resolved = resolveMiddlewarePath(rootDir, middleware, config);
|
||||
|
||||
// resolved.sourceFile will be false-y if an optional middleware
|
||||
// is not resolvable.
|
||||
// if a non-optional middleware is not resolvable, it will throw
|
||||
// at resolveAppPath() and not reach here
|
||||
if (!resolved.sourceFile) {
|
||||
return g.log('{{Middleware}} "%s" not found: %s',
|
||||
middleware,
|
||||
resolved.optional
|
||||
);
|
||||
}
|
||||
|
||||
var middlewareConfig = cloneDeep(config);
|
||||
middlewareConfig.phase = phase;
|
||||
|
||||
if (middlewareConfig.params) {
|
||||
middlewareConfig.params = resolveMiddlewareParams(
|
||||
rootDir, middlewareConfig.params);
|
||||
}
|
||||
|
||||
var item = {
|
||||
sourceFile: resolved.sourceFile,
|
||||
config: middlewareConfig,
|
||||
};
|
||||
if (resolved.fragment) {
|
||||
item.fragment = resolved.fragment;
|
||||
}
|
||||
middlewareList.push(item);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
var flattenedPhaseNames = phasesNames
|
||||
.map(function getBaseName(name) {
|
||||
return name.replace(/:[^:]+$/, '');
|
||||
})
|
||||
.filter(function differsFromPreviousItem(value, ix, source) {
|
||||
// Skip duplicate entries. That happens when
|
||||
// `name:before` and `name:after` are both translated to `name`
|
||||
return ix === 0 || value !== source[ix - 1];
|
||||
});
|
||||
|
||||
return {
|
||||
phases: flattenedPhaseNames,
|
||||
middleware: middlewareList,
|
||||
};
|
||||
}
|
||||
|
||||
function resolveMiddlewarePath(rootDir, middleware, config) {
|
||||
var resolved = {
|
||||
optional: !!config.optional,
|
||||
};
|
||||
|
||||
var segments = middleware.split('#');
|
||||
var pathName = segments[0];
|
||||
var fragment = segments[1];
|
||||
var middlewarePath = pathName;
|
||||
var opts = {
|
||||
strict: true,
|
||||
optional: !!config.optional,
|
||||
};
|
||||
|
||||
if (fragment) {
|
||||
resolved.fragment = fragment;
|
||||
}
|
||||
|
||||
if (pathName.indexOf('./') === 0 || pathName.indexOf('../') === 0) {
|
||||
// Relative path
|
||||
pathName = path.resolve(rootDir, pathName);
|
||||
}
|
||||
|
||||
var resolveOpts = _.extend(opts, {
|
||||
// Workaround for strong-agent to allow probes to detect that
|
||||
// strong-express-middleware was loaded: exclude the path to the
|
||||
// module main file from the source file path.
|
||||
// For example, return
|
||||
// node_modules/strong-express-metrics
|
||||
// instead of
|
||||
// node_modules/strong-express-metrics/index.js
|
||||
fullResolve: false,
|
||||
});
|
||||
var sourceFile = resolveAppScriptPath(rootDir, middlewarePath, resolveOpts);
|
||||
|
||||
if (!fragment) {
|
||||
resolved.sourceFile = sourceFile;
|
||||
return resolved;
|
||||
}
|
||||
|
||||
// Try to require the module and check if <module>.<fragment> is a valid
|
||||
// function
|
||||
var m = require(pathName);
|
||||
if (typeof m[fragment] === 'function') {
|
||||
resolved.sourceFile = sourceFile;
|
||||
return resolved;
|
||||
}
|
||||
|
||||
/*
|
||||
* module/server/middleware/fragment
|
||||
* module/middleware/fragment
|
||||
*/
|
||||
var candidates = [
|
||||
pathName + '/server/middleware/' + fragment,
|
||||
pathName + '/middleware/' + fragment,
|
||||
// TODO: [rfeng] Should we support the following flavors?
|
||||
// pathName + '/lib/' + fragment,
|
||||
// pathName + '/' + fragment
|
||||
];
|
||||
|
||||
var err = undefined; // see https://github.com/eslint/eslint/issues/5744
|
||||
for (var ix in candidates) {
|
||||
try {
|
||||
resolved.sourceFile = resolveAppScriptPath(rootDir, candidates[ix], opts);
|
||||
delete resolved.fragment;
|
||||
return resolved;
|
||||
} catch (e) {
|
||||
// Report the error for the first candidate when no candidate matches
|
||||
if (!err) err = e;
|
||||
}
|
||||
}
|
||||
throw err;
|
||||
}
|
||||
|
||||
// Match values starting with `$!./` or `$!../`
|
||||
var MIDDLEWARE_PATH_PARAM_REGEX = /^\$!(\.\/|\.\.\/)/;
|
||||
|
||||
function resolveMiddlewareParams(rootDir, params) {
|
||||
return cloneDeep(params, function resolvePathParam(value) {
|
||||
if (typeof value === 'string' && MIDDLEWARE_PATH_PARAM_REGEX.test(value)) {
|
||||
return path.resolve(rootDir, value.slice(2));
|
||||
} else {
|
||||
return undefined; // no change
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function buildComponentInstructions(rootDir, componentConfig) {
|
||||
return Object.keys(componentConfig)
|
||||
.filter(function(name) { return !!componentConfig[name]; })
|
||||
.map(function(name) {
|
||||
return {
|
||||
sourceFile: resolveAppScriptPath(rootDir, name, { strict: true }),
|
||||
config: componentConfig[name],
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
function resolveRelativePaths(relativePaths, appRootDir) {
|
||||
var resolveOpts = { strict: false };
|
||||
relativePaths.forEach(function(relativePath, k) {
|
||||
var resolvedPath = tryResolveAppPath(appRootDir, relativePath, resolveOpts);
|
||||
if (resolvedPath !== undefined) {
|
||||
relativePaths[k] = resolvedPath;
|
||||
} else {
|
||||
debug ('skipping boot script %s - unknown file', relativePath);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function getExcludedExtensions() {
|
||||
return {
|
||||
'.json': '.json',
|
||||
'.node': 'node',
|
||||
};
|
||||
}
|
||||
|
||||
function isPreferredExtension(filename) {
|
||||
var includeExtensions = require.extensions;
|
||||
|
||||
var ext = path.extname(filename);
|
||||
return (ext in includeExtensions) && !(ext in getExcludedExtensions());
|
||||
}
|
||||
|
||||
function fixFileExtension(filepath, files, onlyScriptsExportingFunction) {
|
||||
var results = [];
|
||||
var otherFile;
|
||||
|
||||
/* Prefer coffee scripts over json */
|
||||
if (isPreferredExtension(filepath)) return filepath;
|
||||
|
||||
var basename = path.basename(filepath, FILE_EXTENSION_JSON);
|
||||
var sourceDir = path.dirname(filepath);
|
||||
|
||||
files.forEach(function(f) {
|
||||
otherFile = path.resolve(sourceDir, f);
|
||||
|
||||
var stats = fs.statSync(otherFile);
|
||||
if (stats.isFile()) {
|
||||
var otherFileExtension = path.extname(f);
|
||||
|
||||
if (!(otherFileExtension in getExcludedExtensions()) &&
|
||||
path.basename(f, otherFileExtension) == basename) {
|
||||
if (!onlyScriptsExportingFunction)
|
||||
results.push(otherFile);
|
||||
else if (onlyScriptsExportingFunction &&
|
||||
(typeof require.extensions[otherFileExtension]) === 'function') {
|
||||
results.push(otherFile);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
return (results.length > 0 ? results[0] : undefined);
|
||||
}
|
||||
|
||||
function resolveAppScriptPath(rootDir, relativePath, resolveOptions) {
|
||||
var resolvedPath = resolveAppPath(rootDir, relativePath, resolveOptions);
|
||||
if (!resolvedPath) {
|
||||
return false;
|
||||
}
|
||||
var sourceDir = path.dirname(resolvedPath);
|
||||
var files = tryReadDir(sourceDir);
|
||||
var fixedFile = fixFileExtension(resolvedPath, files, false);
|
||||
return (fixedFile === undefined ? resolvedPath : fixedFile);
|
||||
}
|
||||
|
||||
function buildAllMixinInstructions(appRootDir, mixinDirs, mixinSources, options,
|
||||
modelInstructions) {
|
||||
var extensions = _.without(_.keys(require.extensions),
|
||||
_.keys(getExcludedExtensions()));
|
||||
|
||||
// load mixins from `options.mixins`
|
||||
var sourceFiles = options.mixins || [];
|
||||
var instructionsFromMixins = loadMixins(sourceFiles, options);
|
||||
|
||||
// load mixins from `options.mixinDirs`
|
||||
sourceFiles = findMixinDefinitions(appRootDir, mixinDirs, extensions);
|
||||
if (sourceFiles === undefined) return;
|
||||
var instructionsFromMixinDirs = loadMixins(sourceFiles, options);
|
||||
|
||||
/* If `mixinDirs` and `mixinSources` have any directories in common,
|
||||
* then remove the common directories from `mixinSources` */
|
||||
mixinSources = _.difference(mixinSources, mixinDirs);
|
||||
|
||||
// load mixins from `options.mixinSources`
|
||||
sourceFiles = findMixinDefinitions(appRootDir, mixinSources, extensions);
|
||||
if (sourceFiles === undefined) return;
|
||||
var instructionsFromMixinSources = loadMixins(sourceFiles, options);
|
||||
|
||||
// Fetch unique list of mixin names, used in models
|
||||
var modelMixins = fetchMixinNamesUsedInModelInstructions(modelInstructions);
|
||||
modelMixins = _.uniq(modelMixins);
|
||||
|
||||
// Filter-in only mixins, that are used in models
|
||||
instructionsFromMixinSources = filterMixinInstructionsUsingWhitelist(
|
||||
instructionsFromMixinSources, modelMixins);
|
||||
|
||||
var mixins = _.assign(
|
||||
instructionsFromMixins,
|
||||
instructionsFromMixinDirs,
|
||||
instructionsFromMixinSources);
|
||||
|
||||
return _.values(mixins);
|
||||
}
|
||||
|
||||
function findMixinDefinitions(appRootDir, sourceDirs, extensions) {
|
||||
var files = [];
|
||||
sourceDirs.forEach(function(dir) {
|
||||
var path = tryResolveAppPath(appRootDir, dir);
|
||||
if (!path) {
|
||||
debug('Skipping unknown module source dir %j', dir);
|
||||
return;
|
||||
}
|
||||
files = files.concat(findScripts(path, extensions));
|
||||
});
|
||||
return files;
|
||||
}
|
||||
|
||||
function loadMixins(sourceFiles, options) {
|
||||
var mixinInstructions = {};
|
||||
sourceFiles.forEach(function(filepath) {
|
||||
var dir = path.dirname(filepath);
|
||||
var ext = path.extname(filepath);
|
||||
var name = path.basename(filepath, ext);
|
||||
var metafile = path.join(dir, name + FILE_EXTENSION_JSON);
|
||||
|
||||
name = normalizeMixinName(name, options);
|
||||
var meta = {};
|
||||
meta.name = name;
|
||||
if (utils.fileExistsSync(metafile)) {
|
||||
// May overwrite name, not sourceFile
|
||||
_.extend(meta, require(metafile));
|
||||
}
|
||||
meta.sourceFile = filepath;
|
||||
mixinInstructions[meta.name] = meta;
|
||||
});
|
||||
|
||||
return mixinInstructions;
|
||||
}
|
||||
|
||||
function fetchMixinNamesUsedInModelInstructions(modelInstructions) {
|
||||
return _.flatten(modelInstructions
|
||||
.map(function(model) {
|
||||
return model.definition && model.definition.mixins ?
|
||||
Object.keys(model.definition.mixins) : [];
|
||||
}));
|
||||
}
|
||||
|
||||
function filterMixinInstructionsUsingWhitelist(instructions, includeMixins) {
|
||||
var instructionKeys = Object.keys(instructions);
|
||||
includeMixins = _.intersection(instructionKeys, includeMixins);
|
||||
|
||||
var filteredInstructions = {};
|
||||
instructionKeys.forEach(function(mixinName) {
|
||||
if (includeMixins.indexOf(mixinName) !== -1) {
|
||||
filteredInstructions[mixinName] = instructions[mixinName];
|
||||
}
|
||||
});
|
||||
return filteredInstructions;
|
||||
}
|
||||
|
||||
function normalizeMixinName(str, options) {
|
||||
var normalization = options.normalization;
|
||||
switch (normalization) {
|
||||
case false:
|
||||
case 'none': return str;
|
||||
|
||||
case undefined:
|
||||
case 'classify':
|
||||
str = String(str).replace(/([A-Z]+)/g, ' $1').trim();
|
||||
str = String(str).replace(/[\W_]/g, ' ').toLowerCase();
|
||||
str = str.replace(/(?:^|\s|-)\S/g, function(c) {
|
||||
return c.toUpperCase();
|
||||
});
|
||||
str = str.replace(/\s+/g, '');
|
||||
return str;
|
||||
|
||||
case 'dasherize':
|
||||
str = String(str).replace(/([A-Z]+)/g, ' $1').trim();
|
||||
str = String(str).replace(/[\W_]/g, ' ').toLowerCase();
|
||||
str = str.replace(/\s+/g, '-');
|
||||
return str;
|
||||
|
||||
default:
|
||||
if (typeof normalization === 'function') {
|
||||
return normalization(str);
|
||||
}
|
||||
|
||||
var err = new Error(g.f('Invalid normalization format - "%s"',
|
||||
normalization));
|
||||
err.code = 'INVALID_NORMALIZATION_FORMAT';
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,313 +0,0 @@
|
|||
// Copyright IBM Corp. 2014,2016. All Rights Reserved.
|
||||
// Node module: loopback-boot
|
||||
// This file is licensed under the MIT License.
|
||||
// License text available at https://opensource.org/licenses/MIT
|
||||
|
||||
var cloneDeep = require('lodash').cloneDeep;
|
||||
var path = require('path');
|
||||
var utils = require('./utils.js');
|
||||
var debug = require('debug')('loopback:boot:config-loader');
|
||||
var assert = require('assert');
|
||||
var g = require('strong-globalize')();
|
||||
|
||||
var ConfigLoader = exports;
|
||||
|
||||
/**
|
||||
* Load application config from `config.json` and friends.
|
||||
* @param {String} rootDir Directory where to look for files.
|
||||
* @param {String} env Environment, usually `process.env.NODE_ENV`
|
||||
* @returns {Object}
|
||||
*/
|
||||
ConfigLoader.loadAppConfig = function(rootDir, env) {
|
||||
return loadNamed(rootDir, env, 'config', mergeAppConfig);
|
||||
};
|
||||
|
||||
/**
|
||||
* Load data-sources config from `datasources.json` and friends.
|
||||
* @param {String} rootDir Directory where to look for files.
|
||||
* @param {String} env Environment, usually `process.env.NODE_ENV`
|
||||
* @returns {Object}
|
||||
*/
|
||||
ConfigLoader.loadDataSources = function(rootDir, env) {
|
||||
return loadNamed(rootDir, env, 'datasources', mergeDataSourceConfig);
|
||||
};
|
||||
|
||||
/**
|
||||
* Load model config from `model-config.json` and friends.
|
||||
* @param {String} rootDir Directory where to look for files.
|
||||
* @param {String} env Environment, usually `process.env.NODE_ENV`
|
||||
* @returns {Object}
|
||||
*/
|
||||
ConfigLoader.loadModels = function(rootDir, env) {
|
||||
return loadNamed(rootDir, env, 'model-config', mergeModelConfig);
|
||||
};
|
||||
|
||||
/**
|
||||
* Load middleware config from `middleware.json` and friends.
|
||||
* @param {String} rootDir Directory where to look for files.
|
||||
* @param {String} env Environment, usually `process.env.NODE_ENV`
|
||||
* @returns {Object}
|
||||
*/
|
||||
ConfigLoader.loadMiddleware = function(rootDir, env) {
|
||||
return loadNamed(rootDir, env, 'middleware', mergeMiddlewareConfig);
|
||||
};
|
||||
|
||||
/**
|
||||
* Load component config from `component-config.json` and friends.
|
||||
* @param {String} rootDir Directory where to look for files.
|
||||
* @param {String} env Environment, usually `process.env.NODE_ENV`
|
||||
* @returns {Object}
|
||||
*/
|
||||
ConfigLoader.loadComponents = function(rootDir, env) {
|
||||
return loadNamed(rootDir, env, 'component-config', mergeComponentConfig);
|
||||
};
|
||||
|
||||
/*-- Implementation --*/
|
||||
|
||||
/**
|
||||
* Load named configuration.
|
||||
* @param {String} rootDir Directory where to look for files.
|
||||
* @param {String} env Environment, usually `process.env.NODE_ENV`
|
||||
* @param {String} name
|
||||
* @param {function(target:Object, config:Object, filename:String)} mergeFn
|
||||
* @returns {Object}
|
||||
*/
|
||||
function loadNamed(rootDir, env, name, mergeFn) {
|
||||
var files = findConfigFiles(rootDir, env, name);
|
||||
if (files.length) {
|
||||
debug('found %s %s files', env, name);
|
||||
files.forEach(function(f) { debug(' %s', f); });
|
||||
}
|
||||
var configs = loadConfigFiles(files);
|
||||
var merged = mergeConfigurations(configs, mergeFn);
|
||||
|
||||
debug('merged %s %s configuration %j', env, name, merged);
|
||||
|
||||
return merged;
|
||||
}
|
||||
|
||||
/**
|
||||
* Search `appRootDir` for all files containing configuration for `name`.
|
||||
* @param {String} appRootDir
|
||||
* @param {String} env Environment, usually `process.env.NODE_ENV`
|
||||
* @param {String} name
|
||||
* @returns {Array.<String>} Array of absolute file paths.
|
||||
*/
|
||||
function findConfigFiles(appRootDir, env, name) {
|
||||
var master = ifExists(name + '.json');
|
||||
if (!master && (ifExistsWithAnyExt(name + '.local') ||
|
||||
ifExistsWithAnyExt(name + '.' + env))) {
|
||||
g.warn('WARNING: Main {{config}} file "%s.json" is missing', name);
|
||||
}
|
||||
if (!master) return [];
|
||||
|
||||
var candidates = [
|
||||
master,
|
||||
ifExistsWithAnyExt(name + '.local'),
|
||||
ifExistsWithAnyExt(name + '.' + env),
|
||||
];
|
||||
|
||||
return candidates.filter(function(c) { return c !== undefined; });
|
||||
|
||||
function ifExists(fileName) {
|
||||
var filepath = path.resolve(appRootDir, fileName);
|
||||
return utils.fileExistsSync(filepath) ? filepath : undefined;
|
||||
}
|
||||
|
||||
function ifExistsWithAnyExt(fileName) {
|
||||
return ifExists(fileName + '.js') || ifExists(fileName + '.json');
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Load configuration files into an array of objects.
|
||||
* Attach non-enumerable `_filename` property to each object.
|
||||
* @param {Array.<String>} files
|
||||
* @returns {Array.<Object>}
|
||||
*/
|
||||
function loadConfigFiles(files) {
|
||||
return files.map(function(f) {
|
||||
var config = cloneDeep(require(f));
|
||||
Object.defineProperty(config, '_filename', {
|
||||
enumerable: false,
|
||||
value: f,
|
||||
});
|
||||
debug('loaded config file %s: %j', f, config);
|
||||
return config;
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Merge multiple configuration objects into a single one.
|
||||
* @param {Array.<Object>} configObjects
|
||||
* @param {function(target:Object, config:Object, filename:String)} mergeFn
|
||||
*/
|
||||
function mergeConfigurations(configObjects, mergeFn) {
|
||||
var result = configObjects.shift() || {};
|
||||
while (configObjects.length) {
|
||||
var next = configObjects.shift();
|
||||
mergeFn(result, next, next._filename);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
function mergeDataSourceConfig(target, config, fileName) {
|
||||
var err = mergeObjects(target, config);
|
||||
if (err) {
|
||||
throw new Error(g.f('Cannot apply %s: %s', fileName, err));
|
||||
}
|
||||
}
|
||||
|
||||
function mergeModelConfig(target, config, fileName) {
|
||||
var err = mergeObjects(target, config);
|
||||
if (err) {
|
||||
throw new Error(g.f('Cannot apply %s: %s', fileName, err));
|
||||
}
|
||||
}
|
||||
|
||||
function mergeAppConfig(target, config, fileName) {
|
||||
var err = mergeObjects(target, config);
|
||||
if (err) {
|
||||
throw new Error(g.f('Cannot apply %s: %s', fileName, err));
|
||||
}
|
||||
}
|
||||
|
||||
function mergeMiddlewareConfig(target, config, fileName) {
|
||||
var err = undefined; // see https://github.com/eslint/eslint/issues/5744
|
||||
for (var phase in config) {
|
||||
if (phase in target) {
|
||||
err = mergePhaseConfig(target[phase], config[phase], phase);
|
||||
} else {
|
||||
err = g.f('The {{phase}} "%s" is not defined in the main config.', phase);
|
||||
}
|
||||
if (err)
|
||||
throw new Error(g.f('Cannot apply %s: %s', fileName, err));
|
||||
}
|
||||
}
|
||||
|
||||
function mergeNamedItems(arr1, arr2, key) {
|
||||
assert(Array.isArray(arr1), g.f('invalid array: %s', arr1));
|
||||
assert(Array.isArray(arr2), g.f('invalid array: %s', arr2));
|
||||
key = key || 'name';
|
||||
var result = [].concat(arr1);
|
||||
for (var i = 0, n = arr2.length; i < n; i++) {
|
||||
var item = arr2[i];
|
||||
var found = false;
|
||||
if (item[key]) {
|
||||
for (var j = 0, k = result.length; j < k; j++) {
|
||||
if (result[j][key] === item[key]) {
|
||||
mergeObjects(result[j], item);
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!found) {
|
||||
result.push(item);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
function mergePhaseConfig(target, config, phase) {
|
||||
var err = undefined; // see https://github.com/eslint/eslint/issues/5744
|
||||
for (var mw in config) {
|
||||
if (mw in target) {
|
||||
var targetMiddleware = target[mw];
|
||||
var configMiddleware = config[mw];
|
||||
if (Array.isArray(targetMiddleware) && Array.isArray(configMiddleware)) {
|
||||
// Both are arrays, combine them
|
||||
target[mw] = mergeNamedItems(targetMiddleware, configMiddleware);
|
||||
} else if (Array.isArray(targetMiddleware)) {
|
||||
if (typeof configMiddleware === 'object' &&
|
||||
Object.keys(configMiddleware).length) {
|
||||
// Config side is an non-empty object
|
||||
target[mw] = mergeNamedItems(targetMiddleware, [configMiddleware]);
|
||||
}
|
||||
} else if (Array.isArray(configMiddleware)) {
|
||||
if (typeof targetMiddleware === 'object' &&
|
||||
Object.keys(targetMiddleware).length) {
|
||||
// Target side is an non-empty object
|
||||
target[mw] = mergeNamedItems([targetMiddleware], configMiddleware);
|
||||
} else {
|
||||
// Target side is empty
|
||||
target[mw] = configMiddleware;
|
||||
}
|
||||
} else {
|
||||
err = mergeObjects(targetMiddleware, configMiddleware);
|
||||
}
|
||||
} else {
|
||||
err = g.f('The {{middleware}} "%s" in phase "%s"' +
|
||||
'is not defined in the main config.', mw, phase);
|
||||
}
|
||||
if (err) return err;
|
||||
}
|
||||
}
|
||||
|
||||
function mergeComponentConfig(target, config, fileName) {
|
||||
var err = mergeObjects(target, config);
|
||||
if (err) {
|
||||
throw new Error(g.f('Cannot apply %s: %s', fileName, err));
|
||||
}
|
||||
}
|
||||
|
||||
function mergeObjects(target, config, keyPrefix) {
|
||||
for (var key in config) {
|
||||
var fullKey = keyPrefix ? keyPrefix + '.' + key : key;
|
||||
var err = mergeSingleItemOrProperty(target, config, key, fullKey);
|
||||
if (err) return err;
|
||||
}
|
||||
return null; // no error
|
||||
}
|
||||
|
||||
function mergeSingleItemOrProperty(target, config, key, fullKey) {
|
||||
var origValue = target[key];
|
||||
var newValue = config[key];
|
||||
|
||||
if (!hasCompatibleType(origValue, newValue)) {
|
||||
return 'Cannot merge values of incompatible types for the option `' +
|
||||
fullKey + '`.';
|
||||
}
|
||||
|
||||
if (Array.isArray(origValue)) {
|
||||
return mergeArrays(origValue, newValue, fullKey);
|
||||
}
|
||||
|
||||
if (newValue !== null && typeof origValue === 'object') {
|
||||
return mergeObjects(origValue, newValue, fullKey);
|
||||
}
|
||||
|
||||
target[key] = newValue;
|
||||
return null; // no error
|
||||
}
|
||||
|
||||
function mergeArrays(target, config, keyPrefix) {
|
||||
if (target.length !== config.length) {
|
||||
return 'Cannot merge array values of different length' +
|
||||
' for the option `' + keyPrefix + '`.';
|
||||
}
|
||||
|
||||
// Use for(;;) to iterate over undefined items, for(in) would skip them.
|
||||
for (var ix = 0; ix < target.length; ix++) {
|
||||
var fullKey = keyPrefix + '[' + ix + ']';
|
||||
var err = mergeSingleItemOrProperty(target, config, ix, fullKey);
|
||||
if (err) return err;
|
||||
}
|
||||
|
||||
return null; // no error
|
||||
}
|
||||
|
||||
function hasCompatibleType(origValue, newValue) {
|
||||
if (origValue === null || origValue === undefined)
|
||||
return true;
|
||||
|
||||
if (Array.isArray(origValue))
|
||||
return Array.isArray(newValue);
|
||||
|
||||
if (typeof origValue === 'object')
|
||||
return typeof newValue === 'object';
|
||||
|
||||
// Note: typeof Array() is 'object' too,
|
||||
// we don't need to explicitly check array types
|
||||
return typeof newValue !== 'object';
|
||||
}
|
||||
454
lib/executor.js
454
lib/executor.js
|
|
@ -1,454 +0,0 @@
|
|||
// Copyright IBM Corp. 2014,2016. All Rights Reserved.
|
||||
// Node module: loopback-boot
|
||||
// This file is licensed under the MIT License.
|
||||
// License text available at https://opensource.org/licenses/MIT
|
||||
|
||||
var assert = require('assert');
|
||||
var semver = require('semver');
|
||||
var debug = require('debug')('loopback:boot:executor');
|
||||
var async = require('async');
|
||||
var path = require('path');
|
||||
var format = require('util').format;
|
||||
var g = require('strong-globalize')();
|
||||
|
||||
/**
|
||||
* Execute bootstrap instructions gathered by `boot.compile`.
|
||||
*
|
||||
* @param {Object} app The loopback app to boot.
|
||||
* @options {Object} instructions Boot instructions.
|
||||
* @param {Function} [callback] Callback function.
|
||||
*
|
||||
* @header boot.execute(instructions)
|
||||
*/
|
||||
|
||||
module.exports = function execute(app, instructions, callback) {
|
||||
callback = callback || function() {};
|
||||
|
||||
app.booting = true;
|
||||
|
||||
patchAppLoopback(app);
|
||||
assertLoopBackVersion(app);
|
||||
|
||||
setEnv(app, instructions);
|
||||
setHost(app, instructions);
|
||||
setPort(app, instructions);
|
||||
setApiRoot(app, instructions);
|
||||
applyAppConfig(app, instructions);
|
||||
|
||||
setupDataSources(app, instructions);
|
||||
setupModels(app, instructions);
|
||||
setupMiddleware(app, instructions);
|
||||
setupComponents(app, instructions);
|
||||
|
||||
// Run the boot scripts in series synchronously or asynchronously
|
||||
// Please note async supports both styles
|
||||
async.series([
|
||||
function(done) {
|
||||
runBootScripts(app, instructions, done);
|
||||
},
|
||||
function(done) {
|
||||
enableAnonymousSwagger(app, instructions);
|
||||
done();
|
||||
},
|
||||
// Ensure both the "booted" event and the callback are always called
|
||||
// in the next tick of the even loop.
|
||||
// See http://blog.izs.me/post/59142742143/designing-apis-for-asynchrony
|
||||
process.nextTick,
|
||||
], function(err) {
|
||||
app.booting = false;
|
||||
|
||||
if (err) return callback(err);
|
||||
|
||||
app.emit('booted');
|
||||
|
||||
callback();
|
||||
});
|
||||
};
|
||||
|
||||
function patchAppLoopback(app) {
|
||||
if (app.loopback) return;
|
||||
// app.loopback was introduced in 1.9.0
|
||||
// patch the app object to make loopback-boot work with older versions too
|
||||
try {
|
||||
app.loopback = require('loopback');
|
||||
} catch (err) {
|
||||
if (err.code === 'MODULE_NOT_FOUND') {
|
||||
g.error(
|
||||
'When using {{loopback-boot}} with {{loopback}} <1.9, ' +
|
||||
'the {{loopback}} module must be available ' +
|
||||
'for `{{require(\'loopback\')}}`.');
|
||||
}
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
|
||||
function assertLoopBackVersion(app) {
|
||||
var RANGE = '1.x || 2.x || ^3.0.0-alpha';
|
||||
|
||||
var loopback = app.loopback;
|
||||
// remove any pre-release tag from the version string,
|
||||
// because semver has special treatment of pre-release versions,
|
||||
// while loopback-boot treats pre-releases the same way as regular versions
|
||||
var version = (loopback.version || '1.0.0').replace(/-.*$/, '');
|
||||
if (!semver.satisfies(version, RANGE)) {
|
||||
var msg = g.f(
|
||||
'The `{{app}}` is powered by an incompatible {{loopback}} version %s. ' +
|
||||
'Supported versions: %s',
|
||||
loopback.version || '(unknown)',
|
||||
RANGE);
|
||||
throw new Error(msg);
|
||||
}
|
||||
}
|
||||
|
||||
function setEnv(app, instructions) {
|
||||
var env = instructions.env;
|
||||
if (env !== undefined)
|
||||
app.set('env', env);
|
||||
}
|
||||
|
||||
function setHost(app, instructions) {
|
||||
// jscs:disable requireCamelCaseOrUpperCaseIdentifiers
|
||||
var host =
|
||||
process.env.npm_config_host ||
|
||||
process.env.OPENSHIFT_SLS_IP ||
|
||||
process.env.OPENSHIFT_NODEJS_IP ||
|
||||
process.env.HOST ||
|
||||
process.env.VCAP_APP_HOST ||
|
||||
instructions.config.host ||
|
||||
process.env.npm_package_config_host ||
|
||||
app.get('host');
|
||||
|
||||
if (host !== undefined) {
|
||||
assert(typeof host === 'string', g.f('{{app.host}} must be a {{string}}'));
|
||||
app.set('host', host);
|
||||
}
|
||||
}
|
||||
|
||||
function setPort(app, instructions) {
|
||||
// jscs:disable requireCamelCaseOrUpperCaseIdentifiers
|
||||
var port = find([
|
||||
process.env.npm_config_port,
|
||||
process.env.OPENSHIFT_SLS_PORT,
|
||||
process.env.OPENSHIFT_NODEJS_PORT,
|
||||
process.env.PORT,
|
||||
process.env.VCAP_APP_PORT,
|
||||
instructions.config.port,
|
||||
process.env.npm_package_config_port,
|
||||
app.get('port'),
|
||||
3000,
|
||||
], function(p) {
|
||||
return p != null;
|
||||
});
|
||||
|
||||
if (port !== undefined) {
|
||||
var portType = typeof port;
|
||||
assert(portType === 'string' || portType === 'number',
|
||||
g.f('{{app.port}} must be a {{string}} or {{number}}'));
|
||||
app.set('port', port);
|
||||
}
|
||||
}
|
||||
|
||||
function find(array, predicate) {
|
||||
return array.filter(predicate)[0];
|
||||
}
|
||||
|
||||
function setApiRoot(app, instructions) {
|
||||
var restApiRoot =
|
||||
instructions.config.restApiRoot ||
|
||||
app.get('restApiRoot') ||
|
||||
'/api';
|
||||
|
||||
assert(restApiRoot !== undefined, g.f('{{app.restBasePath}} is required'));
|
||||
assert(typeof restApiRoot === 'string',
|
||||
g.f('{{app.restApiRoot}} must be a {{string}}'));
|
||||
assert(/^\//.test(restApiRoot),
|
||||
g.f('{{app.restApiRoot}} must start with "/"'));
|
||||
app.set('restApiRoot', restApiRoot);
|
||||
}
|
||||
|
||||
function applyAppConfig(app, instructions) {
|
||||
var appConfig = instructions.config;
|
||||
for (var configKey in appConfig) {
|
||||
var cur = app.get(configKey);
|
||||
if (cur === undefined || cur === null) {
|
||||
app.set(configKey, appConfig[configKey]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function setupDataSources(app, instructions) {
|
||||
forEachKeyedObject(instructions.dataSources, function(key, obj) {
|
||||
var opts = {
|
||||
useEnvVars: true,
|
||||
};
|
||||
obj = getUpdatedConfigObject(app, obj, opts);
|
||||
var lazyConnect = process.env.LB_LAZYCONNECT_DATASOURCES;
|
||||
if (lazyConnect) {
|
||||
obj.lazyConnect =
|
||||
lazyConnect === 'false' || lazyConnect === '0' ? false : true;
|
||||
}
|
||||
app.dataSource(key, obj);
|
||||
});
|
||||
}
|
||||
|
||||
function setupModels(app, instructions) {
|
||||
defineMixins(app, instructions);
|
||||
defineModels(app, instructions);
|
||||
|
||||
instructions.models.forEach(function(data) {
|
||||
// Skip base models that are not exported to the app
|
||||
if (!data.config) return;
|
||||
|
||||
app.model(data._model, data.config);
|
||||
});
|
||||
}
|
||||
|
||||
function defineMixins(app, instructions) {
|
||||
var modelBuilder = (app.registry || app.loopback).modelBuilder;
|
||||
var BaseClass = app.loopback.Model;
|
||||
var mixins = instructions.mixins || [];
|
||||
|
||||
if (!modelBuilder.mixins || !mixins.length) return;
|
||||
|
||||
mixins.forEach(function(obj) {
|
||||
var mixin = require(obj.sourceFile);
|
||||
|
||||
if (typeof mixin === 'function' || mixin.prototype instanceof BaseClass) {
|
||||
debug('Defining mixin %s', obj.name);
|
||||
modelBuilder.mixins.define(obj.name, mixin); // TODO (name, mixin, meta)
|
||||
} else {
|
||||
debug('Skipping mixin file %s - `module.exports` is not a function' +
|
||||
' or Loopback model', obj);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function defineModels(app, instructions) {
|
||||
var registry = app.registry || app.loopback;
|
||||
instructions.models.forEach(function(data) {
|
||||
var name = data.name;
|
||||
var model;
|
||||
|
||||
if (!data.definition) {
|
||||
model = registry.getModel(name);
|
||||
if (!model) {
|
||||
throw new Error(g.f('Cannot configure unknown model %s', name));
|
||||
}
|
||||
debug('Configuring existing model %s', name);
|
||||
} else if (isBuiltinLoopBackModel(app, data)) {
|
||||
model = registry.getModel(name);
|
||||
assert(model, g.f('Built-in model %s should have been defined', name));
|
||||
debug('Configuring built-in LoopBack model %s', name);
|
||||
} else {
|
||||
debug('Creating new model %s %j', name, data.definition);
|
||||
model = registry.createModel(data.definition);
|
||||
if (data.sourceFile) {
|
||||
debug('Loading customization script %s', data.sourceFile);
|
||||
var code = require(data.sourceFile);
|
||||
if (typeof code === 'function') {
|
||||
debug('Customizing model %s', name);
|
||||
code(model);
|
||||
} else {
|
||||
debug('Skipping model file %s - `module.exports` is not a function',
|
||||
data.sourceFile);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
data._model = model;
|
||||
});
|
||||
}
|
||||
|
||||
// Regular expression to match built-in loopback models
|
||||
var LOOPBACK_MODEL_REGEXP = new RegExp(
|
||||
['', 'node_modules', 'loopback', '[^\\/\\\\]+', 'models', '[^\\/\\\\]+\\.js$']
|
||||
.join('\\' + path.sep));
|
||||
|
||||
function isBuiltinLoopBackModel(app, data) {
|
||||
// 1. Built-in models are exposed on the loopback object
|
||||
if (!app.loopback[data.name]) return false;
|
||||
|
||||
// 2. Built-in models have a script file `loopback/{facet}/models/{name}.js`
|
||||
var srcFile = data.sourceFile;
|
||||
return srcFile &&
|
||||
LOOPBACK_MODEL_REGEXP.test(srcFile);
|
||||
}
|
||||
|
||||
function forEachKeyedObject(obj, fn) {
|
||||
if (typeof obj !== 'object') return;
|
||||
|
||||
Object.keys(obj).forEach(function(key) {
|
||||
fn(key, obj[key]);
|
||||
});
|
||||
}
|
||||
|
||||
function runScripts(app, list, callback) {
|
||||
list = list || [];
|
||||
var functions = [];
|
||||
list.forEach(function(filepath) {
|
||||
debug('Requiring script %s', filepath);
|
||||
try {
|
||||
var exports = require(filepath);
|
||||
if (typeof exports === 'function') {
|
||||
debug('Exported function detected %s', filepath);
|
||||
functions.push({
|
||||
path: filepath,
|
||||
func: exports,
|
||||
});
|
||||
}
|
||||
} catch (err) {
|
||||
g.error('Failed loading boot script: %s\n%s', filepath, err.stack);
|
||||
throw err;
|
||||
}
|
||||
});
|
||||
|
||||
async.eachSeries(functions, function(f, done) {
|
||||
debug('Running script %s', f.path);
|
||||
if (f.func.length >= 2) {
|
||||
debug('Starting async function %s', f.path);
|
||||
f.func(app, function(err) {
|
||||
debug('Async function finished %s', f.path);
|
||||
done(err);
|
||||
});
|
||||
} else {
|
||||
debug('Starting sync function %s', f.path);
|
||||
f.func(app);
|
||||
debug('Sync function finished %s', f.path);
|
||||
done();
|
||||
}
|
||||
}, callback);
|
||||
}
|
||||
|
||||
function setupMiddleware(app, instructions) {
|
||||
if (!instructions.middleware) {
|
||||
// the browserified client does not support middleware
|
||||
return;
|
||||
}
|
||||
|
||||
// Phases can be empty
|
||||
var phases = instructions.middleware.phases || [];
|
||||
assert(Array.isArray(phases),
|
||||
g.f('{{instructions.middleware.phases}} must be an {{array}}'));
|
||||
|
||||
var middleware = instructions.middleware.middleware;
|
||||
assert(Array.isArray(middleware),
|
||||
'instructions.middleware.middleware must be an object');
|
||||
|
||||
debug('Defining middleware phases %j', phases);
|
||||
app.defineMiddlewarePhases(phases);
|
||||
|
||||
middleware.forEach(function(data) {
|
||||
debug('Configuring middleware %j%s', data.sourceFile,
|
||||
data.fragment ? ('#' + data.fragment) : '');
|
||||
var factory = require(data.sourceFile);
|
||||
if (data.fragment) {
|
||||
factory = factory[data.fragment].bind(factory);
|
||||
}
|
||||
assert(typeof factory === 'function',
|
||||
'Middleware factory must be a function');
|
||||
var opts = {
|
||||
useEnvVars: true,
|
||||
};
|
||||
data.config = getUpdatedConfigObject(app, data.config, opts);
|
||||
app.middlewareFromConfig(factory, data.config);
|
||||
});
|
||||
}
|
||||
|
||||
function getUpdatedConfigObject(app, config, opts) {
|
||||
var DYNAMIC_CONFIG_PARAM = /\$\{(\w+)\}$/;
|
||||
var useEnvVars = opts && opts.useEnvVars;
|
||||
|
||||
function getConfigVariable(param) {
|
||||
var configVariable = param;
|
||||
var match = configVariable.match(DYNAMIC_CONFIG_PARAM);
|
||||
if (match) {
|
||||
var varName = match[1];
|
||||
if (useEnvVars && process.env[varName] !== undefined) {
|
||||
debug('Dynamic Configuration: Resolved via process.env: %s as %s',
|
||||
process.env[varName], param);
|
||||
configVariable = process.env[varName];
|
||||
} else if (app.get(varName) !== undefined) {
|
||||
debug('Dynamic Configuration: Resolved via app.get(): %s as %s',
|
||||
app.get(varName), param);
|
||||
var appValue = app.get(varName);
|
||||
configVariable = appValue;
|
||||
} else {
|
||||
// previously it returns the original string such as "${restApiRoot}"
|
||||
// it will now return `undefined`, for the use case of
|
||||
// dynamic datasources url:`undefined` to fallback to other parameters
|
||||
configVariable = undefined;
|
||||
g.warn('%s does not resolve to a valid value, returned as %s. ' +
|
||||
'"%s" must be resolvable in Environment variable or by app.get().',
|
||||
param, configVariable, varName);
|
||||
debug('Dynamic Configuration: Cannot resolve variable for `%s`, ' +
|
||||
'returned as %s', varName, configVariable);
|
||||
}
|
||||
}
|
||||
return configVariable;
|
||||
}
|
||||
|
||||
function interpolateVariables(config) {
|
||||
// config is a string and contains a config variable ('${var}')
|
||||
if (typeof config === 'string')
|
||||
return getConfigVariable(config);
|
||||
|
||||
// anything but an array or object
|
||||
if (typeof config !== 'object' || config == null)
|
||||
return config;
|
||||
|
||||
// recurse into array elements
|
||||
if (Array.isArray(config))
|
||||
return config.map(interpolateVariables);
|
||||
|
||||
// Not a plain object. Examples: RegExp, Date,
|
||||
if (!config.constructor || config.constructor !== Object)
|
||||
return config;
|
||||
|
||||
// recurse into object props
|
||||
var interpolated = {};
|
||||
Object.keys(config).forEach(function(configKey) {
|
||||
var value = config[configKey];
|
||||
if (Array.isArray(value)) {
|
||||
interpolated[configKey] = value.map(interpolateVariables);
|
||||
} else if (typeof value === 'string') {
|
||||
interpolated[configKey] = getConfigVariable(value);
|
||||
} else if (value === null) {
|
||||
interpolated[configKey] = value;
|
||||
} else if (typeof value === 'object' && Object.keys(value).length) {
|
||||
interpolated[configKey] = interpolateVariables(value);
|
||||
} else {
|
||||
interpolated[configKey] = value;
|
||||
}
|
||||
});
|
||||
return interpolated;
|
||||
}
|
||||
|
||||
return interpolateVariables(config);
|
||||
}
|
||||
|
||||
function setupComponents(app, instructions) {
|
||||
instructions.components.forEach(function(data) {
|
||||
debug('Configuring component %j', data.sourceFile);
|
||||
var configFn = require(data.sourceFile);
|
||||
var opts = {
|
||||
useEnvVars: true,
|
||||
};
|
||||
data.config = getUpdatedConfigObject(app, data.config, opts);
|
||||
configFn(app, data.config);
|
||||
});
|
||||
}
|
||||
|
||||
function runBootScripts(app, instructions, callback) {
|
||||
runScripts(app, instructions.files.boot, callback);
|
||||
}
|
||||
|
||||
function enableAnonymousSwagger(app, instructions) {
|
||||
// disable token requirement for swagger, if available
|
||||
var swagger = app.remotes().exports.swagger;
|
||||
if (!swagger) return;
|
||||
|
||||
var appConfig = instructions.config;
|
||||
var requireTokenForSwagger = appConfig.swagger &&
|
||||
appConfig.swagger.requireToken;
|
||||
swagger.requireToken = requireTokenForSwagger || false;
|
||||
}
|
||||
|
|
@ -0,0 +1,328 @@
|
|||
var fs = require('fs');
|
||||
var path = require('path');
|
||||
var debug = require('debug')('loopback:boot:plugin');
|
||||
var assert = require('assert');
|
||||
var _ = require('lodash');
|
||||
|
||||
module.exports = PluginBase;
|
||||
|
||||
function PluginBase(options, name, artifact) {
|
||||
this.options = options || {};
|
||||
this.name = name || options.name;
|
||||
this.artifact = artifact || options.artifact;
|
||||
}
|
||||
|
||||
PluginBase.prototype.getRootDir = function() {
|
||||
return this.options.rootDir;
|
||||
};
|
||||
|
||||
PluginBase.prototype.load = function(context) {
|
||||
var rootDir = this.getRootDir() || this.options.rootDir;
|
||||
var env = this.options.env;
|
||||
assert(this.name, 'Plugin name must to be set');
|
||||
debug('Root dir: %s, env: %s, artifact: %s', rootDir, env, this.artifact);
|
||||
|
||||
var config = {};
|
||||
if (this.options[this.name]) {
|
||||
// First check if options have the corresponding config object
|
||||
config = this.options[this.name];
|
||||
} else {
|
||||
if (this.artifact) {
|
||||
config = this.loadNamed(rootDir, env, this.artifact);
|
||||
}
|
||||
}
|
||||
// Register as context.configurations.<plugin-name>
|
||||
return this.configure(context, config);
|
||||
};
|
||||
|
||||
PluginBase.prototype.configure = function(context, config) {
|
||||
config = config || {};
|
||||
// Register as context.configurations.<plugin-name>
|
||||
if (!context.configurations) {
|
||||
context.configurations = {};
|
||||
}
|
||||
context.configurations[this.name] = config;
|
||||
return config;
|
||||
};
|
||||
|
||||
PluginBase.prototype.merge = function(target, config, keyPrefix) {
|
||||
return this.mergeObjects(target, config, keyPrefix);
|
||||
};
|
||||
|
||||
/**
|
||||
* Load named configuration.
|
||||
* @param {String} rootDir Directory where to look for files.
|
||||
* @param {String} env Environment, usually `process.env.NODE_ENV`
|
||||
* @param {String} name
|
||||
* @returns {Object}
|
||||
*/
|
||||
PluginBase.prototype.loadNamed = function(rootDir, env, name) {
|
||||
var files = this.findConfigFiles(rootDir, env, name);
|
||||
if (files.length) {
|
||||
debug('found %s %s files: %j', env, name, files);
|
||||
files.forEach(function(f) {
|
||||
debug(' %s', f);
|
||||
});
|
||||
}
|
||||
var configs = this.loadConfigFiles(files);
|
||||
var merged = this.mergeConfigurations(configs);
|
||||
|
||||
debug('merged %s %s configuration %j', env, name, merged);
|
||||
|
||||
return merged;
|
||||
};
|
||||
|
||||
/**
|
||||
* Search `rootDir` for all files containing configuration for `name`.
|
||||
* @param {String} rootDir Root directory
|
||||
* @param {String} env Environment, usually `process.env.NODE_ENV`
|
||||
* @param {String} name Name
|
||||
* @param {Array.<String>} exts An array of extension names
|
||||
* @returns {Array.<String>} Array of absolute file paths.
|
||||
*/
|
||||
PluginBase.prototype.findConfigFiles = function(rootDir, env, name, exts) {
|
||||
var master = ifExists(name + '.json');
|
||||
if (!master && (ifExistsWithAnyExt(name + '.local') ||
|
||||
ifExistsWithAnyExt(name + '.' + env))) {
|
||||
console.warn('WARNING: Main config file "' + name + '.json" is missing');
|
||||
}
|
||||
if (!master) return [];
|
||||
|
||||
var candidates = [
|
||||
master,
|
||||
ifExistsWithAnyExt(name + '.common'),
|
||||
ifExistsWithAnyExt(name + '.local'),
|
||||
ifExistsWithAnyExt(name + '.' + env),
|
||||
];
|
||||
|
||||
return candidates.filter(function(c) {
|
||||
return c !== undefined;
|
||||
});
|
||||
|
||||
function ifExists(fileName) {
|
||||
var filePath = path.resolve(rootDir, fileName);
|
||||
return fs.existsSync(filePath) ? filePath : undefined;
|
||||
}
|
||||
|
||||
function ifExistsWithAnyExt(fileName) {
|
||||
var extensions = exts || ['js', 'json'];
|
||||
var file;
|
||||
for (var i = 0, n = extensions.length; i < n; i++) {
|
||||
file = ifExists(fileName + '.' + extensions[i]);
|
||||
if (file) {
|
||||
return file;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Load configuration files into an array of objects.
|
||||
* Attach non-enumerable `_filename` property to each object.
|
||||
* @param {Array.<String>} files
|
||||
* @returns {Array.<Object>}
|
||||
*/
|
||||
PluginBase.prototype.loadConfigFiles = function(files) {
|
||||
return files.map(function(f) {
|
||||
var config = require(f);
|
||||
config = _.cloneDeep(config);
|
||||
Object.defineProperty(config, '_filename', {
|
||||
enumerable: false,
|
||||
value: f,
|
||||
});
|
||||
return config;
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Merge multiple configuration objects into a single one.
|
||||
* @param {Array.<Object>} configObjects
|
||||
*/
|
||||
PluginBase.prototype.mergeConfigurations = function(configObjects) {
|
||||
var result = configObjects.shift() || {};
|
||||
while (configObjects.length) {
|
||||
var next = configObjects.shift();
|
||||
this.merge(result, next, next._filename);
|
||||
}
|
||||
return result;
|
||||
};
|
||||
|
||||
PluginBase.prototype.mergeObjects = function(target, config, keyPrefix) {
|
||||
for (var key in config) {
|
||||
var fullKey = keyPrefix ? keyPrefix + '.' + key : key;
|
||||
var err = this.mergeSingleItemOrProperty(target, config, key, fullKey);
|
||||
if (err) throw err;
|
||||
}
|
||||
return null; // no error
|
||||
};
|
||||
|
||||
PluginBase.prototype.mergeNamedItems = function(arr1, arr2, key) {
|
||||
assert(Array.isArray(arr1), 'invalid array: ' + arr1);
|
||||
assert(Array.isArray(arr2), 'invalid array: ' + arr2);
|
||||
key = key || 'name';
|
||||
var result = [].concat(arr1);
|
||||
for (var i = 0, n = arr2.length; i < n; i++) {
|
||||
var item = arr2[i];
|
||||
var found = false;
|
||||
if (item[key]) {
|
||||
for (var j = 0, k = result.length; j < k; j++) {
|
||||
if (result[j][key] === item[key]) {
|
||||
this.mergeObjects(result[j], item);
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!found) {
|
||||
result.push(item);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
};
|
||||
|
||||
PluginBase.prototype.mergeSingleItemOrProperty =
|
||||
function(target, config, key, fullKey) {
|
||||
var origValue = target[key];
|
||||
var newValue = config[key];
|
||||
|
||||
if (!hasCompatibleType(origValue, newValue)) {
|
||||
return 'Cannot merge values of incompatible types for the option `' +
|
||||
fullKey + '`.';
|
||||
}
|
||||
|
||||
if (Array.isArray(origValue)) {
|
||||
return this.mergeArrays(origValue, newValue, fullKey);
|
||||
}
|
||||
|
||||
if (newValue !== null && typeof origValue === 'object') {
|
||||
return this.mergeObjects(origValue, newValue, fullKey);
|
||||
}
|
||||
|
||||
target[key] = newValue;
|
||||
return null; // no error
|
||||
};
|
||||
|
||||
PluginBase.prototype.mergeArrays = function(target, config, keyPrefix) {
|
||||
if (target.length !== config.length) {
|
||||
return 'Cannot merge array values of different length' +
|
||||
' for the option `' + keyPrefix + '`.';
|
||||
}
|
||||
|
||||
// Use for(;;) to iterate over undefined items, for(in) would skip them.
|
||||
for (var ix = 0; ix < target.length; ix++) {
|
||||
var fullKey = keyPrefix + '[' + ix + ']';
|
||||
var err = this.mergeSingleItemOrProperty(target, config, ix, fullKey);
|
||||
if (err) return err;
|
||||
}
|
||||
|
||||
return null; // no error
|
||||
};
|
||||
|
||||
function hasCompatibleType(origValue, newValue) {
|
||||
if (origValue === null || origValue === undefined)
|
||||
return true;
|
||||
|
||||
if (Array.isArray(origValue))
|
||||
return Array.isArray(newValue);
|
||||
|
||||
if (typeof origValue === 'object')
|
||||
return typeof newValue === 'object';
|
||||
|
||||
// Note: typeof Array() is 'object' too,
|
||||
// we don't need to explicitly check array types
|
||||
return typeof newValue !== 'object';
|
||||
}
|
||||
|
||||
PluginBase.prototype.compile = function(context) {
|
||||
var instructions;
|
||||
if (typeof this.buildInstructions === 'function') {
|
||||
var rootDir = this.options.rootDir;
|
||||
var config = context.configurations[this.name] || {};
|
||||
instructions = this.buildInstructions(context, rootDir, config);
|
||||
} else {
|
||||
instructions = context.configurations[this.name];
|
||||
}
|
||||
|
||||
// Register as context.instructions.<plugin-name>
|
||||
if (!context.instructions) {
|
||||
context.instructions = {};
|
||||
if (this.options.appId) {
|
||||
context.instructions.appId = this.options.appId;
|
||||
}
|
||||
}
|
||||
context.instructions[this.name] = instructions;
|
||||
|
||||
return undefined;
|
||||
};
|
||||
|
||||
var DYNAMIC_CONFIG_PARAM = /\$\{(\w+)\}$/;
|
||||
function getConfigVariable(app, param, useEnvVars) {
|
||||
var configVariable = param;
|
||||
var match = configVariable.match(DYNAMIC_CONFIG_PARAM);
|
||||
if (match) {
|
||||
var varName = match[1];
|
||||
if (useEnvVars && process.env[varName] !== undefined) {
|
||||
debug('Dynamic Configuration: Resolved via process.env: %s as %s',
|
||||
process.env[varName], param);
|
||||
configVariable = process.env[varName];
|
||||
} else if (app.get(varName) !== undefined) {
|
||||
debug('Dynamic Configuration: Resolved via app.get(): %s as %s',
|
||||
app.get(varName), param);
|
||||
var appValue = app.get(varName);
|
||||
configVariable = appValue;
|
||||
} else {
|
||||
// previously it returns the original string such as "${restApiRoot}"
|
||||
// it will now return `undefined`, for the use case of
|
||||
// dynamic datasources url:`undefined` to fallback to other parameters
|
||||
configVariable = undefined;
|
||||
console.warn('%s does not resolve to a valid value, returned as %s. ' +
|
||||
'"%s" must be resolvable in Environment variable or by app.get().',
|
||||
param, configVariable, varName);
|
||||
debug('Dynamic Configuration: Cannot resolve variable for `%s`, ' +
|
||||
'returned as %s', varName, configVariable);
|
||||
}
|
||||
}
|
||||
return configVariable;
|
||||
}
|
||||
|
||||
PluginBase.prototype.getUpdatedConfigObject = function(context, config, opts) {
|
||||
var app = context.app;
|
||||
var useEnvVars = opts && opts.useEnvVars;
|
||||
|
||||
function interpolateVariables(config) {
|
||||
// config is a string and contains a config variable ('${var}')
|
||||
if (typeof config === 'string')
|
||||
return getConfigVariable(app, config, useEnvVars);
|
||||
|
||||
// anything but an array or object
|
||||
if (typeof config !== 'object' || config == null)
|
||||
return config;
|
||||
|
||||
// recurse into array elements
|
||||
if (Array.isArray(config))
|
||||
return config.map(interpolateVariables);
|
||||
|
||||
// Not a plain object. Examples: RegExp, Date,
|
||||
if (!config.constructor || config.constructor !== Object)
|
||||
return config;
|
||||
|
||||
// recurse into object props
|
||||
var interpolated = {};
|
||||
Object.keys(config).forEach(function(configKey) {
|
||||
var value = config[configKey];
|
||||
if (Array.isArray(value)) {
|
||||
interpolated[configKey] = value.map(interpolateVariables);
|
||||
} else if (typeof value === 'string') {
|
||||
interpolated[configKey] = getConfigVariable(app, value, useEnvVars);
|
||||
} else if (value === null) {
|
||||
interpolated[configKey] = value;
|
||||
} else if (typeof value === 'object' && Object.keys(value).length) {
|
||||
interpolated[configKey] = interpolateVariables(value);
|
||||
} else {
|
||||
interpolated[configKey] = value;
|
||||
}
|
||||
});
|
||||
return interpolated;
|
||||
}
|
||||
return interpolateVariables(config);
|
||||
};
|
||||
|
|
@ -0,0 +1,147 @@
|
|||
var util = require('util');
|
||||
var assert = require('assert');
|
||||
var semver = require('semver');
|
||||
var format = require('util').format;
|
||||
var PluginBase = require('../plugin-base');
|
||||
|
||||
module.exports = function(options) {
|
||||
return new Application(options);
|
||||
};
|
||||
|
||||
function Application(options) {
|
||||
PluginBase.call(this, options, 'application', 'config');
|
||||
}
|
||||
|
||||
util.inherits(Application, PluginBase);
|
||||
|
||||
function patchAppLoopback(app) {
|
||||
if (app.loopback) return;
|
||||
// app.loopback was introduced in 1.9.0
|
||||
// patch the app object to make loopback-boot work with older versions too
|
||||
try {
|
||||
app.loopback = require('loopback');
|
||||
} catch (err) {
|
||||
if (err.code === 'MODULE_NOT_FOUND') {
|
||||
console.error(
|
||||
'When using loopback-boot with loopback <1.9, ' +
|
||||
'the loopback module must be available for `require(\'loopback\')`.');
|
||||
}
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
|
||||
function assertLoopBackVersion(app) {
|
||||
var RANGE = '1.x || 2.x || ^3.0.0-alpha';
|
||||
|
||||
var loopback = app.loopback;
|
||||
// remove any pre-release tag from the version string,
|
||||
// because semver has special treatment of pre-release versions,
|
||||
// while loopback-boot treats pre-releases the same way as regular versions
|
||||
var version = (loopback.version || '1.0.0').replace(/-.*$/, '');
|
||||
if (!semver.satisfies(version, RANGE)) {
|
||||
var msg = format(
|
||||
'The `app` is powered by an incompatible loopback version %s. ' +
|
||||
'Supported versions: %s',
|
||||
loopback.version || '(unknown)',
|
||||
RANGE);
|
||||
throw new Error(msg);
|
||||
}
|
||||
}
|
||||
|
||||
function setEnv(app, env) {
|
||||
if (env !== undefined)
|
||||
app.set('env', env);
|
||||
}
|
||||
|
||||
function setHost(app, appConfig) {
|
||||
// jscs:disable requireCamelCaseOrUpperCaseIdentifiers
|
||||
var host =
|
||||
process.env.npm_config_host ||
|
||||
process.env.OPENSHIFT_SLS_IP ||
|
||||
process.env.OPENSHIFT_NODEJS_IP ||
|
||||
process.env.HOST ||
|
||||
process.env.VCAP_APP_HOST ||
|
||||
appConfig.host ||
|
||||
process.env.npm_package_config_host ||
|
||||
app.get('host');
|
||||
|
||||
if (host !== undefined) {
|
||||
assert(typeof host === 'string', 'app.host must be a string');
|
||||
app.set('host', host);
|
||||
}
|
||||
}
|
||||
|
||||
function setPort(app, appConfig) {
|
||||
// jscs:disable requireCamelCaseOrUpperCaseIdentifiers
|
||||
var port = find([
|
||||
process.env.npm_config_port,
|
||||
process.env.OPENSHIFT_SLS_PORT,
|
||||
process.env.OPENSHIFT_NODEJS_PORT,
|
||||
process.env.PORT,
|
||||
process.env.VCAP_APP_PORT,
|
||||
appConfig.port,
|
||||
process.env.npm_package_config_port,
|
||||
app.get('port'),
|
||||
3000,
|
||||
], function(p) {
|
||||
return p != null;
|
||||
});
|
||||
|
||||
if (port !== undefined) {
|
||||
var portType = typeof port;
|
||||
assert(portType === 'string' || portType === 'number',
|
||||
'app.port must be a string or number');
|
||||
app.set('port', port);
|
||||
}
|
||||
}
|
||||
|
||||
function find(array, predicate) {
|
||||
return array.filter(predicate)[0];
|
||||
}
|
||||
|
||||
function setApiRoot(app, appConfig) {
|
||||
var restApiRoot =
|
||||
appConfig.restApiRoot ||
|
||||
app.get('restApiRoot') ||
|
||||
'/api';
|
||||
|
||||
assert(restApiRoot !== undefined, 'app.restBasePath is required');
|
||||
assert(typeof restApiRoot === 'string',
|
||||
'app.restApiRoot must be a string');
|
||||
assert(/^\//.test(restApiRoot),
|
||||
'app.restApiRoot must start with "/"');
|
||||
app.set('restApiRoot', restApiRoot);
|
||||
}
|
||||
|
||||
function applyAppConfig(app, appConfig) {
|
||||
for (var configKey in appConfig) {
|
||||
var cur = app.get(configKey);
|
||||
if (cur === undefined || cur === null) {
|
||||
app.set(configKey, appConfig[configKey]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Application.prototype.starting = function(context) {
|
||||
var app = context.app;
|
||||
app.booting = true;
|
||||
|
||||
patchAppLoopback(app);
|
||||
assertLoopBackVersion(app);
|
||||
|
||||
var appConfig = context.instructions.application;
|
||||
setEnv(app, context.instructions.env || this.options.env);
|
||||
setHost(app, appConfig);
|
||||
setPort(app, appConfig);
|
||||
setApiRoot(app, appConfig);
|
||||
applyAppConfig(app, appConfig);
|
||||
};
|
||||
|
||||
Application.prototype.started = function(context, done) {
|
||||
var app = context.app;
|
||||
app.booting = false;
|
||||
process.nextTick(function() {
|
||||
app.emit('booted');
|
||||
done();
|
||||
});
|
||||
};
|
||||
|
|
@ -0,0 +1,85 @@
|
|||
var util = require('util');
|
||||
var utils = require('../utils');
|
||||
var path = require('path');
|
||||
var async = require('async');
|
||||
var debug = require('debug')('loopback:boot:script');
|
||||
var PluginBase = require('../plugin-base');
|
||||
var _ = require('lodash');
|
||||
|
||||
module.exports = function(options) {
|
||||
return new Script(options);
|
||||
};
|
||||
|
||||
function Script(options) {
|
||||
PluginBase.call(this, options, 'bootScripts', null);
|
||||
}
|
||||
|
||||
util.inherits(Script, PluginBase);
|
||||
|
||||
Script.prototype.load = function(context) {
|
||||
var options = this.options;
|
||||
var appRootDir = options.rootDir;
|
||||
// require directories
|
||||
var bootDirs = options.bootDirs || []; // precedence
|
||||
bootDirs = bootDirs.concat(path.join(appRootDir, 'boot'));
|
||||
utils.resolveRelativePaths(bootDirs, appRootDir);
|
||||
|
||||
var bootScripts = options.bootScripts || [];
|
||||
utils.resolveRelativePaths(bootScripts, appRootDir);
|
||||
|
||||
bootDirs.forEach(function(dir) {
|
||||
bootScripts = bootScripts.concat(utils.findScripts(dir));
|
||||
var envdir = dir + '/' + options.env;
|
||||
bootScripts = bootScripts.concat(utils.findScripts(envdir));
|
||||
});
|
||||
|
||||
// de-dedup boot scripts -ERS
|
||||
// https://github.com/strongloop/loopback-boot/issues/64
|
||||
bootScripts = _.uniq(bootScripts);
|
||||
debug('Boot scripts: %j', bootScripts);
|
||||
this.configure(context, bootScripts);
|
||||
return bootScripts;
|
||||
};
|
||||
|
||||
Script.prototype.start = function(context, done) {
|
||||
var app = context.app;
|
||||
var instructions = context.instructions[this.name];
|
||||
runScripts(app, instructions, done);
|
||||
};
|
||||
|
||||
function runScripts(app, list, callback) {
|
||||
list = list || [];
|
||||
var functions = [];
|
||||
list.forEach(function(filepath) {
|
||||
debug('Requiring script %s', filepath);
|
||||
try {
|
||||
var exports = require(filepath);
|
||||
if (typeof exports === 'function') {
|
||||
debug('Exported function detected %s', filepath);
|
||||
functions.push({
|
||||
path: filepath,
|
||||
func: exports,
|
||||
});
|
||||
}
|
||||
} catch (err) {
|
||||
console.error('Failed loading boot script: %s\n%s', filepath, err.stack);
|
||||
throw err;
|
||||
}
|
||||
});
|
||||
|
||||
async.eachSeries(functions, function(f, done) {
|
||||
debug('Running script %s', f.path);
|
||||
if (f.func.length >= 2) {
|
||||
debug('Starting async function %s', f.path);
|
||||
f.func(app, function(err) {
|
||||
debug('Async function finished %s', f.path);
|
||||
done(err);
|
||||
});
|
||||
} else {
|
||||
debug('Starting sync function %s', f.path);
|
||||
f.func(app);
|
||||
debug('Sync function finished %s', f.path);
|
||||
done();
|
||||
}
|
||||
}, callback);
|
||||
}
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
var util = require('util');
|
||||
var debug = require('debug')('loopback:boot:component');
|
||||
var PluginBase = require('../plugin-base');
|
||||
|
||||
var utils = require('../utils');
|
||||
|
||||
var resolveAppScriptPath = utils.resolveAppScriptPath;
|
||||
|
||||
module.exports = function(options) {
|
||||
return new Component(options);
|
||||
};
|
||||
|
||||
function Component(options) {
|
||||
PluginBase.call(this, options, 'components', 'component-config');
|
||||
}
|
||||
|
||||
util.inherits(Component, PluginBase);
|
||||
|
||||
Component.prototype.buildInstructions = function(context, rootDir, config) {
|
||||
return Object.keys(config)
|
||||
.filter(function(name) {
|
||||
return !!config[name];
|
||||
}).map(function(name) {
|
||||
return {
|
||||
sourceFile: resolveAppScriptPath(rootDir, name, { strict: true }),
|
||||
config: config[name],
|
||||
};
|
||||
});
|
||||
};
|
||||
|
||||
Component.prototype.start = function(context) {
|
||||
var app = context.app;
|
||||
var self = this;
|
||||
context.instructions[this.name].forEach(function(data) {
|
||||
debug('Configuring component %j', data.sourceFile);
|
||||
var configFn = require(data.sourceFile);
|
||||
data.config = self.getUpdatedConfigObject(context, data.config,
|
||||
{ useEnvVars: true });
|
||||
configFn(app, data.config);
|
||||
});
|
||||
};
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
var util = require('util');
|
||||
var utils = require('../utils');
|
||||
var PluginBase = require('../plugin-base');
|
||||
var debug = require('debug')('loopback:boot:datasource');
|
||||
|
||||
module.exports = function(options) {
|
||||
return new DataSource(options);
|
||||
};
|
||||
|
||||
function DataSource(options) {
|
||||
PluginBase.call(this, options, 'dataSources', 'datasources');
|
||||
}
|
||||
|
||||
util.inherits(DataSource, PluginBase);
|
||||
|
||||
DataSource.prototype.getRootDir = function() {
|
||||
return this.options.dsRootDir;
|
||||
};
|
||||
|
||||
DataSource.prototype.start = function(context) {
|
||||
var app = context.app;
|
||||
var self = this;
|
||||
utils.forEachKeyedObject(context.instructions[this.name], function(key, obj) {
|
||||
obj = self.getUpdatedConfigObject(context, obj, { useEnvVars: true });
|
||||
debug('Registering data source %s %j', key, obj);
|
||||
app.dataSource(key, obj);
|
||||
});
|
||||
};
|
||||
|
||||
|
|
@ -0,0 +1,254 @@
|
|||
var util = require('util');
|
||||
var assert = require('assert');
|
||||
var path = require('path');
|
||||
var _ = require('lodash');
|
||||
var cloneDeepWith = _.cloneDeepWith;
|
||||
var cloneDeep = _.cloneDeep;
|
||||
var debug = require('debug')('loopback:boot:middleware');
|
||||
var PluginBase = require('../plugin-base');
|
||||
var utils = require('../utils');
|
||||
|
||||
var resolveAppScriptPath = utils.resolveAppScriptPath;
|
||||
|
||||
module.exports = function(options) {
|
||||
return new Middleware(options);
|
||||
};
|
||||
|
||||
function Middleware(options) {
|
||||
PluginBase.call(this, options, 'middleware', 'middleware');
|
||||
}
|
||||
|
||||
util.inherits(Middleware, PluginBase);
|
||||
|
||||
Middleware.prototype.merge = function(target, config, fileName) {
|
||||
var err, phase;
|
||||
for (phase in config) {
|
||||
if (phase in target) {
|
||||
err = this.mergePhaseConfig(target[phase], config[phase], phase);
|
||||
} else {
|
||||
err = 'The phase "' + phase + '" is not defined in the main config.';
|
||||
}
|
||||
if (err)
|
||||
throw new Error('Cannot apply ' + fileName + ': ' + err);
|
||||
}
|
||||
};
|
||||
|
||||
Middleware.prototype.mergePhaseConfig = function(target, config, phase) {
|
||||
var err, mw;
|
||||
for (mw in config) {
|
||||
if (mw in target) {
|
||||
var targetMiddleware = target[mw];
|
||||
var configMiddleware = config[mw];
|
||||
if (Array.isArray(targetMiddleware) && Array.isArray(configMiddleware)) {
|
||||
// Both are arrays, combine them
|
||||
target[mw] = this.mergeNamedItems(targetMiddleware, configMiddleware);
|
||||
} else if (Array.isArray(targetMiddleware)) {
|
||||
if (typeof configMiddleware === 'object' &&
|
||||
Object.keys(configMiddleware).length) {
|
||||
// Config side is an non-empty object
|
||||
target[mw] = this.mergeNamedItems(targetMiddleware,
|
||||
[configMiddleware]);
|
||||
}
|
||||
} else if (Array.isArray(configMiddleware)) {
|
||||
if (typeof targetMiddleware === 'object' &&
|
||||
Object.keys(targetMiddleware).length) {
|
||||
// Target side is an non-empty object
|
||||
target[mw] = this.mergeNamedItems([targetMiddleware],
|
||||
configMiddleware);
|
||||
} else {
|
||||
// Target side is empty
|
||||
target[mw] = configMiddleware;
|
||||
}
|
||||
} else {
|
||||
err = this.mergeObjects(targetMiddleware, configMiddleware);
|
||||
}
|
||||
} else {
|
||||
err = 'The middleware "' + mw + '" in phase "' + phase + '"' +
|
||||
'is not defined in the main config.';
|
||||
}
|
||||
if (err) return err;
|
||||
}
|
||||
};
|
||||
|
||||
Middleware.prototype.buildInstructions = function(context, rootDir, config) {
|
||||
var phasesNames = Object.keys(config);
|
||||
var middlewareList = [];
|
||||
phasesNames.forEach(function(phase) {
|
||||
var phaseConfig = config[phase];
|
||||
Object.keys(phaseConfig).forEach(function(middleware) {
|
||||
var allConfigs = phaseConfig[middleware];
|
||||
if (!Array.isArray(allConfigs))
|
||||
allConfigs = [allConfigs];
|
||||
|
||||
allConfigs.forEach(function(config) {
|
||||
var resolved = resolveMiddlewarePath(rootDir, middleware, config);
|
||||
|
||||
// resolved.sourceFile will be false-y if an optional middleware
|
||||
// is not resolvable.
|
||||
// if a non-optional middleware is not resolvable, it will throw
|
||||
// at resolveAppPath() and not reach here
|
||||
if (!resolved.sourceFile) {
|
||||
return console.log('Middleware "%s" not found: %s',
|
||||
middleware,
|
||||
resolved.optional
|
||||
);
|
||||
}
|
||||
|
||||
var middlewareConfig = cloneDeep(config);
|
||||
middlewareConfig.phase = phase;
|
||||
|
||||
if (middlewareConfig.params) {
|
||||
middlewareConfig.params = resolveMiddlewareParams(
|
||||
rootDir, middlewareConfig.params);
|
||||
}
|
||||
|
||||
var item = {
|
||||
sourceFile: resolved.sourceFile,
|
||||
config: middlewareConfig,
|
||||
};
|
||||
if (resolved.fragment) {
|
||||
item.fragment = resolved.fragment;
|
||||
}
|
||||
middlewareList.push(item);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
var flattenedPhaseNames = phasesNames
|
||||
.map(function getBaseName(name) {
|
||||
return name.replace(/:[^:]+$/, '');
|
||||
})
|
||||
.filter(function differsFromPreviousItem(value, ix, source) {
|
||||
// Skip duplicate entries. That happens when
|
||||
// `name:before` and `name:after` are both translated to `name`
|
||||
return ix === 0 || value !== source[ix - 1];
|
||||
});
|
||||
|
||||
return {
|
||||
phases: flattenedPhaseNames,
|
||||
middleware: middlewareList,
|
||||
};
|
||||
};
|
||||
|
||||
function resolveMiddlewarePath(rootDir, middleware, config) {
|
||||
var resolved = {
|
||||
optional: !!config.optional,
|
||||
};
|
||||
|
||||
var segments = middleware.split('#');
|
||||
var pathName = segments[0];
|
||||
var fragment = segments[1];
|
||||
var middlewarePath = pathName;
|
||||
var opts = {
|
||||
strict: true,
|
||||
optional: !!config.optional,
|
||||
};
|
||||
|
||||
if (fragment) {
|
||||
resolved.fragment = fragment;
|
||||
}
|
||||
|
||||
if (pathName.indexOf('./') === 0 || pathName.indexOf('../') === 0) {
|
||||
// Relative path
|
||||
pathName = path.resolve(rootDir, pathName);
|
||||
}
|
||||
|
||||
var resolveOpts = _.extend(opts, {
|
||||
// Workaround for strong-agent to allow probes to detect that
|
||||
// strong-express-middleware was loaded: exclude the path to the
|
||||
// module main file from the source file path.
|
||||
// For example, return
|
||||
// node_modules/strong-express-metrics
|
||||
// instead of
|
||||
// node_modules/strong-express-metrics/index.js
|
||||
fullResolve: false,
|
||||
});
|
||||
var sourceFile = resolveAppScriptPath(rootDir, middlewarePath, resolveOpts);
|
||||
|
||||
if (!fragment) {
|
||||
resolved.sourceFile = sourceFile;
|
||||
return resolved;
|
||||
}
|
||||
|
||||
// Try to require the module and check if <module>.<fragment> is a valid
|
||||
// function
|
||||
var m = require(pathName);
|
||||
if (typeof m[fragment] === 'function') {
|
||||
resolved.sourceFile = sourceFile;
|
||||
return resolved;
|
||||
}
|
||||
|
||||
/*
|
||||
* module/server/middleware/fragment
|
||||
* module/middleware/fragment
|
||||
*/
|
||||
var candidates = [
|
||||
pathName + '/server/middleware/' + fragment,
|
||||
pathName + '/middleware/' + fragment,
|
||||
// TODO: [rfeng] Should we support the following flavors?
|
||||
// pathName + '/lib/' + fragment,
|
||||
// pathName + '/' + fragment
|
||||
];
|
||||
|
||||
var err, ix;
|
||||
for (ix in candidates) {
|
||||
try {
|
||||
resolved.sourceFile = resolveAppScriptPath(rootDir, candidates[ix], opts);
|
||||
delete resolved.fragment;
|
||||
return resolved;
|
||||
} catch (e) {
|
||||
// Report the error for the first candidate when no candidate matches
|
||||
if (!err) err = e;
|
||||
}
|
||||
}
|
||||
throw err;
|
||||
}
|
||||
|
||||
// Match values starting with `$!./` or `$!../`
|
||||
var MIDDLEWARE_PATH_PARAM_REGEX = /^\$!(\.\/|\.\.\/)/;
|
||||
|
||||
function resolveMiddlewareParams(rootDir, params) {
|
||||
return cloneDeepWith(params, function resolvePathParam(value) {
|
||||
if (typeof value === 'string' && MIDDLEWARE_PATH_PARAM_REGEX.test(value)) {
|
||||
return path.resolve(rootDir, value.slice(2));
|
||||
} else {
|
||||
return undefined; // no change
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
Middleware.prototype.start = function(context) {
|
||||
var self = this;
|
||||
var app = context.app;
|
||||
var instructions = context.instructions.middleware;
|
||||
if (!instructions) {
|
||||
// the browserified client does not support middleware
|
||||
return;
|
||||
}
|
||||
|
||||
// Phases can be empty
|
||||
var phases = instructions.phases || [];
|
||||
assert(Array.isArray(phases),
|
||||
'Middleware phases must be an array');
|
||||
|
||||
var middleware = instructions.middleware;
|
||||
assert(Array.isArray(middleware),
|
||||
'Middleware must be an array');
|
||||
|
||||
debug('Defining middleware phases %j', phases);
|
||||
app.defineMiddlewarePhases(phases);
|
||||
|
||||
middleware.forEach(function(data) {
|
||||
debug('Configuring middleware %j%s', data.sourceFile,
|
||||
data.fragment ? ('#' + data.fragment) : '');
|
||||
var factory = require(data.sourceFile);
|
||||
if (data.fragment) {
|
||||
factory = factory[data.fragment].bind(factory);
|
||||
}
|
||||
assert(typeof factory === 'function',
|
||||
'Middleware factory must be a function');
|
||||
data.config = self.getUpdatedConfigObject(context, data.config,
|
||||
{ useEnvVars: true });
|
||||
app.middlewareFromConfig(factory, data.config);
|
||||
});
|
||||
};
|
||||
|
|
@ -0,0 +1,189 @@
|
|||
var util = require('util');
|
||||
var fs = require('fs');
|
||||
var path = require('path');
|
||||
var PluginBase = require('../plugin-base');
|
||||
var _ = require('lodash');
|
||||
var debug = require('debug')('loopback:boot:mixin');
|
||||
var utils = require('../utils');
|
||||
|
||||
var tryResolveAppPath = utils.tryResolveAppPath;
|
||||
var getExcludedExtensions = utils.getExcludedExtensions;
|
||||
var findScripts = utils.findScripts;
|
||||
var FILE_EXTENSION_JSON = utils.FILE_EXTENSION_JSON;
|
||||
|
||||
module.exports = function(options) {
|
||||
return new Mixin(options);
|
||||
};
|
||||
|
||||
function Mixin(options) {
|
||||
PluginBase.call(this, options, 'mixins', null);
|
||||
}
|
||||
|
||||
util.inherits(Mixin, PluginBase);
|
||||
|
||||
Mixin.prototype.buildInstructions = function(context, rootDir, config) {
|
||||
var modelsMeta = context.configurations.mixins._meta || {};
|
||||
var modelInstructions = context.instructions.models;
|
||||
var mixinDirs = this.options.mixinDirs || [];
|
||||
var mixinSources = this.options.mixinSources || modelsMeta.mixins ||
|
||||
['./mixins'];
|
||||
|
||||
var mixinInstructions = buildAllMixinInstructions(
|
||||
rootDir, mixinDirs, mixinSources, this.options, modelInstructions);
|
||||
|
||||
return mixinInstructions;
|
||||
};
|
||||
|
||||
function buildAllMixinInstructions(appRootDir, mixinDirs, mixinSources, options,
|
||||
modelInstructions) {
|
||||
var extensions = _.without(_.keys(require.extensions),
|
||||
_.keys(getExcludedExtensions()));
|
||||
|
||||
// load mixins from `options.mixins`
|
||||
var sourceFiles = options.mixins || [];
|
||||
var instructionsFromMixins = loadMixins(sourceFiles, options);
|
||||
|
||||
// load mixins from `options.mixinDirs`
|
||||
sourceFiles = findMixinDefinitions(appRootDir, mixinDirs, extensions);
|
||||
if (sourceFiles === undefined) return;
|
||||
var instructionsFromMixinDirs = loadMixins(sourceFiles, options);
|
||||
|
||||
/* If `mixinDirs` and `mixinSources` have any directories in common,
|
||||
* then remove the common directories from `mixinSources` */
|
||||
mixinSources = _.difference(mixinSources, mixinDirs);
|
||||
|
||||
// load mixins from `options.mixinSources`
|
||||
sourceFiles = findMixinDefinitions(appRootDir, mixinSources, extensions);
|
||||
if (sourceFiles === undefined) return;
|
||||
var instructionsFromMixinSources = loadMixins(sourceFiles, options);
|
||||
|
||||
// Fetch unique list of mixin names, used in models
|
||||
var modelMixins = fetchMixinNamesUsedInModelInstructions(modelInstructions);
|
||||
modelMixins = _.uniq(modelMixins);
|
||||
|
||||
// Filter-in only mixins, that are used in models
|
||||
instructionsFromMixinSources = filterMixinInstructionsUsingWhitelist(
|
||||
instructionsFromMixinSources, modelMixins);
|
||||
|
||||
var mixins = _.assign(
|
||||
instructionsFromMixins,
|
||||
instructionsFromMixinDirs,
|
||||
instructionsFromMixinSources);
|
||||
|
||||
return _.values(mixins);
|
||||
}
|
||||
|
||||
function findMixinDefinitions(appRootDir, sourceDirs, extensions) {
|
||||
var files = [];
|
||||
sourceDirs.forEach(function(dir) {
|
||||
var path = tryResolveAppPath(appRootDir, dir);
|
||||
if (!path) {
|
||||
debug('Skipping unknown module source dir %j', dir);
|
||||
return;
|
||||
}
|
||||
files = files.concat(findScripts(path, extensions));
|
||||
});
|
||||
return files;
|
||||
}
|
||||
|
||||
function loadMixins(sourceFiles, options) {
|
||||
var mixinInstructions = {};
|
||||
sourceFiles.forEach(function(filepath) {
|
||||
var dir = path.dirname(filepath);
|
||||
var ext = path.extname(filepath);
|
||||
var name = path.basename(filepath, ext);
|
||||
var metafile = path.join(dir, name + FILE_EXTENSION_JSON);
|
||||
|
||||
name = normalizeMixinName(name, options);
|
||||
var meta = {};
|
||||
meta.name = name;
|
||||
if (fs.existsSync(metafile)) {
|
||||
// May overwrite name, not sourceFile
|
||||
_.extend(meta, require(metafile));
|
||||
}
|
||||
meta.sourceFile = filepath;
|
||||
mixinInstructions[meta.name] = meta;
|
||||
});
|
||||
|
||||
return mixinInstructions;
|
||||
}
|
||||
|
||||
function fetchMixinNamesUsedInModelInstructions(modelInstructions) {
|
||||
return _.flatten(modelInstructions
|
||||
.map(function(model) {
|
||||
return model.definition && model.definition.mixins ?
|
||||
Object.keys(model.definition.mixins) : [];
|
||||
}));
|
||||
}
|
||||
|
||||
function filterMixinInstructionsUsingWhitelist(instructions, includeMixins) {
|
||||
var instructionKeys = Object.keys(instructions);
|
||||
includeMixins = _.intersection(instructionKeys, includeMixins);
|
||||
|
||||
var filteredInstructions = {};
|
||||
instructionKeys.forEach(function(mixinName) {
|
||||
if (includeMixins.indexOf(mixinName) !== -1) {
|
||||
filteredInstructions[mixinName] = instructions[mixinName];
|
||||
}
|
||||
});
|
||||
return filteredInstructions;
|
||||
}
|
||||
|
||||
function normalizeMixinName(str, options) {
|
||||
var normalization = options.normalization;
|
||||
switch (normalization) {
|
||||
case false:
|
||||
case 'none':
|
||||
return str;
|
||||
|
||||
case undefined:
|
||||
case 'classify':
|
||||
str = String(str).replace(/([A-Z]+)/g, ' $1').trim();
|
||||
str = String(str).replace(/[\W_]/g, ' ').toLowerCase();
|
||||
str = str.replace(/(?:^|\s|-)\S/g, function(c) {
|
||||
return c.toUpperCase();
|
||||
});
|
||||
str = str.replace(/\s+/g, '');
|
||||
return str;
|
||||
|
||||
case 'dasherize':
|
||||
str = String(str).replace(/([A-Z]+)/g, ' $1').trim();
|
||||
str = String(str).replace(/[\W_]/g, ' ').toLowerCase();
|
||||
str = str.replace(/\s+/g, '-');
|
||||
return str;
|
||||
|
||||
default:
|
||||
if (typeof normalization === 'function') {
|
||||
return normalization(str);
|
||||
}
|
||||
|
||||
var err = new Error('Invalid normalization format - "' +
|
||||
normalization + '"');
|
||||
err.code = 'INVALID_NORMALIZATION_FORMAT';
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
|
||||
Mixin.prototype.starting = function(context) {
|
||||
var app = context.app;
|
||||
var instructions = context.instructions.mixins;
|
||||
|
||||
var modelBuilder = (app.registry || app.loopback).modelBuilder;
|
||||
var BaseClass = app.loopback.Model;
|
||||
var mixins = instructions || [];
|
||||
|
||||
if (!modelBuilder.mixins || !mixins.length) return;
|
||||
|
||||
mixins.forEach(function(obj) {
|
||||
debug('Requiring mixin %s', obj.sourceFile);
|
||||
var mixin = require(obj.sourceFile);
|
||||
|
||||
if (typeof mixin === 'function' || mixin.prototype instanceof BaseClass) {
|
||||
debug('Defining mixin %s', obj.name);
|
||||
modelBuilder.mixins.define(obj.name, mixin); // TODO (name, mixin, meta)
|
||||
} else {
|
||||
debug('Skipping mixin file %s - `module.exports` is not a function' +
|
||||
' or Loopback model', obj);
|
||||
}
|
||||
});
|
||||
};
|
||||
|
|
@ -0,0 +1,297 @@
|
|||
var assert = require('assert');
|
||||
var util = require('util');
|
||||
var PluginBase = require('../plugin-base');
|
||||
var path = require('path');
|
||||
var debug = require('debug')('loopback:boot:model');
|
||||
var _ = require('lodash');
|
||||
var toposort = require('toposort');
|
||||
var utils = require('../utils');
|
||||
|
||||
var tryReadDir = utils.tryReadDir;
|
||||
var assertIsValidConfig = utils.assertIsValidConfig;
|
||||
var tryResolveAppPath = utils.tryResolveAppPath;
|
||||
var fixFileExtension = utils.fixFileExtension;
|
||||
|
||||
module.exports = function(options) {
|
||||
return new Model(options);
|
||||
};
|
||||
|
||||
function Model(options) {
|
||||
PluginBase.call(this, options, 'models', 'model-config');
|
||||
}
|
||||
|
||||
util.inherits(Model, PluginBase);
|
||||
|
||||
Model.prototype.getRootDir = function() {
|
||||
return this.options.modelsRootDir;
|
||||
};
|
||||
|
||||
Model.prototype.load = function(context) {
|
||||
var config = PluginBase.prototype.load.apply(this, arguments);
|
||||
assertIsValidModelConfig(config);
|
||||
return config;
|
||||
};
|
||||
|
||||
Model.prototype.buildInstructions = function(context, rootDir, modelsConfig) {
|
||||
var modelsMeta = modelsConfig._meta || {};
|
||||
delete modelsConfig._meta;
|
||||
context.configurations.mixins._meta = modelsMeta;
|
||||
|
||||
var modelSources = this.options.modelSources || modelsMeta.sources ||
|
||||
['./models'];
|
||||
var modelInstructions = buildAllModelInstructions(
|
||||
rootDir, modelsConfig, modelSources, this.options.modelDefinitions);
|
||||
return modelInstructions;
|
||||
};
|
||||
|
||||
function buildAllModelInstructions(rootDir, modelsConfig, sources,
|
||||
modelDefinitions) {
|
||||
var registry = verifyModelDefinitions(rootDir, modelDefinitions) ||
|
||||
findModelDefinitions(rootDir, sources);
|
||||
|
||||
var modelNamesToBuild = addAllBaseModels(registry, Object.keys(modelsConfig));
|
||||
|
||||
var instructions = modelNamesToBuild
|
||||
.map(function createModelInstructions(name) {
|
||||
var config = modelsConfig[name];
|
||||
var definition = registry[name] || {};
|
||||
|
||||
debug('Using model "%s"\nConfiguration: %j\nDefinition %j',
|
||||
name, config, definition.definition);
|
||||
|
||||
return {
|
||||
name: name,
|
||||
config: config,
|
||||
definition: definition.definition,
|
||||
sourceFile: definition.sourceFile,
|
||||
};
|
||||
});
|
||||
|
||||
return sortByInheritance(instructions);
|
||||
}
|
||||
|
||||
function addAllBaseModels(registry, modelNames) {
|
||||
var result = [];
|
||||
var visited = {};
|
||||
|
||||
while (modelNames.length) {
|
||||
var name = modelNames.shift();
|
||||
|
||||
if (visited[name]) continue;
|
||||
visited[name] = true;
|
||||
result.push(name);
|
||||
|
||||
var definition = registry[name] && registry[name].definition;
|
||||
if (!definition) continue;
|
||||
|
||||
var base = getBaseModelName(definition);
|
||||
|
||||
// ignore built-in models like User
|
||||
if (!registry[base]) continue;
|
||||
|
||||
modelNames.push(base);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
function getBaseModelName(modelDefinition) {
|
||||
if (!modelDefinition)
|
||||
return undefined;
|
||||
|
||||
return modelDefinition.base ||
|
||||
modelDefinition.options && modelDefinition.options.base;
|
||||
}
|
||||
|
||||
function sortByInheritance(instructions) {
|
||||
// create edges Base name -> Model name
|
||||
var edges = instructions
|
||||
.map(function(inst) {
|
||||
return [getBaseModelName(inst.definition), inst.name];
|
||||
});
|
||||
|
||||
var sortedNames = toposort(edges);
|
||||
|
||||
var instructionsByModelName = {};
|
||||
instructions.forEach(function(inst) {
|
||||
instructionsByModelName[inst.name] = inst;
|
||||
});
|
||||
|
||||
return sortedNames
|
||||
// convert to instructions
|
||||
.map(function(name) {
|
||||
return instructionsByModelName[name];
|
||||
})
|
||||
// remove built-in models
|
||||
.filter(function(inst) {
|
||||
return !!inst;
|
||||
});
|
||||
}
|
||||
|
||||
function verifyModelDefinitions(rootDir, modelDefinitions) {
|
||||
if (!modelDefinitions || modelDefinitions.length < 1) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
var registry = {};
|
||||
modelDefinitions.forEach(function(definition, idx) {
|
||||
if (definition.sourceFile) {
|
||||
var fullPath = path.resolve(rootDir, definition.sourceFile);
|
||||
definition.sourceFile = fixFileExtension(
|
||||
fullPath,
|
||||
tryReadDir(path.dirname(fullPath)),
|
||||
true);
|
||||
if (!definition.sourceFile) {
|
||||
debug('Model source code not found: %s - %s', definition.sourceFile);
|
||||
}
|
||||
}
|
||||
|
||||
debug('Found model "%s" - %s %s',
|
||||
definition.definition.name,
|
||||
'from options',
|
||||
definition.sourceFile ?
|
||||
path.relative(rootDir, definition.sourceFile) :
|
||||
'(no source file)');
|
||||
|
||||
var modelName = definition.definition.name;
|
||||
if (!modelName) {
|
||||
debug('Skipping model definition without Model name ' +
|
||||
'(from options.modelDefinitions @ index %s)',
|
||||
idx);
|
||||
return;
|
||||
}
|
||||
registry[modelName] = definition;
|
||||
});
|
||||
|
||||
return registry;
|
||||
}
|
||||
|
||||
function findModelDefinitions(rootDir, sources) {
|
||||
var registry = {};
|
||||
|
||||
sources.forEach(function(src) {
|
||||
var srcDir = tryResolveAppPath(rootDir, src, { strict: false });
|
||||
if (!srcDir) {
|
||||
debug('Skipping unknown module source dir %j', src);
|
||||
return;
|
||||
}
|
||||
|
||||
var files = tryReadDir(srcDir);
|
||||
|
||||
files
|
||||
.filter(function(f) {
|
||||
return f[0] !== '_' && path.extname(f) === '.json';
|
||||
})
|
||||
.forEach(function(f) {
|
||||
var fullPath = path.resolve(srcDir, f);
|
||||
var entry = loadModelDefinition(rootDir, fullPath, files);
|
||||
var modelName = entry.definition.name;
|
||||
if (!modelName) {
|
||||
debug('Skipping model definition without Model name: %s',
|
||||
path.relative(srcDir, fullPath));
|
||||
return;
|
||||
}
|
||||
registry[modelName] = entry;
|
||||
});
|
||||
});
|
||||
|
||||
return registry;
|
||||
}
|
||||
|
||||
function loadModelDefinition(rootDir, jsonFile, allFiles) {
|
||||
var definition = require(jsonFile);
|
||||
var basename = path.basename(jsonFile, path.extname(jsonFile));
|
||||
definition.name = definition.name || _.upperFirst(_.camelCase(basename));
|
||||
|
||||
// find a matching file with a supported extension like `.js` or `.coffee`
|
||||
var sourceFile = fixFileExtension(jsonFile, allFiles, true);
|
||||
if (sourceFile === undefined) {
|
||||
debug('Model source code not found: %s', sourceFile);
|
||||
}
|
||||
|
||||
debug('Found model "%s" - %s %s', definition.name,
|
||||
path.relative(rootDir, jsonFile),
|
||||
sourceFile ? path.relative(rootDir, sourceFile) : '(no source file)');
|
||||
|
||||
return {
|
||||
definition: definition,
|
||||
sourceFile: sourceFile,
|
||||
};
|
||||
}
|
||||
|
||||
function assertIsValidModelConfig(config) {
|
||||
assertIsValidConfig('model', config);
|
||||
for (var name in config) {
|
||||
var entry = config[name];
|
||||
var options = entry.options || {};
|
||||
var unsupported = entry.properties ||
|
||||
entry.base || options.base ||
|
||||
entry.plural || options.plural;
|
||||
|
||||
if (unsupported) {
|
||||
throw new Error(
|
||||
'The data in model-config.json is in the unsupported 1.x format.');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Regular expression to match built-in loopback models
|
||||
var LOOPBACK_MODEL_REGEXP = new RegExp(
|
||||
['', 'node_modules', 'loopback', '[^\\/\\\\]+', 'models', '[^\\/\\\\]+\\.js$']
|
||||
.join('\\' + path.sep));
|
||||
|
||||
function isBuiltinLoopBackModel(app, data) {
|
||||
// 1. Built-in models are exposed on the loopback object
|
||||
if (!app.loopback[data.name]) return false;
|
||||
|
||||
// 2. Built-in models have a script file `loopback/{facet}/models/{name}.js`
|
||||
var srcFile = data.sourceFile;
|
||||
return srcFile &&
|
||||
LOOPBACK_MODEL_REGEXP.test(srcFile);
|
||||
}
|
||||
|
||||
Model.prototype.start = function(context) {
|
||||
var app = context.app;
|
||||
var instructions = context.instructions[this.name];
|
||||
|
||||
var registry = app.registry || app.loopback;
|
||||
instructions.forEach(function(data) {
|
||||
var name = data.name;
|
||||
var model;
|
||||
|
||||
if (!data.definition) {
|
||||
model = registry.getModel(name);
|
||||
if (!model) {
|
||||
throw new Error('Cannot configure unknown model ' + name);
|
||||
}
|
||||
debug('Configuring existing model %s', name);
|
||||
} else if (isBuiltinLoopBackModel(app, data)) {
|
||||
model = registry.getModel(name);
|
||||
assert(model, 'Built-in model ' + name + ' should have been defined');
|
||||
debug('Configuring built-in LoopBack model %s', name);
|
||||
} else {
|
||||
debug('Creating new model %s %j', name, data.definition);
|
||||
model = registry.createModel(data.definition);
|
||||
if (data.sourceFile) {
|
||||
debug('Loading customization script %s', data.sourceFile);
|
||||
var code = require(data.sourceFile);
|
||||
if (typeof code === 'function') {
|
||||
debug('Customizing model %s', name);
|
||||
code(model);
|
||||
} else {
|
||||
debug('Skipping model file %s - `module.exports` is not a function',
|
||||
data.sourceFile);
|
||||
}
|
||||
}
|
||||
}
|
||||
data._model = model;
|
||||
});
|
||||
|
||||
instructions.forEach(function(data) {
|
||||
// Skip base models that are not exported to the app
|
||||
if (!data.config) return;
|
||||
|
||||
app.model(data._model, data.config);
|
||||
});
|
||||
};
|
||||
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
var util = require('util');
|
||||
var PluginBase = require('../plugin-base');
|
||||
|
||||
module.exports = function(options) {
|
||||
return new Swagger(options);
|
||||
};
|
||||
|
||||
function Swagger(options) {
|
||||
PluginBase.call(this, options, 'apis', null);
|
||||
}
|
||||
|
||||
util.inherits(Swagger, PluginBase);
|
||||
|
||||
Swagger.prototype.start = function(context) {
|
||||
var app = context.app;
|
||||
var appConfig = context.instructions.application;
|
||||
// disable token requirement for swagger, if available
|
||||
var swagger = app.remotes().exports.swagger;
|
||||
if (!swagger) return;
|
||||
|
||||
var requireTokenForSwagger = appConfig.swagger &&
|
||||
appConfig.swagger.requireToken;
|
||||
swagger.requireToken = requireTokenForSwagger || false;
|
||||
};
|
||||
325
lib/utils.js
325
lib/utils.js
|
|
@ -5,7 +5,331 @@
|
|||
|
||||
var fs = require('fs');
|
||||
|
||||
var debug = require('debug')('loopback:boot');
|
||||
var path = require('path');
|
||||
var Module = require('module');
|
||||
var fs = require('fs');
|
||||
var assert = require('assert');
|
||||
var _ = require('lodash');
|
||||
|
||||
exports.tryReadDir = tryReadDir;
|
||||
exports.resolveRelativePaths = resolveRelativePaths;
|
||||
exports.assertIsValidConfig = assertIsValidConfig;
|
||||
exports.fileExistsSync = fileExistsSync;
|
||||
exports.fixFileExtension = fixFileExtension;
|
||||
exports.findScripts = findScripts;
|
||||
exports.resolveAppScriptPath = resolveAppScriptPath;
|
||||
exports.getExcludedExtensions = getExcludedExtensions;
|
||||
exports.tryResolveAppPath = tryResolveAppPath;
|
||||
exports.forEachKeyedObject = forEachKeyedObject;
|
||||
exports.mergePhaseNameLists = mergePhaseNameLists;
|
||||
|
||||
var FILE_EXTENSION_JSON = exports.FILE_EXTENSION_JSON = '.json';
|
||||
/**
|
||||
* Find all javascript files (except for those prefixed with _)
|
||||
* and all directories.
|
||||
* @param {String} dir Full path of the directory to enumerate.
|
||||
* @return {Array.<String>} A list of absolute paths to pass to `require()`.
|
||||
*/
|
||||
|
||||
function findScripts(dir, extensions) {
|
||||
assert(dir, 'cannot require directory contents without directory name');
|
||||
|
||||
var files = tryReadDir(dir);
|
||||
extensions = extensions || _.keys(require.extensions);
|
||||
|
||||
// sort files in lowercase alpha for linux
|
||||
files.sort(function(a, b) {
|
||||
a = a.toLowerCase();
|
||||
b = b.toLowerCase();
|
||||
|
||||
if (a < b) {
|
||||
return -1;
|
||||
} else if (b < a) {
|
||||
return 1;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
});
|
||||
|
||||
var results = [];
|
||||
files.forEach(function(filename) {
|
||||
// ignore index.js and files prefixed with underscore
|
||||
if (filename === 'index.js' || filename[0] === '_') {
|
||||
return;
|
||||
}
|
||||
|
||||
var filepath = path.resolve(path.join(dir, filename));
|
||||
var stats = fs.statSync(filepath);
|
||||
|
||||
// only require files supported by require.extensions (.txt .md etc.)
|
||||
if (stats.isFile()) {
|
||||
if (isPreferredExtension(filename))
|
||||
results.push(filepath);
|
||||
else
|
||||
debug('Skipping file %s - unknown extension', filepath);
|
||||
} else {
|
||||
debug('Skipping directory %s', filepath);
|
||||
}
|
||||
});
|
||||
|
||||
return results;
|
||||
}
|
||||
|
||||
function tryReadDir() {
|
||||
try {
|
||||
return fs.readdirSync.apply(fs, arguments);
|
||||
} catch (e) {
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
function resolveRelativePaths(relativePaths, appRootDir) {
|
||||
var resolveOpts = { strict: false };
|
||||
relativePaths.forEach(function(relativePath, k) {
|
||||
var resolvedPath = tryResolveAppPath(appRootDir, relativePath, resolveOpts);
|
||||
if (resolvedPath !== undefined) {
|
||||
relativePaths[k] = resolvedPath;
|
||||
} else {
|
||||
debug ('skipping boot script %s - unknown file', relativePath);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function getExcludedExtensions() {
|
||||
return {
|
||||
'.json': '.json',
|
||||
'.node': 'node',
|
||||
};
|
||||
}
|
||||
|
||||
function isPreferredExtension(filename) {
|
||||
var includeExtensions = require.extensions;
|
||||
|
||||
var ext = path.extname(filename);
|
||||
return (ext in includeExtensions) && !(ext in getExcludedExtensions());
|
||||
}
|
||||
|
||||
function fixFileExtension(filepath, files, onlyScriptsExportingFunction) {
|
||||
var results = [];
|
||||
var otherFile;
|
||||
|
||||
/* Prefer coffee scripts over json */
|
||||
if (isPreferredExtension(filepath)) return filepath;
|
||||
|
||||
var basename = path.basename(filepath, FILE_EXTENSION_JSON);
|
||||
var sourceDir = path.dirname(filepath);
|
||||
|
||||
files.forEach(function(f) {
|
||||
otherFile = path.resolve(sourceDir, f);
|
||||
|
||||
var stats = fs.statSync(otherFile);
|
||||
if (stats.isFile()) {
|
||||
var otherFileExtension = path.extname(f);
|
||||
|
||||
if (!(otherFileExtension in getExcludedExtensions()) &&
|
||||
path.basename(f, otherFileExtension) == basename) {
|
||||
if (!onlyScriptsExportingFunction)
|
||||
results.push(otherFile);
|
||||
else if (onlyScriptsExportingFunction &&
|
||||
(typeof require.extensions[otherFileExtension]) === 'function') {
|
||||
results.push(otherFile);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
return (results.length > 0 ? results[0] : undefined);
|
||||
}
|
||||
|
||||
function resolveAppPath(rootDir, relativePath, resolveOptions) {
|
||||
var resolvedPath = tryResolveAppPath(rootDir, relativePath, resolveOptions);
|
||||
if (resolvedPath === undefined && !resolveOptions.optional) {
|
||||
var err = new Error('Cannot resolve path "' + relativePath + '"');
|
||||
err.code = 'PATH_NOT_FOUND';
|
||||
throw err;
|
||||
}
|
||||
return resolvedPath;
|
||||
}
|
||||
|
||||
function resolveAppScriptPath(rootDir, relativePath, resolveOptions) {
|
||||
var resolvedPath = resolveAppPath(rootDir, relativePath, resolveOptions);
|
||||
if (!resolvedPath) {
|
||||
return false;
|
||||
}
|
||||
var sourceDir = path.dirname(resolvedPath);
|
||||
var files = tryReadDir(sourceDir);
|
||||
var fixedFile = fixFileExtension(resolvedPath, files, false);
|
||||
return (fixedFile === undefined ? resolvedPath : fixedFile);
|
||||
}
|
||||
|
||||
function tryResolveAppPath(rootDir, relativePath, resolveOptions) {
|
||||
var fullPath;
|
||||
var start = relativePath.substring(0, 2);
|
||||
|
||||
/* In order to retain backward compatibility, we need to support
|
||||
* two ways how to treat values that are not relative nor absolute
|
||||
* path (e.g. `relativePath = 'foobar'`)
|
||||
* - `resolveOptions.strict = true` searches in `node_modules` only
|
||||
* - `resolveOptions.strict = false` attempts to resolve the value
|
||||
* as a relative path first before searching `node_modules`
|
||||
*/
|
||||
resolveOptions = resolveOptions || { strict: true };
|
||||
|
||||
var isModuleRelative = false;
|
||||
if (relativePath[0] === '/') {
|
||||
fullPath = relativePath;
|
||||
} else if (start === './' || start === '..') {
|
||||
fullPath = path.resolve(rootDir, relativePath);
|
||||
} else if (!resolveOptions.strict) {
|
||||
isModuleRelative = true;
|
||||
fullPath = path.resolve(rootDir, relativePath);
|
||||
}
|
||||
|
||||
if (fullPath) {
|
||||
// This check is needed to support paths pointing to a directory
|
||||
if (fs.existsSync(fullPath)) {
|
||||
return fullPath;
|
||||
}
|
||||
|
||||
try {
|
||||
fullPath = require.resolve(fullPath);
|
||||
return fullPath;
|
||||
} catch (err) {
|
||||
if (!isModuleRelative) {
|
||||
debug ('Skipping %s - %s', fullPath, err);
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Handle module-relative path, e.g. `loopback/common/models`
|
||||
|
||||
// Module.globalPaths is a list of globally configured paths like
|
||||
// [ env.NODE_PATH values, $HOME/.node_modules, etc. ]
|
||||
// Module._nodeModulePaths(rootDir) returns a list of paths like
|
||||
// [ rootDir/node_modules, rootDir/../node_modules, etc. ]
|
||||
var modulePaths = Module.globalPaths
|
||||
.concat(Module._nodeModulePaths(rootDir));
|
||||
|
||||
fullPath = modulePaths
|
||||
.map(function(candidateDir) {
|
||||
var absPath = path.join(candidateDir, relativePath);
|
||||
try {
|
||||
// NOTE(bajtos) We need to create a proper String object here,
|
||||
// otherwise we can't attach additional properties to it
|
||||
/*jshint -W053 */
|
||||
var filePath = new String(require.resolve(absPath));
|
||||
filePath.unresolvedPath = absPath;
|
||||
return filePath;
|
||||
} catch (err) {
|
||||
return absPath;
|
||||
}
|
||||
})
|
||||
.filter(function(candidate) {
|
||||
return fs.existsSync(candidate.toString());
|
||||
})
|
||||
[0];
|
||||
|
||||
if (fullPath) {
|
||||
if (fullPath.unresolvedPath && resolveOptions.fullResolve === false)
|
||||
return fullPath.unresolvedPath;
|
||||
// Convert String object back to plain string primitive
|
||||
return fullPath.toString();
|
||||
}
|
||||
|
||||
debug ('Skipping %s - module not found', fullPath);
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function assertIsValidConfig(name, config) {
|
||||
if (config) {
|
||||
assert(typeof config === 'object',
|
||||
name + ' config must be a valid JSON object');
|
||||
}
|
||||
}
|
||||
|
||||
function forEachKeyedObject(obj, fn) {
|
||||
if (typeof obj !== 'object') return;
|
||||
|
||||
Object.keys(obj).forEach(function(key) {
|
||||
fn(key, obj[key]);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Extend the list of builtin phases by merging in an array of phases
|
||||
* requested by a user while preserving the relative order of phases
|
||||
* as specified by both arrays.
|
||||
*
|
||||
* If the first new name does not match any existing phase, it is inserted
|
||||
* as the first phase in the new list. The same applies for the second phase,
|
||||
* and so on, until an existing phase is found.
|
||||
*
|
||||
* Any new names in the middle of the array are inserted immediatelly after
|
||||
* the last common phase. For example, extending
|
||||
* `["initial", "session", "auth"]` with `["initial", "preauth", "auth"]`
|
||||
* results in `["initial", "preauth", "session", "auth"]`.
|
||||
*
|
||||
*
|
||||
* **Example**
|
||||
*
|
||||
* ```js
|
||||
* var result = mergePhaseNameLists(
|
||||
* ['initial', 'session', 'auth', 'routes', 'files', 'final'],
|
||||
* ['initial', 'postinit', 'preauth', 'auth',
|
||||
* 'routes', 'subapps', 'final', 'last']
|
||||
* );
|
||||
*
|
||||
* // result: [
|
||||
* // 'initial', 'postinit', 'preauth', 'session', 'auth',
|
||||
* // 'routes', 'subapps', 'files', 'final', 'last'
|
||||
* // ]
|
||||
* ```
|
||||
*
|
||||
* @param {Array} currentNames The current list of phase names.
|
||||
* @param {Array} namesToMerge The items to add (zip merge) into the target
|
||||
* array.
|
||||
* @returns {Array} A new array containing combined items from both arrays.
|
||||
*
|
||||
* @header mergePhaseNameLists
|
||||
*/
|
||||
function mergePhaseNameLists(currentNames, namesToMerge) {
|
||||
if (!namesToMerge.length) return currentNames.slice();
|
||||
|
||||
var targetArray = currentNames.slice();
|
||||
var targetIx = targetArray.indexOf(namesToMerge[0]);
|
||||
|
||||
if (targetIx === -1) {
|
||||
// the first new item does not match any existing one
|
||||
// start adding the new items at the start of the list
|
||||
targetArray.splice(0, 0, namesToMerge[0]);
|
||||
targetIx = 0;
|
||||
}
|
||||
|
||||
// merge (zip) two arrays
|
||||
for (var sourceIx = 1; sourceIx < namesToMerge.length; sourceIx++) {
|
||||
var valueToAdd = namesToMerge[sourceIx];
|
||||
var previousValue = namesToMerge[sourceIx - 1];
|
||||
var existingIx = targetArray.indexOf(valueToAdd, targetIx);
|
||||
|
||||
if (existingIx === -1) {
|
||||
// A new phase - try to add it after the last one,
|
||||
// unless it was already registered
|
||||
if (targetArray.indexOf(valueToAdd) !== -1) {
|
||||
throw new Error('Ordering conflict: cannot add "' + valueToAdd +
|
||||
'" after "' + previousValue + '", because the opposite order was ' +
|
||||
' already specified');
|
||||
}
|
||||
var previousIx = targetArray.indexOf(previousValue);
|
||||
targetArray.splice(previousIx + 1, 0, valueToAdd);
|
||||
} else {
|
||||
// An existing phase - move the pointer
|
||||
targetIx = existingIx;
|
||||
}
|
||||
}
|
||||
|
||||
return targetArray;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check synchronously if a filepath points to an existing file.
|
||||
|
|
@ -23,3 +347,4 @@ function fileExistsSync(filepath) {
|
|||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
29
package.json
29
package.json
|
|
@ -24,24 +24,25 @@
|
|||
},
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"async": "~0.9.0",
|
||||
"commondir": "0.0.1",
|
||||
"debug": "^2.0.0",
|
||||
"lodash": "^3.6.0",
|
||||
"semver": "^4.1.0",
|
||||
"async": "^0.9.2",
|
||||
"bluebird": "^3.3.5",
|
||||
"commondir": "1.0.1",
|
||||
"debug": "^2.2.0",
|
||||
"lodash": "^4.11.1",
|
||||
"semver": "^5.1.0",
|
||||
"strong-globalize": "^2.6.2",
|
||||
"toposort": "^0.2.10"
|
||||
"toposort": "^0.2.12"
|
||||
},
|
||||
"devDependencies": {
|
||||
"browserify": "^4.1.8",
|
||||
"chai": "^1.10.0",
|
||||
"coffee-script": "^1.8.0",
|
||||
"coffeeify": "^0.7.0",
|
||||
"browserify": "^4.2.3",
|
||||
"eslint": "^2.5.3",
|
||||
"eslint-config-loopback": "^1.0.0",
|
||||
"fs-extra": "^0.12.0",
|
||||
"loopback": "^2.16.3",
|
||||
"mocha": "^1.19.0",
|
||||
"supertest": "^0.14.0"
|
||||
"chai": "^3.5.0",
|
||||
"coffee-script": "^1.10.0",
|
||||
"coffeeify": "^2.0.1",
|
||||
"fs-extra": "^0.28.0",
|
||||
"loopback": "^2.27.0",
|
||||
"mocha": "^2.4.5",
|
||||
"supertest": "^1.2.0"
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,72 @@
|
|||
var path = require('path');
|
||||
var loopback = require('loopback');
|
||||
var expect = require('chai').expect;
|
||||
var Bootstrapper = require('../lib/bootstrapper').Bootstrapper;
|
||||
|
||||
describe('Bootstrapper', function() {
|
||||
var app;
|
||||
beforeEach(function() {
|
||||
app = loopback();
|
||||
process.bootFlags = [];
|
||||
});
|
||||
|
||||
it('should honor options.phases', function(done) {
|
||||
var options = {
|
||||
app: app,
|
||||
appRootDir: path.join(__dirname, './fixtures/simple-app'),
|
||||
phases: ['load'],
|
||||
};
|
||||
|
||||
var bootstrapper = new Bootstrapper(options);
|
||||
|
||||
var context = {
|
||||
app: app,
|
||||
};
|
||||
|
||||
bootstrapper.run(context, function(err) {
|
||||
if (err) return done(err);
|
||||
expect(context.configurations.application).to.be.object;
|
||||
expect(context.configurations.bootScripts).to.be.object;
|
||||
expect(context.configurations.middleware).to.be.object;
|
||||
expect(context.configurations.models).to.be.object;
|
||||
expect(context.instructions).to.be.undefined;
|
||||
expect(process.bootFlags.length).to.eql(0);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should honor options.plugins', function(done) {
|
||||
var options = {
|
||||
app: app,
|
||||
appRootDir: path.join(__dirname, './fixtures/simple-app'),
|
||||
plugins: ['application', 'boot-script'],
|
||||
};
|
||||
|
||||
var bootstrapper = new Bootstrapper(options);
|
||||
|
||||
var context = {
|
||||
app: app,
|
||||
};
|
||||
|
||||
bootstrapper.run(context, function(err) {
|
||||
if (err) return done(err);
|
||||
expect(context.configurations.application).to.be.object;
|
||||
expect(context.configurations.middleware).to.be.undefined;
|
||||
expect(context.configurations.models).to.be.undefined;
|
||||
expect(context.configurations.bootScripts).to.be.object;
|
||||
expect(context.instructions.application).to.be.object;
|
||||
expect(process.bootFlags).to.eql(['barLoaded',
|
||||
'barSyncLoaded',
|
||||
'fooLoaded',
|
||||
'barStarted',
|
||||
'barFinished',
|
||||
'barSyncExecuted',
|
||||
]);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
afterEach(function() {
|
||||
delete process.bootFlags;
|
||||
});
|
||||
});
|
||||
|
|
@ -58,11 +58,22 @@ describe('browser support for multiple apps', function() {
|
|||
});
|
||||
});
|
||||
|
||||
function addPlugins(b) {
|
||||
var files = fs.readdirSync(path.join(__dirname, '../lib/plugins'));
|
||||
files.forEach(function(f) {
|
||||
b.require('../../lib/plugins/' + f,
|
||||
{ expose: './plugins/' + path.basename(f, '.js') });
|
||||
});
|
||||
}
|
||||
|
||||
function browserifyTestApps(apps, next) {
|
||||
var b = browserify({
|
||||
debug: true,
|
||||
basedir: path.resolve(__dirname, './fixtures'),
|
||||
});
|
||||
|
||||
addPlugins(b);
|
||||
|
||||
for (var i in apps) {
|
||||
var appDir = apps[i].appDir;
|
||||
var appFile = apps[i].appFile;
|
||||
|
|
|
|||
|
|
@ -14,13 +14,21 @@ var vm = require('vm');
|
|||
var createBrowserLikeContext = require('./helpers/browser').createContext;
|
||||
var printContextLogs = require('./helpers/browser').printContextLogs;
|
||||
|
||||
function addPlugins(b) {
|
||||
var files = fs.readdirSync(path.join(__dirname, '../lib/plugins'));
|
||||
files.forEach(function(f) {
|
||||
b.require('../../../lib/plugins/' + f,
|
||||
{ expose: './plugins/' + path.basename(f, '.js') });
|
||||
});
|
||||
}
|
||||
|
||||
var compileStrategies = {
|
||||
'default': function(appDir) {
|
||||
var b = browserify({
|
||||
basedir: appDir,
|
||||
debug: true,
|
||||
});
|
||||
|
||||
addPlugins(b);
|
||||
b.require('./app.js', { expose: 'browser-app' });
|
||||
return b;
|
||||
},
|
||||
|
|
@ -31,7 +39,7 @@ var compileStrategies = {
|
|||
extensions: ['.coffee'],
|
||||
debug: true,
|
||||
});
|
||||
|
||||
addPlugins(b);
|
||||
b.transform('coffeeify');
|
||||
|
||||
b.require('./app.coffee', { expose: 'browser-app' });
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ describe('compiler', function() {
|
|||
|
||||
beforeEach(function() {
|
||||
options = {
|
||||
config: {
|
||||
application: {
|
||||
port: 3000,
|
||||
host: '127.0.0.1',
|
||||
restApiRoot: '/rest-api',
|
||||
|
|
@ -44,7 +44,7 @@ describe('compiler', function() {
|
|||
},
|
||||
};
|
||||
instructions = boot.compile(options);
|
||||
appConfig = instructions.config;
|
||||
appConfig = instructions.application;
|
||||
});
|
||||
|
||||
it('has port setting', function() {
|
||||
|
|
@ -549,7 +549,7 @@ describe('compiler', function() {
|
|||
{ cfgEnv: 'applied' });
|
||||
|
||||
var instructions = boot.compile(appdir.PATH);
|
||||
var appConfig = instructions.config;
|
||||
var appConfig = instructions.application;
|
||||
|
||||
expect(appConfig).to.have.property('cfgLocal', 'applied');
|
||||
expect(appConfig).to.have.property('cfgEnv', 'applied');
|
||||
|
|
@ -568,7 +568,7 @@ describe('compiler', function() {
|
|||
'module.exports = { fromJs: true };');
|
||||
|
||||
var instructions = boot.compile(appdir.PATH);
|
||||
var appConfig = instructions.config;
|
||||
var appConfig = instructions.application;
|
||||
|
||||
expect(appConfig).to.have.property('fromJs', true);
|
||||
});
|
||||
|
|
@ -587,7 +587,7 @@ describe('compiler', function() {
|
|||
appConfigRootDir: path.resolve(appdir.PATH, 'custom'),
|
||||
});
|
||||
|
||||
expect(instructions.config).to.have.property('port');
|
||||
expect(instructions.application).to.have.property('port');
|
||||
});
|
||||
|
||||
it('supports `dsRootDir` option', function() {
|
||||
|
|
@ -627,7 +627,7 @@ describe('compiler', function() {
|
|||
var initJs = appdir.writeFileSync('boot/init.js',
|
||||
'module.exports = function(app) { app.fnCalled = true; };');
|
||||
var instructions = boot.compile(appdir.PATH);
|
||||
expect(instructions.files.boot).to.eql([initJs]);
|
||||
expect(instructions.bootScripts).to.eql([initJs]);
|
||||
});
|
||||
|
||||
it('supports `bootDirs` option', function() {
|
||||
|
|
@ -638,7 +638,7 @@ describe('compiler', function() {
|
|||
appRootDir: appdir.PATH,
|
||||
bootDirs: [path.dirname(initJs)],
|
||||
});
|
||||
expect(instructions.files.boot).to.eql([initJs]);
|
||||
expect(instructions.bootScripts).to.eql([initJs]);
|
||||
});
|
||||
|
||||
it('should resolve relative path in `bootDirs`', function() {
|
||||
|
|
@ -649,7 +649,7 @@ describe('compiler', function() {
|
|||
appRootDir: appdir.PATH,
|
||||
bootDirs: ['./custom-boot'],
|
||||
});
|
||||
expect(instructions.files.boot).to.eql([initJs]);
|
||||
expect(instructions.bootScripts).to.eql([initJs]);
|
||||
});
|
||||
|
||||
it('should resolve non-relative path in `bootDirs`', function() {
|
||||
|
|
@ -659,7 +659,7 @@ describe('compiler', function() {
|
|||
appRootDir: appdir.PATH,
|
||||
bootDirs: ['custom-boot'],
|
||||
});
|
||||
expect(instructions.files.boot).to.eql([initJs]);
|
||||
expect(instructions.bootScripts).to.eql([initJs]);
|
||||
});
|
||||
|
||||
it('ignores index.js in `bootDirs`', function() {
|
||||
|
|
@ -669,7 +669,7 @@ describe('compiler', function() {
|
|||
appRootDir: appdir.PATH,
|
||||
bootDirs: ['./custom-boot'],
|
||||
});
|
||||
expect(instructions.files.boot).to.have.length(0);
|
||||
expect(instructions.bootScripts).to.have.length(0);
|
||||
});
|
||||
|
||||
it('prefers coffeescript over json in `appRootDir/bootDir`', function() {
|
||||
|
|
@ -681,7 +681,7 @@ describe('compiler', function() {
|
|||
appRootDir: appdir.PATH,
|
||||
bootDirs: ['./custom-boot'],
|
||||
});
|
||||
expect(instructions.files.boot).to.eql([coffee]);
|
||||
expect(instructions.bootScripts).to.eql([coffee]);
|
||||
});
|
||||
|
||||
it('prefers coffeescript over json in `bootDir` non-relative path',
|
||||
|
|
@ -695,7 +695,7 @@ describe('compiler', function() {
|
|||
appRootDir: appdir.PATH,
|
||||
bootDirs: ['custom-boot'],
|
||||
});
|
||||
expect(instructions.files.boot).to.eql([coffee]);
|
||||
expect(instructions.bootScripts).to.eql([coffee]);
|
||||
});
|
||||
|
||||
it('supports `bootScripts` option', function() {
|
||||
|
|
@ -706,7 +706,7 @@ describe('compiler', function() {
|
|||
appRootDir: appdir.PATH,
|
||||
bootScripts: [initJs],
|
||||
});
|
||||
expect(instructions.files.boot).to.eql([initJs]);
|
||||
expect(instructions.bootScripts).to.eql([initJs]);
|
||||
});
|
||||
|
||||
it('should remove duplicate scripts', function() {
|
||||
|
|
@ -718,7 +718,7 @@ describe('compiler', function() {
|
|||
bootDirs: [path.dirname(initJs)],
|
||||
bootScripts: [initJs],
|
||||
});
|
||||
expect(instructions.files.boot).to.eql([initJs]);
|
||||
expect(instructions.bootScripts).to.eql([initJs]);
|
||||
});
|
||||
|
||||
it('should resolve relative path in `bootScripts`', function() {
|
||||
|
|
@ -729,7 +729,7 @@ describe('compiler', function() {
|
|||
appRootDir: appdir.PATH,
|
||||
bootScripts: ['./custom-boot/init.js'],
|
||||
});
|
||||
expect(instructions.files.boot).to.eql([initJs]);
|
||||
expect(instructions.bootScripts).to.eql([initJs]);
|
||||
});
|
||||
|
||||
it('should resolve non-relative path in `bootScripts`', function() {
|
||||
|
|
@ -739,7 +739,7 @@ describe('compiler', function() {
|
|||
appRootDir: appdir.PATH,
|
||||
bootScripts: ['custom-boot/init.js'],
|
||||
});
|
||||
expect(instructions.files.boot).to.eql([initJs]);
|
||||
expect(instructions.bootScripts).to.eql([initJs]);
|
||||
});
|
||||
|
||||
it('resolves missing extensions in `bootScripts`', function() {
|
||||
|
|
@ -749,7 +749,7 @@ describe('compiler', function() {
|
|||
appRootDir: appdir.PATH,
|
||||
bootScripts: ['./custom-boot/init'],
|
||||
});
|
||||
expect(instructions.files.boot).to.eql([initJs]);
|
||||
expect(instructions.bootScripts).to.eql([initJs]);
|
||||
});
|
||||
|
||||
it('resolves missing extensions in `bootScripts` in module relative path',
|
||||
|
|
@ -761,7 +761,7 @@ describe('compiler', function() {
|
|||
appRootDir: appdir.PATH,
|
||||
bootScripts: ['custom-boot/init'],
|
||||
});
|
||||
expect(instructions.files.boot).to.eql([initJs]);
|
||||
expect(instructions.bootScripts).to.eql([initJs]);
|
||||
});
|
||||
|
||||
it('resolves module relative path for `bootScripts`', function() {
|
||||
|
|
@ -771,7 +771,7 @@ describe('compiler', function() {
|
|||
appRootDir: appdir.PATH,
|
||||
bootScripts: ['custom-boot/init.js'],
|
||||
});
|
||||
expect(instructions.files.boot).to.eql([initJs]);
|
||||
expect(instructions.bootScripts).to.eql([initJs]);
|
||||
});
|
||||
|
||||
it('explores `bootScripts` in app relative path', function() {
|
||||
|
|
@ -784,7 +784,7 @@ describe('compiler', function() {
|
|||
appRootDir: appdir.PATH,
|
||||
bootScripts: ['custom-boot/init.js'],
|
||||
});
|
||||
expect(instructions.files.boot).to.eql([appJs]);
|
||||
expect(instructions.bootScripts).to.eql([appJs]);
|
||||
});
|
||||
|
||||
it('ignores models/ subdirectory', function() {
|
||||
|
|
@ -793,7 +793,7 @@ describe('compiler', function() {
|
|||
|
||||
var instructions = boot.compile(appdir.PATH);
|
||||
|
||||
expect(instructions.files).to.not.have.property('models');
|
||||
expect(instructions.bootScripts).to.not.have.property('models');
|
||||
});
|
||||
|
||||
it('throws when models-config.json contains 1.x `properties`', function() {
|
||||
|
|
@ -1253,10 +1253,10 @@ describe('compiler', function() {
|
|||
appdir.createConfigFilesSync();
|
||||
|
||||
var instructions = boot.compile(appdir.PATH);
|
||||
instructions.config.modified = true;
|
||||
instructions.application.modified = true;
|
||||
|
||||
instructions = boot.compile(appdir.PATH);
|
||||
expect(instructions.config).to.not.have.property('modified');
|
||||
expect(instructions.application).to.not.have.property('modified');
|
||||
});
|
||||
|
||||
describe('for mixins', function() {
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ describe('executor', function() {
|
|||
});
|
||||
|
||||
var dummyInstructions = someInstructions({
|
||||
config: {
|
||||
application: {
|
||||
port: 0,
|
||||
host: '127.0.0.1',
|
||||
restApiRoot: '/rest-api',
|
||||
|
|
@ -62,18 +62,18 @@ describe('executor', function() {
|
|||
|
||||
describe('when booting', function() {
|
||||
it('should set the `booting` flag during execution', function(done) {
|
||||
expect(app.booting).to.be.undefined();
|
||||
expect(app.booting).to.be.undefined;
|
||||
boot.execute(app, simpleAppInstructions(), function(err) {
|
||||
expect(err).to.be.undefined();
|
||||
expect(process.bootingFlagSet).to.be.true();
|
||||
expect(app.booting).to.be.false();
|
||||
expect(err).to.be.undefined;
|
||||
expect(process.bootingFlagSet).to.be.true;
|
||||
expect(app.booting).to.be.false;
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('should emit the `booted` event in the next tick', function(done) {
|
||||
boot.execute(app, dummyInstructions, function(err) {
|
||||
expect(err).to.be.undefined();
|
||||
expect(err).to.be.undefined;
|
||||
});
|
||||
app.on('booted', function() {
|
||||
// This test fails with a timeout when the `booted` event has not been
|
||||
|
|
@ -119,7 +119,7 @@ describe('executor', function() {
|
|||
],
|
||||
}));
|
||||
|
||||
expect(app.models.Customer).to.exist();
|
||||
expect(app.models.Customer).to.exist;
|
||||
expect(app.models.Customer.settings._customized).to.be.equal('Customer');
|
||||
var UserModel = app.registry.getModel('User');
|
||||
expect(UserModel.settings._customized).to.equal('Base');
|
||||
|
|
@ -209,7 +209,7 @@ describe('executor', function() {
|
|||
'require("doesnt-exist"); module.exports = {};');
|
||||
|
||||
function doBoot() {
|
||||
boot.execute(app, someInstructions({ files: { boot: [file] }}));
|
||||
boot.execute(app, someInstructions({ bootScripts: [file] }));
|
||||
}
|
||||
|
||||
expect(doBoot).to.throw(/Cannot find module \'doesnt-exist\'/);
|
||||
|
|
@ -237,7 +237,7 @@ describe('executor', function() {
|
|||
it('skips definition of already defined LoopBack models', function() {
|
||||
var builtinModel = {
|
||||
name: 'User',
|
||||
definition: fs.readJsonFileSync(
|
||||
definition: fs.readJsonSync(
|
||||
require.resolve('loopback/common/models/user.json')
|
||||
),
|
||||
config: { dataSource: 'db' },
|
||||
|
|
@ -360,7 +360,7 @@ describe('executor', function() {
|
|||
function bootWithDefaults() {
|
||||
app = loopback();
|
||||
boot.execute(app, someInstructions({
|
||||
config: {
|
||||
application: {
|
||||
port: undefined,
|
||||
host: undefined,
|
||||
},
|
||||
|
|
@ -429,19 +429,19 @@ describe('executor', function() {
|
|||
}
|
||||
|
||||
it('should honor 0 for free port', function() {
|
||||
boot.execute(app, someInstructions({ config: { port: 0 }}));
|
||||
boot.execute(app, someInstructions({ application: { port: 0 }}));
|
||||
assert.equal(app.get('port'), 0);
|
||||
});
|
||||
|
||||
it('should default to port 3000', function() {
|
||||
boot.execute(app, someInstructions({ config: { port: undefined }}));
|
||||
boot.execute(app, someInstructions({ application: { port: undefined }}));
|
||||
assert.equal(app.get('port'), 3000);
|
||||
});
|
||||
|
||||
it('should respect named pipes port values in ENV', function() {
|
||||
var NAMED_PORT = '\\.\\pipe\\test';
|
||||
process.env.PORT = NAMED_PORT;
|
||||
boot.execute(app, someInstructions({ config: { port: 3000 }}));
|
||||
boot.execute(app, someInstructions({ application: { port: 3000 }}));
|
||||
assert.equal(app.get('port'), NAMED_PORT);
|
||||
});
|
||||
});
|
||||
|
|
@ -482,7 +482,7 @@ describe('executor', function() {
|
|||
var bootInstructions;
|
||||
bootInstructions = simpleMiddlewareConfig('routes',
|
||||
{ path: '${restApiRoot}' });
|
||||
bootInstructions.config = { restApiRoot: '/url-from-config' };
|
||||
bootInstructions.application = { restApiRoot: '/url-from-config' };
|
||||
boot.execute(app, someInstructions(bootInstructions));
|
||||
|
||||
supertest(app).get('/url-from-env-var').end(function(err, res) {
|
||||
|
|
@ -576,8 +576,8 @@ describe('executor', function() {
|
|||
supertest(app)
|
||||
.get('/')
|
||||
.end(function(err, res) {
|
||||
expect(err).to.be.null();
|
||||
expect(res.body.path).to.be.undefined();
|
||||
expect(err).to.be.null;
|
||||
expect(res.body.path).to.be.undefined;
|
||||
cb();
|
||||
});
|
||||
}, done);
|
||||
|
|
@ -592,7 +592,7 @@ describe('executor', function() {
|
|||
supertest(app)
|
||||
.get('/')
|
||||
.end(function(err, res) {
|
||||
expect(err).to.be.null();
|
||||
expect(err).to.be.null;
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
|
@ -639,7 +639,7 @@ describe('executor', function() {
|
|||
);
|
||||
|
||||
// result should get value from config.json
|
||||
bootInstructions.config['DYNAMIC_CONFIG'] = 'FOOBAR-CONFIG';
|
||||
bootInstructions.application['DYNAMIC_CONFIG'] = 'FOOBAR-CONFIG';
|
||||
// result should get value from env var
|
||||
process.env.DYNAMIC_ENVVAR = 'FOOBAR-ENVVAR';
|
||||
|
||||
|
|
@ -658,7 +658,7 @@ describe('executor', function() {
|
|||
path: '${restApiRoot}',
|
||||
isDynamic: '${' + key + '}',
|
||||
});
|
||||
bootInstructions.config[key] = 'should be overwritten';
|
||||
bootInstructions.application[key] = 'should be overwritten';
|
||||
process.env[key] = 'successfully overwritten';
|
||||
|
||||
boot.execute(app, bootInstructions);
|
||||
|
|
@ -730,8 +730,8 @@ describe('executor', function() {
|
|||
'module.exports = function(app) { app.fnCalled = true; };');
|
||||
|
||||
delete app.fnCalled;
|
||||
boot.execute(app, someInstructions({ files: { boot: [file] }}));
|
||||
expect(app.fnCalled, 'exported fn was called').to.be.true();
|
||||
boot.execute(app, someInstructions({ bootScripts: [file] }));
|
||||
expect(app.fnCalled, 'exported fn was called').to.be.true;
|
||||
});
|
||||
|
||||
it('configures middleware', function(done) {
|
||||
|
|
@ -901,10 +901,10 @@ describe('executor', function() {
|
|||
|
||||
describe('when booting with env', function() {
|
||||
it('should set the `booting` flag during execution', function(done) {
|
||||
expect(app.booting).to.be.undefined();
|
||||
expect(app.booting).to.be.undefined;
|
||||
boot.execute(app, envAppInstructions(), function(err) {
|
||||
if (err) return done(err);
|
||||
expect(app.booting).to.be.false();
|
||||
expect(app.booting).to.be.false;
|
||||
expect(process.bootFlags).to.not.have.property('barLoadedInTest');
|
||||
done();
|
||||
});
|
||||
|
|
@ -997,7 +997,7 @@ describe('executor', function() {
|
|||
mydb: { host: '${DYNAMIC_HOST}' },
|
||||
};
|
||||
var bootInstructions = {
|
||||
config: { DYNAMIC_HOST: '127.0.0.4' },
|
||||
application: { DYNAMIC_HOST: '127.0.0.4' },
|
||||
dataSources: datasource,
|
||||
};
|
||||
boot.execute(app, someInstructions(bootInstructions), function() {
|
||||
|
|
@ -1014,7 +1014,7 @@ describe('executor', function() {
|
|||
mydb: { host: '${DYNAMIC_HOST}' },
|
||||
};
|
||||
var bootInstructions = {
|
||||
config: { DYNAMIC_HOST: '127.0.0.3' },
|
||||
application: { DYNAMIC_HOST: '127.0.0.3' },
|
||||
dataSources: datasource,
|
||||
};
|
||||
boot.execute(app, someInstructions(bootInstructions), function() {
|
||||
|
|
@ -1031,8 +1031,8 @@ describe('executor', function() {
|
|||
var bootInstructions = { dataSources: datasource };
|
||||
|
||||
boot.execute(app, someInstructions(bootInstructions), function() {
|
||||
expect(app.get('DYNAMIC_HOST')).to.be.undefined();
|
||||
expect(app.datasources.mydb.settings.host).to.be.undefined();
|
||||
expect(app.get('DYNAMIC_HOST')).to.be.undefined;
|
||||
expect(app.datasources.mydb.settings.host).to.be.undefined;
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
|
@ -1095,14 +1095,12 @@ assert.isFunc = function(obj, name) {
|
|||
|
||||
function someInstructions(values) {
|
||||
var result = {
|
||||
config: values.config || {},
|
||||
application: values.application || {},
|
||||
models: values.models || [],
|
||||
dataSources: values.dataSources || { db: { connector: 'memory' }},
|
||||
middleware: values.middleware || { phases: [], middleware: [] },
|
||||
components: values.components || [],
|
||||
files: {
|
||||
boot: [],
|
||||
},
|
||||
bootScripts: values.bootScripts || [],
|
||||
};
|
||||
|
||||
if (values.env)
|
||||
|
|
|
|||
|
|
@ -58,6 +58,8 @@ function createContext() {
|
|||
error: [],
|
||||
},
|
||||
},
|
||||
|
||||
ArrayBuffer: ArrayBuffer,
|
||||
};
|
||||
|
||||
// `window` is used by loopback to detect browser runtime
|
||||
|
|
|
|||
Loading…
Reference in New Issue