• thorin.error(code=string)// generic error message and status 400
• thorin.error(code=string, message=string)// default status 400
• thorin.error(code=string, message=string, statusCode=number)
• thorin.error(code=string, message=string, error=Error)// attach error stack to the custom error
• thorin.error(error=Error) // wrap a node.js error inside a thorin error with a default SERVER_ERROR code and status 500

'use strict';
const fs = require('fs');
function readFile(fpath) {
   fs.readFile(fpath, (err, content) => {
      if(err) return Promise.reject(thorin.error(err));  // wrap the default error in a thorin.error()
      return content;
   });
}

'use strict';
const fs = require('fs');
function readFile(fpath) {
   fs.readFile(fpath, (err, content) => {
      if(err) throw err;         // NEVER throw in an async context, but gracefully handle the error.
      // do something with content
   });
}

'use strict';
const myObj = thorin.util.extend({"v1": "one"}, {"v2": "two"});
// myObj is now {"v1": "one", "v2": "two"} with a new object reference.

• ext - only include files with the specified extension, OR
• dirs - if set to true, return only directories
• modules - if set to true, will go into node_modules folders, by default it excludes them.
• relative - if set to true, all resulting paths will be converted to the relative path of the search path, excluding the first slash (eg: /home/ec2-user/myapp/myfolder/app.js => myfolder/app.js)

• thorin.fetcher(url=string, opt=object) // creates a fetcher but does not cache it
• thorin.fetcher(name=string, url=string, opt=object // creates a fetcher and caches it using the given name
• thorin.fetcher(name=string) // returns a previously cached fetcher

'use strict';
const mailer = thorin.fetcher('mailer', 'http://localhost:12301/dispatch', {authorization: 'SOME_TOKEN'});
mailer
   .dispatch('my.action', {some: "payload"})
   .then((res) => {
      log.info('Mailer responded with', res);
   })
   .catch((e) => {});

// Access a previously defined fetcher.
const mailerApi = thorin.fetcher('mailer');

• The paths that are to be loaded can be either directory or file paths. If a path is a directory, thorin will try to recursively load all the .js files inside that directory.
• If the path is not absolute, the full path will be thorin.root + '/' + path (use the application folder as the root path).
• When calling loadPath(path, true), the require() call will wait untill you call thorin's run() function to boot up the application and wait untill all components had their init() function called.
• If the exported variable of a required file is a function, thorin will call it, passing any additional arguments that you've specified in the loadPaths() call, excluding the paths and ignoreInitialized arguments.

'use strict';
const thorin = require('thorin');
// File: app.js
thorin.loadPath('app/lib', thorin, "Hello"); // pass thorin and true as a variable for the exported functions.

'use strict';
// File: app/lib/file.js
module.exports = (thorin, word) => {
   log.info('Required with word:', word);
   // do stuff.
}

• thorin.series(items=array,stopOnError=false) // work with promises and won't stop on first error.
• thorin.series(items=array, onComplete=function, stopOnError=false) // work with callback and won't stop on the first error.
• thorin.series(items=array, onComplete=function) // works with callback, stops at first error
• thorin.series(items=array) // works with promises, stops at first error.

'use strict';
const store = thorin.store('sql');
const calls = [];
let appObj;
calls.push(() => {
   const Account = store.model('account');
   return Account.build({email: 'john@doe.com'});
});
if(thorin.env === 'production') {
   calls.push(() => {
      log.info('Account created');
      return Application.find({where: { id: 1 }).then((obj) => appObj = obj);
   });
}
calls.push(() => {
   if(!appObj) return;
   return appObj.update({is_active: true});
});

thorin.series(calls, (e) => {
   log.info('All done!');
});