Initialize an application from an options object or a set of JSON and JavaScript files.
This function takes an optional argument that is either a string or an object.
If the argument is a string, then it sets the application root directory based on the string value. Then it:
Creates DataSources from the datasources.json
file in the application
root directory.
Creates Models from the models.json
file in the application
root directory.
If the argument is an object, then it looks for model
, dataSources
,
and appRootDir
properties of the object.
If the object has no appRootDir
property then it sets the current working
directory as the application root directory.
Then it:
Creates DataSources from the options.dataSources
object.
Creates Models from the options.models
object.
In both cases, the function loads JavaScript files in the /models
and
/boot
subdirectories of the application root directory with require()
.
NOTE: mixing app.boot()
and app.model(name, config)
in multiple
files may result in models being undefined due to race conditions.
To avoid this when using app.boot()
make sure all models are passed
as part of the models
definition.
Throws an error if the config object is not valid or if boot fails.
Name | Type | Description |
---|---|---|
app |
|
LoopBack application created by |
options |
String or Object
|
Boot options; If String, this is the application root directory; if object, has below properties. |
Name | Type | Description |
---|---|---|
appRootDir |
String
|
Directory to use when loading JSON and JavaScript files (optional).
Defaults to the current directory ( |
models |
Object
|
Object containing |
dataSources |
Object
|
Object containing |
modelsRootDir |
String
|
Directory to use when loading |
datasourcesRootDir |
String
|
Directory to use when loading |
env |
String
|
Environment type, defaults to |
Compile boot instructions and add them to a browserify bundler.
Name | Type | Description |
---|---|---|
options |
Object or String
|
as described in |
bundler |
Object
|
A browserify bundler created by |
The browser version of bootLoopBackApp
.
When loopback-boot is loaded in browser, the module exports this
function instead of bootLoopBackApp
.
The function expects the boot instructions to be included in
the browser bundle, see boot.compileToBrowserify
.
Name | Type | Description |
---|---|---|
app |
Object
|
The loopback app to boot, as returned by |
The following is example JSON for two Model
definitions:
"dealership" and "location".
{
"dealership": {
// a reference, by name, to a dataSource definition
"dataSource": "my-db",
// the options passed to Model.extend(name, properties, options)
"options": {
"relations": {
"cars": {
"type": "hasMany",
"model": "Car",
"foreignKey": "dealerId"
}
}
},
// the properties passed to Model.extend(name, properties, options)
"properties": {
"id": {"id": true},
"name": "String",
"zip": "Number",
"address": "String"
}
},
"car": {
"dataSource": "my-db"
"properties": {
"id": {
"type": "String",
"required": true,
"id": true
},
"make": {
"type": "String",
"required": true
},
"model": {
"type": "String",
"required": true
}
}
}
}
The bootstrap process is implemented in two steps that can be called independently.
The first step loads all configuration files, merges values from additional
config files like app.local.js
and produces a set of instructions
that can be used to boot the application.
These instructions must be included in the browser bundle together
with all configuration scripts from models/
and boot/
.
Don't worry, you don't have to understand these details.
Just call boot.compileToBrowserify
, it will take care of everything for you.
/*-- build file --*/
var browserify = require('browserify');
var boot = require('loopback-boot');
var b = browserify({
basedir: appDir,
});
// add the main application file
b.require('./app.js', { expose: 'loopback-app' });
// add boot instructions
boot.compileToBrowserify(appDir, b);
// create the bundle
var out = fs.createWriteStream('app.bundle.js');
b.bundle().pipe(out);
// handle out.on('error') and out.on('close')
In the browser, the main application file should call loopback-boot to setup the loopback application by executing the instructions contained in the browser bundle:
/*-- app.js --*/
var loopback = require('loopback');
var boot = require('loopback-boot');
var app = module.exports = loopback();
boot(app);
The app object created above can be accessed via require('loopback-app')
,
where loopback-app
is the identifier used for the main app file in
the browserify build shown above.
Here is a simple example demonstrating the concept:
<script src="app.bundle.js"></script>
<script>
var app = require('loopback-app');
var User = app.models.User;
User.login({ email: 'test@example.com', password: '12345', function(err, res) {
if (err) {
console.error('Login failed: ', err);
} else {
console.log('Logged in.');
}
});
</script>