601 lines
17 KiB
JavaScript
601 lines
17 KiB
JavaScript
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 debug = require('debug')('loopback:boot:compiler');
|
|
var Module = require('module');
|
|
var _ = require('lodash');
|
|
var _s = require('underscore.string');
|
|
|
|
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);
|
|
|
|
// not configurable yet
|
|
var middlewareRootDir = appRootDir;
|
|
|
|
var middlewareConfig = options.middleware ||
|
|
ConfigLoader.loadMiddleware(middlewareRootDir, env);
|
|
var middlewareInstructions =
|
|
buildMiddlewareInstructions(middlewareRootDir, middlewareConfig);
|
|
|
|
var componentRootDir = appRootDir; // not configurable yet
|
|
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));
|
|
});
|
|
|
|
// 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);
|
|
|
|
// 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 = {
|
|
config: appConfig,
|
|
dataSources: dataSourcesConfig,
|
|
models: modelInstructions,
|
|
middleware: middlewareInstructions,
|
|
components: componentInstructions,
|
|
files: {
|
|
boot: bootScripts
|
|
}
|
|
};
|
|
|
|
if (options.appId)
|
|
instructions.appId = options.appId;
|
|
|
|
return cloneDeep(instructions);
|
|
};
|
|
|
|
function assertIsValidConfig(name, config) {
|
|
if (config) {
|
|
assert(typeof config === 'object',
|
|
name + ' config must be a valid JSON object');
|
|
}
|
|
}
|
|
|
|
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.');
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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) {
|
|
assert(dir, 'cannot require directory contents without directory name');
|
|
|
|
var files = tryReadDir(dir);
|
|
|
|
// 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) {
|
|
var registry = 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 findModelDefinitions(rootDir, sources) {
|
|
var registry = {};
|
|
|
|
sources.forEach(function(src) {
|
|
var srcDir = tryResolveAppPath(rootDir, src);
|
|
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) {
|
|
var err = new Error('Cannot resolve path "' + 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, while resolving
|
|
* component path, `resolveOptions` parameter is added where
|
|
* `resolveOptions.strict` = true,
|
|
* means retain backward compatibility when resolving the path and
|
|
* `resolveOptions.strict` = false,
|
|
* does not enforce any such restriction when resolving the path */
|
|
resolveOptions = resolveOptions || { strict: false };
|
|
|
|
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) {
|
|
try {
|
|
var filePath = path.join(candidateDir, relativePath);
|
|
filePath = require.resolve(filePath);
|
|
return filePath;
|
|
} catch (err) {
|
|
return filePath;
|
|
}
|
|
})
|
|
.filter(function(candidate) {
|
|
return fs.existsSync(candidate);
|
|
})
|
|
[0];
|
|
|
|
if (fullPath)
|
|
return fullPath;
|
|
|
|
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 || _s.capitalize(_s.camelize(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);
|
|
|
|
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) {
|
|
var resolved = {};
|
|
|
|
var segments = middleware.split('#');
|
|
var pathName = segments[0];
|
|
var fragment = segments[1];
|
|
var middlewarePath = pathName;
|
|
var opts = { strict: true };
|
|
|
|
if (fragment) {
|
|
resolved.fragment = fragment;
|
|
}
|
|
|
|
if (pathName.indexOf('./') === 0 || pathName.indexOf('../') === 0) {
|
|
// Relative path
|
|
pathName = path.resolve(rootDir, pathName);
|
|
}
|
|
|
|
if (!fragment) {
|
|
resolved.sourceFile = resolveAppScriptPath(rootDir, middlewarePath, opts);
|
|
return resolved;
|
|
}
|
|
|
|
var err;
|
|
|
|
// 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 = resolveAppScriptPath(rootDir, middlewarePath, opts);
|
|
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
|
|
];
|
|
|
|
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) {
|
|
relativePaths.forEach(function(relativePath, k) {
|
|
var resolvedPath = tryResolveAppPath(appRootDir, relativePath);
|
|
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);
|
|
var sourceDir = path.dirname(resolvedPath);
|
|
var files = tryReadDir(sourceDir);
|
|
var fixedFile = fixFileExtension(resolvedPath, files, false);
|
|
return (fixedFile === undefined ? resolvedPath : fixedFile);
|
|
}
|