denali/dist/denali.fragment.js

(function denali() {
  loader.scope('denali', '0.0.42', (loader) => {



// app/actions/error.js
//========================================

loader.add('/app/actions/error.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const assert = require("assert");
const action_1 = require("../../lib/runtime/action");
const container_1 = require("../../lib/metal/container");
/**
 * The default error action. When Denali encounters an error while processing a request, it will
 * attempt to hand off that error to the `error` action, which can determine how to respond. This is
 * a good spot to do things like report the error to an error-tracking service, sanitize the error
 * response based on environment (i.e. a full stack trace in dev, but limited info in prod), etc.
 *
 * @export
 * @class ErrorAction
 * @extends {Action}
 */
class ErrorAction extends action_1.default {
    constructor() {
        super(...arguments);
        this.logger = container_1.lookup('app:logger');
        this.parser = container_1.lookup('parser:json');
    }
    get originalAction() {
        return this.request._originalAction;
    }
    /**
     * Respond with JSON by default
     */
    async respond({ params }) {
        let error = params.error;
        assert(error, 'Error action must be invoked with an error as a param');
        // Print the error to the logs
        if ((!error.status || error.status >= 500) && this.config.environment !== 'test') {
            this.logger.error(`Request ${this.request.id} errored:\n${error.stack || error.message}`);
        }
        // Ensure a default status code of 500
        error.status = error.statusCode = error.statusCode || 500;
        // If debugging info is allowed, attach some debugging info to standard
        // locations.
        if (this.config.getWithDefault('logging', 'showDebuggingInfo', this.config.environment !== 'production')) {
            error.meta = error.meta || {};
            Object.assign(error.meta, {
                stack: error.stack.split('\n'),
                action: this.originalAction
            });
            // Otherwise, sanitize the output
        }
        else {
            if (error.statusCode === 500) {
                error.message = 'Internal Error';
            }
            delete error.stack;
        }
        if (this.request.accepts('html') && this.config.environment !== 'production') {
            this.render(error.status, error, { view: 'error.html' });
        }
        else {
            this.render(error.status, error);
        }
    }
}
exports.default = ErrorAction;

});



// app/actions/index.js
//========================================

loader.add('/app/actions/index.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const action_1 = require("../../lib/runtime/action");
class IndexAction extends action_1.default {
    respond() {
        return this.render(200, { hello: 'world' }, { serializer: 'json' });
    }
}
exports.default = IndexAction;

});



// app/addon.js
//========================================

loader.add('/app/addon.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const lib_1 = require("../lib");
class MyAddonAddon extends lib_1.Addon {
}
exports.default = MyAddonAddon;

});



// app/logger.js
//========================================

loader.add('/app/logger.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var logger_1 = require("../lib/runtime/logger");
exports.default = logger_1.default;

});



// app/orm-adapters/application.js
//========================================

loader.add('/app/orm-adapters/application.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var memory_1 = require("../../lib/data/memory");
exports.default = memory_1.default;

});



// app/orm-adapters/memory.js
//========================================

loader.add('/app/orm-adapters/memory.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var memory_1 = require("../../lib/data/memory");
exports.default = memory_1.default;

});



// app/parsers/application.js
//========================================

loader.add('/app/parsers/application.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var json_api_1 = require("./json-api");
exports.default = json_api_1.default;

});



// app/parsers/json-api.js
//========================================

loader.add('/app/parsers/json-api.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var json_api_1 = require("../../lib/parse/json-api");
exports.default = json_api_1.default;

});



// app/parsers/json.js
//========================================

loader.add('/app/parsers/json.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var json_1 = require("../../lib/parse/json");
exports.default = json_1.default;

});



// app/router.js
//========================================

loader.add('/app/router.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var router_1 = require("../lib/runtime/router");
exports.default = router_1.default;

});



// app/serializers/application.js
//========================================

loader.add('/app/serializers/application.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var json_api_1 = require("./json-api");
exports.default = json_api_1.default;

});



// app/serializers/json-api.js
//========================================

loader.add('/app/serializers/json-api.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var json_api_1 = require("../../lib/render/json-api");
exports.default = json_api_1.default;

});



// app/serializers/json.js
//========================================

loader.add('/app/serializers/json.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var json_1 = require("../../lib/render/json");
exports.default = json_1.default;

});



// app/services/config.js
//========================================

loader.add('/app/services/config.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var config_1 = require("../../lib/runtime/config");
exports.default = config_1.default;

});



// app/views/error.js
//========================================

loader.add('/app/views/error.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const lodash_1 = require("lodash");
const view_1 = require("../../lib/render/view");
let template = lodash_1.template(`
  <html>
    <head>
      <style>
        body {
          font-family: Arial, Helvetica, sans-serif;
          background: #f7f7f7;
          margin: 0;
        }
        pre {
          font-family: Inconsolata, Monaco, Menlo, monospace;
        }
        .headline {
          background: #fff;
          padding: 30px;
          color: #DC4B4B;
          font-family: Inconsolata, Monaco, Menlo, monospace;
          border-bottom: 1px solid #ddd;
          margin-bottom: 0;
        }
        .lead {
          display: block;
          margin-bottom: 7px;
          color: #aaa;
          font-size: 14px;
          font-family: Arial, Helvetica, sans-serif;
          font-weight: 300;
        }
        .details {
          padding: 30px;
        }
      </style>
    </head>
    <body>
      <h1 class='headline'>
        <small class='lead'>There was an error with this request:</small>
        <%= data.error.message %>
      </h1>
      <div class='details'>
        <% if (data.error.action) { %>
          <h2 class='source'>from <%= data.error.action %></h2>
        <% } %>
        <h5>Stacktrace:</h5>
        <pre><code><%= data.error.stack %></code></pre>
      </div>
    </body>
  </html>
`, {
    variable: 'data'
});
class ErrorView extends view_1.default {
    async render(action, response, error, options) {
        response.setHeader('Content-type', 'text/html');
        error.stack = error.stack.replace('\\n', '\n');
        response.write(template({ error }));
        response.end();
    }
}
exports.default = ErrorView;

});



// config/environment.js
//========================================

loader.add('/config/environment.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

module.exports = function baseConfig(environment, appConfig) {
    if (!appConfig.logging) {
        appConfig.logging = {};
    }
    if (!appConfig.logging.hasOwnProperty('showDebuggingInfo')) {
        appConfig.logging.showDebuggingInfo = environment !== 'production';
    }
};

});



// config/initializers/define-orm-models.js
//========================================

loader.add('/config/initializers/define-orm-models.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const lodash_1 = require("lodash");
const container_1 = require("../../lib/metal/container");
exports.default = {
    name: 'define-orm-models',
    /**
     * Find all models, group them by their orm adapter, then give each adapter the chance to define
     * any internal model representation necessary.
     */
    async initialize(application) {
        let models = container_1.default.lookupAll('model');
        let modelsGroupedByAdapter = new Map();
        lodash_1.forEach(models, (ModelClass, modelName) => {
            if (ModelClass.hasOwnProperty('abstract') && ModelClass.abstract) {
                return;
            }
            let Adapter = container_1.lookup(`orm-adapter:${modelName}`, { loose: true }) || container_1.default.lookup('orm-adapter:application');
            if (!modelsGroupedByAdapter.has(Adapter)) {
                modelsGroupedByAdapter.set(Adapter, []);
            }
            modelsGroupedByAdapter.get(Adapter).push(ModelClass);
        });
        for (let [Adapter, models] of modelsGroupedByAdapter) {
            if (Adapter.defineModels) {
                await Adapter.defineModels(models);
            }
        }
    }
};

});



// config/middleware.js
//========================================

loader.add('/config/middleware.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const lodash_1 = require("lodash");
const timing = require("response-time");
const compression = require("compression");
const cookies = require("cookie-parser");
const cors = require("cors");
const helmet = require("helmet");
const morgan = require("morgan");
/**
 * Denali ships with several base middleware included, each of which can be enabled/disabled
 * individually through config options.
 */
function baseMiddleware(router, application) {
    let config = application.config;
    /**
     * Returns true if the given property either does not exist on the config object, or it does exist
     * and it's `enabled` property is not `false`. All the middleware here are opt out, so to disable
     * you must define set that middleware's root config property to `{ enabled: false }`
     */
    function isEnabled(prop) {
        return config.get(prop) == null || config.get(prop, 'enabled') !== false;
    }
    if (isEnabled('timing')) {
        router.use(timing());
    }
    if (isEnabled('logging')) {
        let defaultLoggingFormat = application.environment === 'production' ? 'combined' : 'dev';
        let defaultLoggingOptions = {
            // tslint:disable-next-line:completed-docs
            skip() {
                return application.environment === 'test';
            }
        };
        let format = config.getWithDefault('logging', 'format', defaultLoggingFormat);
        let options = lodash_1.defaults(config.getWithDefault('logging', {}), defaultLoggingOptions);
        router.use(morgan(format, options));
        // Patch morgan to read from our non-express response
        morgan.token('res', (req, res, field) => {
            let header = res.getHeader(field);
            if (typeof header === 'number') {
                header = String(header);
            }
            else if (Array.isArray(header)) {
                header = header.join(', ');
            }
            return header;
        });
    }
    if (isEnabled('compression')) {
        router.use(compression());
    }
    if (isEnabled('cookies')) {
        router.use(cookies(config.get('cookies')));
    }
    if (isEnabled('cors')) {
        router.use(cors(config.get('cors')));
    }
    if (isEnabled('xssFilter')) {
        router.use(helmet.xssFilter());
    }
    if (isEnabled('frameguard')) {
        router.use(helmet.frameguard());
    }
    if (isEnabled('hidePoweredBy')) {
        router.use(helmet.hidePoweredBy());
    }
    if (isEnabled('ieNoOpen')) {
        router.use(helmet.ieNoOpen());
    }
    if (isEnabled('noSniff')) {
        router.use(helmet.noSniff());
    }
}
exports.default = baseMiddleware;

});



// lib/data/descriptors.js
//========================================

loader.add('/lib/data/descriptors.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
/**
 * Base Descriptor class
 *
 * @package data
 */
class Descriptor {
    /**
     * Creates an instance of Descriptor.
     */
    constructor(options = {}) {
        this.options = options;
    }
}
exports.Descriptor = Descriptor;
/**
 * The Attribute class is used to tell Denali what the available attributes are
 * on your Model. You shouldn't use the Attribute class directly; instead,
 * import the `attr()` method from Denali, and use it to define an attribute:
 *
 *     import { attr } from 'denali';
 *     class Post extends ApplicationModel {
 *       static title = attr('text');
 *     }
 *
 * Note that attributes must be defined as `static` properties on your Model
 * class.
 *
 * The `attr()` method takes two arguments:
 *
 *   * `type` - a string indicating the type of this attribute. Denali doesn't
 *   care what this string is. Your ORM adapter should specify what types it
 *   expects.
 *   * `options` - any additional options for this attribute. At the moment,
 *   these are used solely by your ORM adapter, there are no additional options
 *   that Denali expects itself.
 *
 * @package data
 * @since 0.1.0
 */
class AttributeDescriptor extends Descriptor {
    constructor(datatype, options) {
        super(options);
        this.datatype = datatype;
        /**
         * Convenience flag for checking if this is an attribute
         *
         * @since 0.1.0
         */
        this.isAttribute = true;
    }
}
exports.AttributeDescriptor = AttributeDescriptor;
/**
 * Syntax sugar factory method for creating Attributes
 *
 * @package data
 * @since 0.1.0
 */
function attr(datatype, options) {
    return new AttributeDescriptor(datatype, options);
}
exports.attr = attr;
/**
 * The HasManyRelationship class is used to describe a 1 to many or many to
 * many relationship on your Model. You shouldn't use the HasManyRelationship
 * class directly; instead, import the `hasMany()` method from Denali, and use
 * it to define a relationship:
 *
 *     import { hasMany } from 'denali';
 *     class Post extends ApplicationModel {
 *       static comments = hasMany('comment');
 *     }
 *
 * Note that relationships must be defined as `static` properties on your Model
 * class.
 *
 * The `hasMany()` method takes two arguments:
 *
 *   * `type` - a string indicating the type of model for this relationship.
 *   * `options` - any additional options for this attribute. At the moment,
 *   these are used solely by your ORM adapter, there are no additional options
 *   that Denali expects itself.
 *
 * @package data
 * @since 0.1.0
 */
class HasManyRelationshipDescriptor extends Descriptor {
    constructor(relatedModelName, options) {
        super(options);
        this.relatedModelName = relatedModelName;
        /**
         * Convenience flag for checking if this is a relationship
         *
         * @since 0.1.0
         */
        this.isRelationship = true;
        /**
         * Relationship mode, i.e. 1 -> 1 or 1 -> N
         *
         * @since 0.1.0
         */
        this.mode = 'hasMany';
    }
}
exports.HasManyRelationshipDescriptor = HasManyRelationshipDescriptor;
/**
 * Syntax sugar factory function for creating HasManyRelationships
 *
 * @package data
 * @since 0.1.0
 */
function hasMany(relatedModelName, options) {
    return new HasManyRelationshipDescriptor(relatedModelName, options);
}
exports.hasMany = hasMany;
/**
 * The HasOneRelationship class is used to describe a 1 to many or 1 to 1
 * relationship on your Model. You shouldn't use the HasOneRelationship class
 * directly; instead, import the `hasOne()` method from Denali, and use it to
 * define a relationship:
 *
 *     import { hasOne } from 'denali';
 *     class Post extends ApplicationModel {
 *       static author = hasOne('user');
 *     }
 *
 * Note that relationships must be defined as `static` properties on your Model
 * class.
 *
 * The `hasOne()` method takes two arguments:
 *
 *   * `type` - a string indicating the type of model for this relationship.
 *   * `options` - any additional options for this attribute. At the moment,
 *   these are used solely by your ORM adapter, there are no additional options
 *   that Denali expects itself.
 *
 * @package data
 * @since 0.1.0
 */
class HasOneRelationshipDescriptor extends Descriptor {
    constructor(relatedModelName, options) {
        super(options);
        this.relatedModelName = relatedModelName;
        /**
         * Convenience flag for checking if this is a relationship
         *
         * @since 0.1.0
         */
        this.isRelationship = true;
        /**
         * Relationship mode, i.e. 1 -> 1 or 1 -> N
         *
         * @since 0.1.0
         */
        this.mode = 'hasOne';
    }
}
exports.HasOneRelationshipDescriptor = HasOneRelationshipDescriptor;
/**
 * Syntax sugar factory function for creating HasOneRelationships
 *
 * @package data
 * @since 0.1.0
 */
function hasOne(relatedModelName, options) {
    return new HasOneRelationshipDescriptor(relatedModelName, options);
}
exports.hasOne = hasOne;

});



// lib/data/memory.js
//========================================

loader.add('/lib/data/memory.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const lodash_1 = require("lodash");
const orm_adapter_1 = require("./orm-adapter");
const assert = require("assert");
const inflection_1 = require("inflection");
let guid = 0;
/**
 * An in-memory ORM adapter for getting started quickly, testing, and
 * debugging. Should **not** be used for production data.
 *
 * @package data
 * @since 0.1.0
 */
class MemoryAdapter extends orm_adapter_1.default {
    constructor() {
        super(...arguments);
        /**
         * An in-memory cache of records. Top level objects are collections of
         * records by type, indexed by record id.
         */
        this._cache = {};
    }
    /**
     * Get the collection of records for a given type, indexed by record id. If
     * the collection doesn't exist yet, create it and return the empty
     * collection.
     */
    _cacheFor(type) {
        if (!this._cache[type]) {
            this._cache[type] = {};
        }
        return this._cache[type];
    }
    // tslint:disable:completed-docs
    async find(type, id) {
        return this._cacheFor(type)[id] || null;
    }
    async queryOne(type, query) {
        return lodash_1.find(this._cacheFor(type), query) || null;
    }
    async all(type) {
        return lodash_1.values(this._cacheFor(type));
    }
    async query(type, query) {
        return lodash_1.filter(this._cacheFor(type), query);
    }
    buildRecord(type, data = {}) {
        this._cacheFor(type);
        return data;
    }
    idFor(model) {
        return model.record.id;
    }
    setId(model, value) {
        let collection = this._cacheFor(model.modelName);
        delete collection[model.record.id];
        model.record.id = value;
        collection[value] = model.record;
    }
    getAttribute(model, property) {
        return model.record[property] === undefined ? null : model.record[property];
    }
    setAttribute(model, property, value) {
        model.record[property] = value;
        return true;
    }
    deleteAttribute(model, property) {
        model.record[property] = null;
        return true;
    }
    async getRelated(model, relationship, descriptor, query) {
        let relatedCollection = this._cacheFor(descriptor.relatedModelName);
        if (descriptor.mode === 'hasMany') {
            let related = lodash_1.filter(relatedCollection, (relatedRecord) => {
                let relatedIds = model.record[`${inflection_1.singularize(relationship)}_ids`];
                return relatedIds && relatedIds.includes(relatedRecord.id);
            });
            if (query) {
                related = lodash_1.filter(related, query);
            }
            return related;
        }
        return this.queryOne(descriptor.relatedModelName, { id: model.record[`${relationship}_id`] });
    }
    async setRelated(model, relationship, descriptor, relatedModels) {
        if (Array.isArray(relatedModels)) {
            assert(descriptor.mode === 'hasMany', `You tried to set ${relationship} to an array of related records, but it is a hasOne relationship`);
            model.record[`${inflection_1.singularize(relationship)}_ids`] = lodash_1.map(relatedModels, 'record.id');
        }
        else {
            model.record[`${relationship}_id`] = relatedModels.record.id;
        }
    }
    async addRelated(model, relationship, descriptor, relatedModel) {
        let relatedIds = model.record[`${inflection_1.singularize(relationship)}_ids`];
        if (!relatedIds) {
            relatedIds = model.record[`${inflection_1.singularize(relationship)}_ids`] = [];
        }
        relatedIds.push(relatedModel.id);
    }
    async removeRelated(model, relationship, descriptor, relatedModel) {
        lodash_1.remove(model.record[`${inflection_1.singularize(relationship)}_ids`], (id) => id === relatedModel.id);
    }
    async saveRecord(model) {
        let collection = this._cacheFor(model.modelName);
        if (model.record.id == null) {
            guid += 1;
            model.record.id = guid;
        }
        collection[model.record.id] = model.record;
        return model.record;
    }
    async deleteRecord(model) {
        let collection = this._cacheFor(model.modelName);
        delete collection[model.record.id];
    }
}
exports.default = MemoryAdapter;

});



// lib/data/model.js
//========================================

loader.add('/lib/data/model.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const assert = require("assert");
const util = require("util");
const createDebug = require("debug");
const inflection_1 = require("inflection");
const lodash_1 = require("lodash");
const object_1 = require("../metal/object");
const container_1 = require("../metal/container");
const debug = createDebug('denali:model');
const augmentedWithAccessors = Symbol();
/**
 * The Model class is the core of Denali's unique approach to data and ORMs. It
 * acts as a wrapper and translation layer that provides a unified interface to
 * access and manipulate data, but translates those interactions into ORM
 * specific operations via ORM adapters.
 *
 * The primary purpose of having Models in Denali is to allow Denali addons to
 * access a common interface for manipulating data. Importantly, the goal is
 * **not** to let you swap different ORMs / databases with little effort. Don't
 * be surprised if you find your app littered with ORM specific code - that is
 * expected and even encouraged. For more on this concept, check out the Denali
 * blog.
 *
 * TODO: link to blog post on ^
 *
 * @package data
 * @since 0.1.0
 */
class Model extends object_1.default {
    /**
     * Tell the underlying ORM to build this record
     */
    constructor(data, options) {
        super();
        /**
         * The underlying ORM adapter record. An opaque value to Denali, handled
         * entirely by the ORM adapter.
         *
         * @since 0.1.0
         */
        this.record = null;
        this.constructor._augmentWithSchemaAccessors();
        this.record = this.constructor.adapter.buildRecord(this.modelName, data, options);
    }
    /**
     * Returns the schema filtered down to just the attribute fields
     */
    static get attributes() {
        // <any> is needed here because pickBy doesn't properly act as a type guard
        // see: https://github.com/Microsoft/TypeScript/issues/7657
        return lodash_1.pickBy(this.schema, (descriptor) => descriptor.isAttribute);
    }
    /**
     * Returns the schema filtered down to just the relationship fields
     */
    static get relationships() {
        // <any> is needed here because pickBy doesn't properly act as a type guard
        // see: https://github.com/Microsoft/TypeScript/issues/7657
        return lodash_1.pickBy(this.schema, (descriptor) => descriptor.isRelationship);
    }
    static _augmentWithSchemaAccessors() {
        if (this.prototype[augmentedWithAccessors]) {
            return;
        }
        this.prototype[augmentedWithAccessors] = true;
        lodash_1.forEach(this.schema, (descriptor, name) => {
            if (descriptor.isAttribute) {
                Object.defineProperty(this.prototype, name, {
                    configurable: true,
                    get() {
                        return this.constructor.adapter.getAttribute(this, name);
                    },
                    set(newValue) {
                        return this.constructor.adapter.setAttribute(this, name, newValue);
                    }
                });
            }
            else {
                // author => "Author"
                let methodRoot = lodash_1.upperFirst(name);
                // getAuthor(options?)
                Object.defineProperty(this.prototype, `get${methodRoot}`, {
                    configurable: true,
                    value(options) { return this.getRelated(name, options); }
                });
                // setAuthor(comments, options?)
                Object.defineProperty(this.prototype, `set${methodRoot}`, {
                    configurable: true,
                    value(relatedModels, options) {
                        return this.setRelated(name, relatedModels, options);
                    }
                });
                if (descriptor.mode === 'hasMany') {
                    let singularRoot = inflection_1.singularize(methodRoot);
                    // addComment(comment, options?)
                    Object.defineProperty(this.prototype, `add${singularRoot}`, {
                        configurable: true,
                        value(relatedModel, options) {
                            return this.addRelated(name, relatedModel, options);
                        }
                    });
                    // removeComment(comment, options?)
                    Object.defineProperty(this.prototype, `remove${singularRoot}`, {
                        configurable: true,
                        value(relatedModel, options) {
                            return this.removeRelated(name, relatedModel, options);
                        }
                    });
                }
            }
        });
    }
    /**
     * Builds a new Model instance from an already existing ORM record reference
     *
     * @param record The ORM adapter record object
     */
    static build(record) {
        let model = new this();
        model.record = record;
        return model;
    }
    /**
     * Retrieve a single record by it's id
     *
     * @param id The id of the record you want to lookup
     * @param options Options passed through to the ORM adapter
     * @since 0.1.0
     */
    static async find(id, options) {
        assert(id != null, `You must pass an id to Model.find(id)`);
        debug(`${this.modelName} find: ${id}`);
        let record = await this.adapter.find(this.modelName, id, options);
        if (!record) {
            return null;
        }
        return this.build(record);
    }
    /**
     * Retrieve the first record matching the given query
     *
     * @param query The query to pass through to the ORM adapter
     * @param options An options object passed through to the ORM adapter
     * @since 0.1.0
     */
    static async queryOne(query, options) {
        assert(query != null, `You must pass a query to Model.queryOne(conditions)`);
        debug(`${this.modelName} queryOne: ${util.inspect(query)}`);
        let record = await this.adapter.queryOne(this.modelName, query, options);
        if (!record) {
            return null;
        }
        return this.build(record);
    }
    /**
     * Fetch all records matching the given query
     *
     * @param query The query to pass through to the ORM adapter
     * @param options An options object passed through to the ORM adapter
     * @since 0.1.0
     */
    static async query(query, options) {
        assert(query != null, `You must pass a query to Model.query(conditions)`);
        debug(`${this.modelName} query: ${util.inspect(query)}`);
        let records = await this.adapter.query(this.modelName, query, options);
        return records.map((record) => this.build(record));
    }
    /**
     * Fetch all records of this type
     *
     * @param options An options object passed through to the ORM adapter
     * @since 0.1.0
     */
    static async all(options) {
        debug(`${this.modelName} all`);
        let result = await this.adapter.all(this.modelName, options);
        return result.map((record) => this.build(record));
    }
    /**
     * Create a new Model instance with the supplied data, and immediately
     * persist it
     *
     * @param data Data to populate the new Model instance with
     * @param options An options object passed through to the ORM adapter
     * @since 0.1.0
     */
    static async create(data = {}, options) {
        let model = new this(data, options);
        return model.save();
    }
    /**
     * The ORM adapter specific to this model type. Defaults to the application's
     * ORM adapter if none for this specific model type is found.
     *
     * @since 0.1.0
     */
    static get adapter() {
        return container_1.lookup(`orm-adapter:${this.modelName}`);
    }
    /**
     * The name of this Model type. Used in a variety of use cases, including
     * serialization.
     *
     * @since 0.1.0
     */
    static get modelName() {
        let name = this.name;
        if (name.endsWith('Model')) {
            name = name.substring(0, name.length - 'Model'.length);
        }
        name = lodash_1.kebabCase(name);
        return name;
    }
    /**
     * The name of this Model type. Used in a variety of use cases, including
     * serialization.
     *
     * @since 0.1.0
     */
    get modelName() {
        return this.constructor.modelName;
    }
    /**
     * The id of the record
     *
     * @since 0.1.0
     */
    get id() {
        return this.constructor.adapter.idFor(this);
    }
    set id(value) {
        this.constructor.adapter.setId(this, value);
    }
    /**
     * Persist this model.
     *
     * @since 0.1.0
     */
    async save(options) {
        debug(`saving ${this.toString()}`);
        await this.constructor.adapter.saveRecord(this, options);
        return this;
    }
    /**
     * Delete this model.
     *
     * @since 0.1.0
     */
    async delete(options) {
        debug(`deleting ${this.toString()}`);
        await this.constructor.adapter.deleteRecord(this, options);
    }
    /**
     * Returns the related record(s) for the given relationship.
     *
     * @since 0.1.0
     */
    async getRelated(relationshipName, options) {
        let descriptor = this.constructor.schema[relationshipName];
        assert(descriptor && descriptor.isRelationship, `You tried to fetch related ${relationshipName}, but no such relationship exists on ${this.modelName}`);
        let RelatedModel = container_1.lookup(`model:${descriptor.relatedModelName}`);
        let results = await this.constructor.adapter.getRelated(this, relationshipName, descriptor, options);
        if (descriptor.mode === 'hasOne') {
            assert(!Array.isArray(results), `The ${this.modelName} ORM adapter returned an array for the hasOne '${relationshipName}' relationship - it should return either an ORM record or null.`);
            return results ? RelatedModel.create(results) : null;
        }
        assert(Array.isArray(results), `The ${this.modelName} ORM adapter did not return an array for the hasMany '${relationshipName}' relationship - it should return an array (empty if no related records exist).`);
        return results.map((record) => RelatedModel.build(record));
    }
    /**
     * Replaces the related records for the given relationship with the supplied
     * related records.
     *
     * @since 0.1.0
     */
    async setRelated(relationshipName, relatedModels, options) {
        let descriptor = this.constructor.schema[relationshipName];
        await this.constructor.adapter.setRelated(this, relationshipName, descriptor, relatedModels, options);
    }
    /**
     * Add a related record to a hasMany relationship.
     *
     * @since 0.1.0
     */
    async addRelated(relationshipName, relatedModel, options) {
        let descriptor = this.constructor.schema[inflection_1.pluralize(relationshipName)];
        await this.constructor.adapter.addRelated(this, relationshipName, descriptor, relatedModel, options);
    }
    /**
     * Remove the given record from the hasMany relationship
     *
     * @since 0.1.0
     */
    async removeRelated(relationshipName, relatedModel, options) {
        let descriptor = this.constructor.schema[inflection_1.pluralize(relationshipName)];
        await this.constructor.adapter.removeRelated(this, relationshipName, descriptor, relatedModel, options);
    }
    /**
     * Return an human-friendly string representing this Model instance, with a
     * summary of it's attributes
     *
     * @since 0.1.0
     */
    inspect() {
        let attributesSummary = [];
        lodash_1.forEach(this.constructor.schema, (descriptor, name) => {
            attributesSummary.push(`${name}=${util.inspect(this[name])}`);
        });
        return `<${lodash_1.startCase(this.modelName)}:${this.id == null ? '-new-' : this.id} ${attributesSummary.join(', ')}>`;
    }
    /**
     * Return an human-friendly string representing this Model instance
     *
     * @since 0.1.0
     */
    toString() {
        return `<${lodash_1.startCase(this.modelName)}:${this.id == null ? '-new-' : this.id}>`;
    }
}
/**
 * Marks the Model as an abstract base model, so ORM adapters can know not to
 * create tables or other supporting infrastructure.
 *
 * @since 0.1.0
 */
Model.abstract = false;
/**
 * The schema definition for this model. Keys are the field names, and values
 * should be either `attr(...)', `hasOne(...)`, or `hasMany(...)`
 */
Model.schema = {};
exports.default = Model;

});



// lib/data/orm-adapter.js
//========================================

loader.add('/lib/data/orm-adapter.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const object_1 = require("../metal/object");
/**
 * The ORMAdapter class is responsible for enabling Denali to communicate with
 * the ORM of your choice. It does this by boiling down the possible actions
 * that a user might before against a Model that would involve persistence into
 * a set of basic operations. Your adapter then implements these operations,
 * and Denali can build on top of that.
 *
 * Most of the values passed between your application code and the underlying
 * ORM are opaque to Denali. This means that Denali has no idea what that
 * `query` object looks like or does - it just blindly hands it off to your
 * ORM adapter, which can plug it into the ORM interface appropriately.
 *
 * Most instance-level methods are given a reference to the Denali Model
 * instance that is being acted upon. Most ORM adapters will use that model
 * instance to access `model.record`, which is the slot used to store the
 * instance of the ORM's record. However, the full Model instance is supplied
 * to provide the adapter with maximum flexibility.
 *
 * The ORM adapter interface was designed to be a high enough abstraction that
 * most data stores should support most of the operations. However, it is not
 * required that an adapter support all of the operations - for example, not
 * all data stores support changing a record's ID. In those cases, the adapter
 * method may simply throw.
 *
 * @package data
 * @since 0.1.0
 */
class ORMAdapter extends object_1.default {
}
exports.default = ORMAdapter;

});



// lib/index.js
//========================================

loader.add('/lib/index.js', {"isMain":true}, function(module, exports, require, __dirname, __filename) {

"use strict";
/**
 *
 * This is the main module exported by Denali when it is loaded via
 * `require/import`.
 *
 * This exports convenient shortcuts to other modules within Denali.
 * Rather than having to `import Addon from 'denali/lib/runtime/addon'`,
 * you can just `import { Addon } from 'denali'`.
 *
 */
Object.defineProperty(exports, "__esModule", { value: true });
// Data
const descriptors_1 = require("./data/descriptors");
exports.attr = descriptors_1.attr;
exports.hasMany = descriptors_1.hasMany;
exports.hasOne = descriptors_1.hasOne;
exports.HasOneRelationshipDescriptor = descriptors_1.HasOneRelationshipDescriptor;
exports.HasManyRelationshipDescriptor = descriptors_1.HasManyRelationshipDescriptor;
exports.AttributeDescriptor = descriptors_1.AttributeDescriptor;
const model_1 = require("./data/model");
exports.Model = model_1.default;
const orm_adapter_1 = require("./data/orm-adapter");
exports.ORMAdapter = orm_adapter_1.default;
const memory_1 = require("./data/memory");
exports.MemoryAdapter = memory_1.default;
// Render
const serializer_1 = require("./render/serializer");
exports.Serializer = serializer_1.default;
const json_1 = require("./render/json");
exports.JSONSerializer = json_1.default;
const json_api_1 = require("./render/json-api");
exports.JSONAPISerializer = json_api_1.default;
const view_1 = require("./render/view");
exports.View = view_1.default;
// Parse
const parser_1 = require("./parse/parser");
exports.Parser = parser_1.default;
const json_2 = require("./parse/json");
exports.JSONParser = json_2.default;
const json_api_2 = require("./parse/json-api");
exports.JSONAPIParser = json_api_2.default;
// Metal
const instrumentation_1 = require("./metal/instrumentation");
exports.Instrumentation = instrumentation_1.default;
const mixin_1 = require("./metal/mixin");
exports.mixin = mixin_1.default;
exports.createMixin = mixin_1.createMixin;
const container_1 = require("./metal/container");
exports.container = container_1.default;
exports.lookup = container_1.lookup;
exports.Container = container_1.Container;
const resolver_1 = require("./metal/resolver");
exports.Resolver = resolver_1.default;
const object_1 = require("./metal/object");
exports.DenaliObject = object_1.default;
// Runtime
const action_1 = require("./runtime/action");
exports.Action = action_1.default;
const addon_1 = require("./runtime/addon");
exports.Addon = addon_1.default;
const application_1 = require("./runtime/application");
exports.Application = application_1.default;
const errors_1 = require("./runtime/errors");
exports.Errors = errors_1.default;
const logger_1 = require("./runtime/logger");
exports.Logger = logger_1.default;
const request_1 = require("./runtime/request");
exports.Request = request_1.default;
const router_1 = require("./runtime/router");
exports.Router = router_1.default;
const service_1 = require("./runtime/service");
exports.Service = service_1.default;
const config_1 = require("./runtime/config");
exports.ConfigService = config_1.default;
// Test
const acceptance_test_1 = require("./test/acceptance-test");
exports.setupAcceptanceTest = acceptance_test_1.default;
exports.AcceptanceTest = acceptance_test_1.AcceptanceTest;
const unit_test_1 = require("./test/unit-test");
exports.setupUnitTest = unit_test_1.default;
exports.UnitTest = unit_test_1.UnitTest;
const mock_request_1 = require("./test/mock-request");
exports.MockRequest = mock_request_1.default;
const mock_response_1 = require("./test/mock-response");
exports.MockResponse = mock_response_1.default;

});



// lib/metal/container.js
//========================================

loader.add('/lib/metal/container.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const assert = require("assert");
const lodash_1 = require("lodash");
const resolver_1 = require("./resolver");
const strings_1 = require("../utils/strings");
const crawl = require("tree-crawl");
const DEFAULT_OPTIONS = {
    singleton: true,
    fallbacks: []
};
/**
 * The Container is the dependency injection solution for Denali. It is
 * responsible for managing the lifecycle of objects (i.e. singletons),
 * as well as orchestrating dependency lookup. This provides two key benefits:
 *
 *   * Apps can consume classes that originate from anywhere in the addon
 *     dependency tree, without needing to care/specify where.
 *   * We can more easily test parts of the framework by mocking out container
 *     entries instead of dealing with hardcoding dependencies
 *
 * @package metal
 * @since 0.1.0
 */
class Container {
    constructor() {
        /**
         * Manual registrations that should override resolver retrieved values
         */
        this.registry = {};
        /**
         * An array of resolvers used to retrieve container members. Resolvers are
         * tried in order, first to find the member wins. Normally, each addon will
         * supply it's own resolver, allowing for addon order and precedence when
         * looking up container entries.
         */
        this.resolvers = [];
        /**
         * Internal cache of lookup values
         */
        this.lookups = {};
        /**
         * Default options for container entries. Keyed on specifier or type. See
         * ContainerOptions.
         */
        this.options = {
            app: { singleton: true },
            'app:application': { singleton: false },
            action: { singleton: false },
            config: { singleton: false },
            initializer: { singleton: false },
            'orm-adapter': { singleton: true, fallbacks: ['orm-adapter:application'] },
            model: { singleton: false },
            parser: { singleton: true, fallbacks: ['parser:application'] },
            serializer: { singleton: true, fallbacks: ['serializer:application'] },
            service: { singleton: true },
            view: { singleton: true }
        };
    }
    /**
     * Take a top level bundle loader and load it into this container
     */
    loadBundle(loader) {
        this.loader = loader;
        crawl(loader, this.loadBundleScope.bind(this), {
            order: 'bfs',
            getChildren(loader) {
                return Array.from(loader.children.values());
            }
        });
    }
    /**
     * Load a bundle scope into the container. A bundle scope typically
     * corresponds to an addon. Each bundle scope can provide it's own resolver to
     * tell the consuming app how to look things up within the bundle scope. If
     * no resolver is supplied, Denali will use the default Denali resolver.
     */
    loadBundleScope(loader) {
        let LoaderResolver;
        try {
            LoaderResolver = loader.load('resolver');
        }
        catch (e) {
            LoaderResolver = resolver_1.default;
        }
        let resolver = new LoaderResolver(loader);
        this.resolvers.push(resolver);
        loader.resolver = resolver;
    }
    /**
     * Add a manual registration that will take precedence over any resolved
     * lookups.
     *
     * @since 0.1.0
     */
    register(specifier, entry, options) {
        this.registry[specifier] = entry;
        if (options) {
            lodash_1.forOwn(options, (value, key) => {
                this.setOption(specifier, key, value);
            });
        }
    }
    lookup(specifier, options = {}) {
        // Raw lookups skip caching and singleton behavior
        if (options.raw) {
            let entry = this.lookupRaw(specifier);
            if (entry === false && !options.loose) {
                throw new ContainerEntryNotFound(specifier, this.registry, this.resolvers);
            }
            return entry;
        }
        // I can haz cache hit plz?
        if (this.lookups[specifier]) {
            return this.lookups[specifier];
        }
        // Not in cache - first lookup. Get the underlying value first
        let entry = this.lookupRaw(specifier);
        // If that works - handle singletons, cache, and call it good
        if (entry !== false) {
            entry = this.instantiateSingletons(specifier, entry);
            this.lookups[specifier] = entry;
            return entry;
        }
        // Not in cache and no underlying entry found. Can we fallback?
        let fallbacks = this.getOption(specifier, 'fallbacks').slice(0);
        let fallback;
        while ((fallback = fallbacks.shift()) && (fallback !== specifier)) {
            entry = this.lookup(fallback, options);
            if (entry) {
                break;
            }
        }
        if (entry !== false) {
            // No singleton instantiation here - the recursion into lookup should
            // handle that
            this.lookups[specifier] = entry;
            return entry;
        }
        if (options.loose) {
            return false;
        }
        throw new ContainerEntryNotFound(specifier, this.registry, this.resolvers);
    }
    instantiateSingletons(specifier, entry) {
        // Instantiate if it's a singleton
        let singleton = this.getOption(specifier, 'singleton');
        if (singleton) {
            let Class = entry;
            assert(typeof Class === 'function', strings_1.default.ContainerEntryNotAConstructor(specifier, Class));
            return new Class();
        }
        return entry;
    }
    /**
     * Recursive lookup method that takes a specifier and fallback specifiers.
     * Checks manual registrations first, then iterates through each resolver. If
     * the entry is still not found, it recurses through the fallback options
     * before ultimatley throwing (or returning false if loose: true)
     */
    lookupRaw(specifier) {
        // Manual registrations take precedence
        let entry = this.registry[specifier];
        // Try each resolver in order
        if (!entry) {
            lodash_1.forEach(this.resolvers, (resolver) => {
                entry = resolver.retrieve(specifier);
                if (entry) {
                    return false;
                }
            });
        }
        return entry == null ? false : entry;
    }
    /**
     * Lookup all the entries for a given type in the container. This will ask
     * all resolvers to eagerly load all classes for this type. Returns an object
     * whose keys are container specifiers and values are the looked up values
     * for those specifiers.
     *
     * @since 0.1.0
     */
    lookupAll(type) {
        let entries = this.availableForType(type);
        let values = entries.map((entry) => this.lookup(`${type}:${entry}`));
        return lodash_1.zipObject(entries, values);
    }
    /**
     * Returns an array of entry names for all entries under this type.
     *
     * @since 0.1.0
     */
    availableForType(type) {
        let registrations = Object.keys(this.registry).filter((specifier) => {
            return specifier.startsWith(type);
        });
        let resolved = this.resolvers.reverse().reduce((entries, resolver) => {
            return entries.concat(resolver.availableForType(type));
        }, []);
        return lodash_1.uniq(registrations.concat(resolved)).map((specifier) => specifier.split(':')[1]);
    }
    /**
     * Return the value for the given option on the given specifier. Specifier
     * may be a full specifier or just a type.
     *
     * @since 0.1.0
     */
    getOption(specifier, optionName) {
        let [type] = specifier.split(':');
        let options = lodash_1.defaults(this.options[specifier], this.options[type], DEFAULT_OPTIONS);
        return options[optionName];
    }
    /**
     * Set the option for the given specifier or type.
     *
     * @since 0.1.0
     */
    setOption(specifier, optionName, value) {
        if (!this.options[specifier]) {
            this.options[specifier] = Object.assign({}, DEFAULT_OPTIONS);
        }
        this.options[specifier][optionName] = value;
    }
    /**
     * Clear any cached lookups for this specifier. You probably don't want to
     * use this. The only significant use case is for testing to allow test
     * containers to override an already looked up value.
     */
    clearCache(specifier) {
        delete this.lookups[specifier];
    }
    /**
     * Empties the entire container, including removing all resolvers and the
     * loader, as well as emptying all caches. The primary use case is for
     * unit testing, when you want a clean slate environment to selectively
     * add things back to.
     */
    clear() {
        this.lookups = {};
        this.registry = {};
        this.resolvers = [];
        this.loader = null;
    }
    /**
     * Given container-managed singletons a chance to cleanup on application
     * shutdown
     *
     * @since 0.1.0
     */
    teardown() {
        lodash_1.forEach(this.lookups, (instance) => {
            if (typeof instance.teardown === 'function') {
                instance.teardown();
            }
        });
    }
}
exports.Container = Container;
class ContainerEntryNotFound extends Error {
    constructor(specifier, registry, resolvers) {
        let message = strings_1.default.ContainerEntryNotFound(specifier, Object.keys(registry), resolvers.map((r) => r.name));
        super(message);
    }
}
// The exports here are unusual - rather than exporting the Container class, we
// actually instantiate the container and export that. This is because all
// Denali code is loaded via a bundle, and there is only one container instance
// per bundle. Instantiating it here allows us to treat the container as
// effectively a global variable, which allows for *much* more convenient use
// (otherwise, the container would need to control instantiation of every object
// to ensure each object could get a reference to the container instance).
const container = new Container();
exports.default = container;
exports.lookup = container.lookup.bind(container);

});



// lib/metal/instrumentation.js
//========================================

loader.add('/lib/metal/instrumentation.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const EventEmitter = require("events");
const lodash_1 = require("lodash");
/**
 * The Instrumentation class is a low level class for instrumenting your app's
 * code. It allows you to listen to framework level profiling events, as well
 * as creating and firing your own such events.
 *
 * For example, if you wanted to instrument how long a particular action was
 * taking:
 *
 *     import { Instrumentation, Action } from 'denali';
 *     export default class MyAction extends Action {
 *       respond() {
 *         let Post = this.modelFor('post');
 *         return Instrumentation.instrument('post lookup', { currentUser: this.user.id }, () => {
 *           Post.find({ user: this.user });
 *         });
 *       }
 *     }
 *
 * @package metal
 */
class InstrumentationEvent {
    constructor(eventName, data) {
        this.eventName = eventName;
        this.data = data;
        this.startTime = process.hrtime();
    }
    /**
     * Subscribe to be notified when a particular instrumentation block completes.
     */
    static subscribe(eventName, callback) {
        this._emitter.on(eventName, callback);
    }
    /**
     * Unsubscribe from being notified when a particular instrumentation block completes.
     */
    static unsubscribe(eventName, callback) {
        this._emitter.removeListener(eventName, callback);
    }
    /**
     * Run the supplied function, timing how long it takes to complete. If the function returns a
     * promise, the timer waits until that promise resolves. Returns a promise that resolves with the
     * return value of the supplied function. Fires an event with the given event name and event data
     * (the function result is provided as well).
     */
    static instrument(eventName, data) {
        return new InstrumentationEvent(eventName, data);
    }
    /**
     * Emit an InstrumentationEvent to subscribers
     */
    static emit(eventName, event) {
        this._emitter.emit(eventName, event);
    }
    /**
     * Finish this event. Records the duration, and fires an event to any subscribers. Any data
     * provided here is merged with any previously provided data.
     */
    finish(data) {
        this.duration = process.hrtime(this.startTime)[1];
        this.data = lodash_1.merge({}, this.data, data);
        InstrumentationEvent.emit(this.eventName, this);
    }
}
/**
 * The internal event emitter used for notifications
 */
InstrumentationEvent._emitter = new EventEmitter();
exports.default = InstrumentationEvent;

});



// lib/metal/mixin.js
//========================================

loader.add('/lib/metal/mixin.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const assert = require("assert");
/**
 * ES6 classes don't provide any native syntax or support for compositional
 * mixins. This helper method provides that support:
 *
 *     import { mixin } from 'denali';
 *     import MyMixin from '../mixins/my-mixin';
 *     import ApplicationAction from './application';
 *
 *     export default class MyAction extends mixin(ApplicationAction, MyMixin) {
 *       // ...
 *     }
 *
 * Objects that extend from Denali's Object class automatically get a static
 * `mixin` method to make the syntax a bit more familiar:
 *
 *     export default class MyAction extends ApplicationAction.mixin(MyMixin) {
 *
 * ## How it works
 *
 * Since ES6 classes are based on prototype chains, and protoype chains are
 * purely linear (you can't have two prototypes of a single object), we
 * implement mixins by creating anonymous intermediate subclasses for each
 * applied mixin.
 *
 * Mixins are defined as factory functions that take a base class and extend it
 * with their own mixin properties/methods. When these mixin factory functions
 * are applied, they are called in order, with the result of the last mixin
 * feeding into the base class of the next mixin factory.
 *
 * ## Use sparingly!
 *
 * Mixins can be useful in certain circumstances, but use them sparingly. They
 * add indirection that can be surprising or confusing to later developers who
 * encounter the code. Wherever possible, try to find alternatives that make
 * the various dependencies of your code clear.
 *
 * @package metal
 * @since 0.1.0
 */
function mixin(baseClass, ...mixins) {
    return mixins.reduce((currentBase, mixinFactory) => {
        let appliedClass = mixinFactory._factory(currentBase, ...mixinFactory._args);
        assert(typeof appliedClass === 'function', `Invalid mixin (${appliedClass}) - did you forget to return your mixin class from the createMixin method?`);
        return appliedClass;
    }, baseClass);
}
exports.default = mixin;
/**
 * Creates a mixin factory function wrapper. These wrapper functions have the
 * special property that they can be invoked an arbitrary number of times, and
 * each time will cache the arguments to be handed off to the actual factory
 * function.
 *
 * This is useful to allow per-use options for your mixin. For example:
 *
 *     class ProtectedAction extends Action.mixin(authenticate({ ... })) {
 *
 * In that example, the optons object provided to the `authenticate` mixin
 * function will be cached, and once the mixin factory function is invoked, it
 * will be provided as an additional argument:
 *
 *     createMixin((BaseClass, options) => {
 *
 * @package metal
 * @since 0.1.0
 */
function createMixin(mixinFactory) {
    let cacheMixinArguments = function (...args) {
        cacheMixinArguments._args.push(...args);
        return cacheMixinArguments;
    };
    cacheMixinArguments._args = [];
    cacheMixinArguments._factory = mixinFactory;
    return cacheMixinArguments;
}
exports.createMixin = createMixin;

});



// lib/metal/object.js
//========================================

loader.add('/lib/metal/object.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const mixin_1 = require("./mixin");
/**
 * The base object class for Denali classes. Adds mixin support and a stubbed
 * `teardown` method.
 *
 * @package metal
 * @since 0.1.0
 */
class DenaliObject {
    /**
     * Apply mixins using this class as the base class. Pure syntactic sugar for
     * the `mixin` helper.
     */
    static mixin(...mixins) {
        return mixin_1.default(this, ...mixins);
    }
    /**
     * A hook invoked when an application is torn down. Only invoked on
     * singletons stored in the container.
     */
    teardown() {
        // Default is no-op
    }
}
exports.default = DenaliObject;

});



// lib/metal/resolver.js
//========================================

loader.add('/lib/metal/resolver.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const lodash_1 = require("lodash");
const path = require("path");
const inflection_1 = require("inflection");
const assert = require("assert");
const createDebug = require("debug");
class Resolver {
    constructor(loader) {
        /**
         * The internal cache of available references
         */
        this.registry = new Map();
        assert(loader, 'You must supply a loader that the resolver should use to load from');
        this.name = loader.pkgName;
        this.debug = createDebug(`denali:resolver:${this.name}`);
        this.loader = loader;
    }
    /**
     * Manually add a member to this resolver. Manually registered members take
     * precedence over any retrieved from the filesystem. This same pattern
     * exists at the container level, but having it here allows an addon to
     * specify a manual override _for it's own scope_, but not necessarily force
     * it onto the consuming application
     *
     * @since 0.1.0
     */
    register(specifier, value) {
        assert(specifier.includes(':'), 'Container specifiers must be in "type:entry" format');
        this.registry.set(specifier, value);
    }
    /**
     * Fetch the member matching the given parsedName. First checks for any
     * manually registered members, then falls back to type specific retrieve
     * methods that typically find the matching file on the filesystem.
     *
     * @since 0.1.0
     */
    retrieve(specifier) {
        assert(specifier.includes(':'), 'Container specifiers must be in "type:entry" format');
        this.debug(`retrieving ${specifier}`);
        let [type, entry] = specifier.split(':');
        if (this.registry.has(specifier)) {
            this.debug(`cache hit, returning cached value`);
            return this.registry.get(specifier);
        }
        let retrieveMethod = this[`retrieve${lodash_1.upperFirst(lodash_1.camelCase(type))}`];
        if (!retrieveMethod) {
            retrieveMethod = this.retrieveOther;
        }
        this.debug(`retrieving via retrieve${lodash_1.upperFirst(lodash_1.camelCase(type))}`);
        let result = retrieveMethod.call(this, type, entry);
        result = result && result.default || result;
        this.debug('retrieved %o', result);
        return result;
    }
    _retrieve(type, entry, relativepath) {
        this.debug(`attempting to retrieve ${type}:${entry} at ${relativepath} from ${this.name}`);
        return this.loader.loadRelative('/', relativepath, lodash_1.constant(false));
    }
    /**
     * Unknown types are assumed to exist underneath the `app/` folder
     */
    retrieveOther(type, entry) {
        return this._retrieve(type, entry, path.join('/app', inflection_1.pluralize(type), entry));
    }
    /**
     * App files are found in `app/*`
     */
    retrieveApp(type, entry) {
        return this._retrieve(type, entry, path.join('/app', entry));
    }
    /**
     * Config files are found in `config/`
     */
    retrieveConfig(type, entry) {
        return this._retrieve(type, entry, path.join('/config', entry));
    }
    /**
     * Initializer files are found in `config/initializers/`
     */
    retrieveInitializer(type, entry) {
        return this._retrieve(type, entry, path.join('/config', 'initializers', entry));
    }
    /**
     * Returns an array of entry names that are available from this resolver for
     * the given type.
     *
     * @since 0.1.0
     */
    availableForType(type) {
        let registeredForType = [];
        this.registry.forEach((entry, specifier) => {
            if (specifier.split(':')[0] === type) {
                registeredForType.push(specifier);
            }
        });
        let availableMethod = this[`availableFor${lodash_1.upperFirst(lodash_1.camelCase(type))}`];
        if (!availableMethod) {
            availableMethod = this.availableForOther;
        }
        let entries = availableMethod.call(this, type);
        let resolvedEntries = entries.map((entry) => `${type}:${entry}`);
        return lodash_1.uniq(registeredForType.sort().concat(resolvedEntries.sort()));
    }
    _availableForType(prefix) {
        let matchingFactories = Array.from(this.loader.factories.keys()).filter((moduleName) => {
            return moduleName.startsWith(prefix);
        });
        return matchingFactories.map((factoryPath) => factoryPath.substring(prefix.length + 1));
    }
    /**
     * Unknown types are assumed to exist in the `app/` folder
     */
    availableForOther(type) {
        return this._availableForType(path.join('/app', inflection_1.pluralize(type)));
    }
    /**
     * App files are found in `app/*`
     */
    availableForApp(type, entry) {
        return this._availableForType('/app');
    }
    /**
     * Config files are found in the `config/` folder. Initializers are _not_ included in this group
     */
    availableForConfig(type) {
        return this._availableForType('/config');
    }
    /**
     * Initializers files are found in the `config/initializers/` folder
     */
    availableForInitializer(type) {
        return this._availableForType(path.join('/config', 'initializers'));
    }
}
exports.default = Resolver;

});



// lib/parse/json-api.js
//========================================

loader.add('/lib/parse/json-api.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const lodash_1 = require("lodash");
const assert = require("assert");
const json_1 = require("./json");
const errors_1 = require("../runtime/errors");
const set_if_not_empty_1 = require("../utils/set-if-not-empty");
const inflection_1 = require("inflection");
/**
 * Parses incoming request bodies according to the JSON-API specification. For
 * incoming payloads with `included` arrays, the primary `data` is returned
 * under the `body` key, and `included` is moved to it's own property.
 *
 * @package parse
 * @since 0.1.0
 */
class JSONAPIParser extends json_1.default {
    constructor() {
        super(...arguments);
        /**
         * The media type for JSON-API requests. If the incoming request doesn't have
         * this Content Type, the parser will immediately render a 400 Bad Request response
         */
        this.type = 'application/vnd.api+json';
    }
    async parse(request) {
        let body = await this.bufferAndParseBody(request);
        let result = {
            query: request.query,
            headers: request.headers,
            params: request.params
        };
        if (!request.hasBody) {
            return result;
        }
        try {
            assert(request.getHeader('content-type') === 'application/vnd.api+json', 'Invalid content type - must have `application/vnd.api+json` as the request content type');
            assert(body.data, 'Invalid JSON-API document (missing top level `data` object - see http://jsonapi.org/format/#document-top-level)');
            let parseResource = this.parseResource.bind(this);
            if (body.data) {
                if (!lodash_1.isArray(body.data)) {
                    result.body = parseResource(body.data);
                }
                else {
                    result.body = body.data.map(parseResource);
                }
            }
            if (body.included) {
                result.included = body.included.map(parseResource);
            }
            return result;
        }
        catch (e) {
            if (e.name === 'AssertionError') {
                throw new errors_1.default.BadRequest(e.message);
            }
            throw e;
        }
    }
    /**
     * Parse a single resource object from a JSONAPI document. The resource
     * object could come from the top level `data` payload, or from the
     * sideloaded `included` records.
     *
     * @since 0.1.0
     */
    parseResource(resource) {
        let parsedResource = {};
        set_if_not_empty_1.default(parsedResource, 'id', this.parseId(resource.id));
        Object.assign(parsedResource, this.parseAttributes(resource.attributes));
        Object.assign(parsedResource, this.parseRelationships(resource.relationships));
        return parsedResource;
    }
    /**
     * Parse a resource object id
     *
     * @since 0.1.0
     */
    parseId(id) {
        return id;
    }
    /**
     * Parse a resource object's type string
     *
     * @since 0.1.0
     */
    parseType(type) {
        return inflection_1.singularize(type);
    }
    /**
     * Parse a resource object's attributes. By default, this converts from the
     * JSONAPI recommended dasheried keys to camelCase.
     *
     * @since 0.1.0
     */
    parseAttributes(attrs) {
        return lodash_1.mapKeys(attrs, (value, key) => {
            return lodash_1.camelCase(key);
        });
    }
    /**
     * Parse a resource object's relationships. By default, this converts from
     * the JSONAPI recommended dasheried keys to camelCase.
     *
     * @since 0.1.0
     */
    parseRelationships(relationships) {
        return lodash_1.mapKeys(relationships, (value, key) => {
            return lodash_1.camelCase(key);
        });
    }
}
exports.default = JSONAPIParser;

});



// lib/parse/json.js
//========================================

loader.add('/lib/parse/json.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const parser_1 = require("./parser");
const body_parser_1 = require("body-parser");
const bluebird_1 = require("bluebird");
/**
 * Parses incoming request bodies as JSON payloads.
 *
 * @package parse
 * @since 0.1.0
 */
class JSONParser extends parser_1.default {
    constructor() {
        super(...arguments);
        /**
         * When set to true, then deflated (compressed) bodies will be inflated; when
         * false, deflated bodies are rejected. Defaults to true.
         *
         * @since 0.1.0
         */
        this.inflate = true;
        /**
         * Controls the maximum request body size. If this is a number, then the
         * value specifies the number of bytes; if it is a string, the value is
         * passed to the bytes library for parsing. Defaults to '100kb'.
         *
         * @since 0.1.0
         */
        this.limit = '100kb';
        /**
         * When set to true, will only accept arrays and objects; when false will
         * accept anything JSON.parse accepts. Defaults to true.
         *
         * @since 0.1.0
         */
        this.strict = true;
        /**
         * The type option is used to determine what media type the middleware will
         * parse. This option can be a function or a string. If a string, type option
         * is passed directly to the type-is library and this can be an extension
         * name (like json), a mime type (like application/json), or a mime type with
         * a wildcard. If a function, the type option is called as fn(req) and the
         * request is parsed if it returns a truthy value. Defaults to
         * application/json.
         *
         * @since 0.1.0
         */
        this.type = 'application/json';
    }
    async bufferAndParseBody(request) {
        await bluebird_1.fromNode((cb) => {
            if (!this.jsonParserMiddleware) {
                this.jsonParserMiddleware = body_parser_1.json({
                    inflate: this.inflate,
                    limit: this.limit,
                    reviver: this.reviver,
                    strict: this.strict,
                    type: this.type,
                    verify: this.verify
                });
            }
            this.jsonParserMiddleware(request.incomingMessage, {}, cb);
        });
        return request.incomingMessage.body;
    }
    async parse(request) {
        let body = await this.bufferAndParseBody(request);
        return {
            body,
            query: request.query,
            headers: request.headers,
            params: request.params
        };
    }
}
exports.default = JSONParser;

});



// lib/parse/parser.js
//========================================

loader.add('/lib/parse/parser.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const object_1 = require("../metal/object");
/**
 * Denali's Parsers are responsible for taking the incoming request body of an
 * HTTP request and transforming it into a consistent object structure that can
 * be used by Actions.
 *
 * For example, if your app uses JSON-API, you can use the JSON-API parser to
 * transform the incoming JSON-API request body structure into something easier
 * to work with in your Action layer.
 *
 * Other examples of common tasks include parsing and type casting query
 * params, and transforming keys (i.e. kebab-case to camelCase).
 *
 * @package parse
 * @since 0.1.0
 */
class Parser extends object_1.default {
}
exports.default = Parser;

});



// lib/render/json-api.js
//========================================

loader.add('/lib/render/json-api.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const lodash_1 = require("lodash");
const assert = require("assert");
const path = require("path");
const inflection_1 = require("inflection");
const serializer_1 = require("./serializer");
const container_1 = require("../metal/container");
const bluebird_1 = require("bluebird");
const set_if_not_empty_1 = require("../utils/set-if-not-empty");
/**
 * Renders the payload according to the JSONAPI 1.0 spec, including related
 * resources, included records, and support for meta and links.
 *
 * @package data
 * @since 0.1.0
 */
class JSONAPISerializer extends serializer_1.default {
    constructor() {
        super(...arguments);
        /**
         * The default content type to use for any responses rendered by this serializer.
         *
         * @since 0.1.0
         */
        this.contentType = 'application/vnd.api+json';
    }
    /**
     * Take a response body (a model, an array of models, or an Error) and render
     * it as a JSONAPI compliant document
     *
     * @since 0.1.0
     */
    async serialize(body, action, options) {
        let context = {
            action,
            body,
            options,
            document: {}
        };
        await this.renderPrimary(context);
        await this.renderIncluded(context);
        this.renderMeta(context);
        this.renderLinks(context);
        this.renderVersion(context);
        this.dedupeIncluded(context);
        return context.document;
    }
    /**
     * Render the primary payload for a JSONAPI document (either a model or array
     * of models).
     *
     * @since 0.1.0
     */
    async renderPrimary(context) {
        let payload = context.body;
        if (lodash_1.isArray(payload)) {
            await this.renderPrimaryArray(context, payload);
        }
        else {
            await this.renderPrimaryObject(context, payload);
        }
    }
    /**
     * Render the primary data for the document, either a single Model or a
     * single Error.
     *
     * @since 0.1.0
     */
    async renderPrimaryObject(context, payload) {
        if (payload instanceof Error) {
            context.document.errors = [await this.renderError(context, payload)];
        }
        else {
            context.document.data = await this.renderRecord(context, payload);
        }
    }
    /**
     * Render the primary data for the document, either an array of Models or
     * Errors
     *
     * @since 0.1.0
     */
    async renderPrimaryArray(context, payload) {
        if (payload[0] instanceof Error) {
            context.document.errors = await bluebird_1.map(payload, async (error) => {
                assert(error instanceof Error, 'You passed a mixed array of errors and models to the JSON-API serializer. The JSON-API spec does not allow for both `data` and `errors` top level objects in a response');
                return await this.renderError(context, error);
            });
        }
        else {
            context.document.data = await bluebird_1.map(payload, async (record) => {
                assert(!(record instanceof Error), 'You passed a mixed array of errors and models to the JSON-API serializer. The JSON-API spec does not allow for both `data` and `errors` top level objects in a response');
                return await this.renderRecord(context, record);
            });
        }
    }
    /**
     * Render any included records supplied by the options into the top level of
     * the document
     *
     * @since 0.1.0
     */
    async renderIncluded(context) {
        if (context.options.included) {
            assert(lodash_1.isArray(context.options.included), 'included records must be passed in as an array');
            context.document.included = await bluebird_1.map(context.options.included, async (includedRecord) => {
                return await this.renderRecord(context, includedRecord);
            });
        }
    }
    /**
     * Render top level meta object for a document. Default uses meta supplied in
     * options call to res.render().
     *
     * @since 0.1.0
     */
    renderMeta(context) {
        if (context.options.meta) {
            context.document.meta = context.options.meta;
        }
    }
    /**
     * Render top level links object for a document. Defaults to the links
     * supplied in options.
     *
     * @since 0.1.0
     */
    renderLinks(context) {
        if (context.options.links) {
            context.document.links = context.options.links;
        }
    }
    /**
     * Render the version of JSONAPI supported.
     *
     * @since 0.1.0
     */
    renderVersion(context) {
        context.document.jsonapi = {
            version: '1.0'
        };
    }
    /**
     * Render the supplied record as a resource object.
     *
     * @since 0.1.0
     */
    async renderRecord(context, record) {
        assert(record, `Cannot serialize ${record}. You supplied ${record} instead of a Model instance.`);
        let serializedRecord = {
            type: inflection_1.pluralize(record.modelName),
            id: record.id
        };
        assert(serializedRecord.id != null, `Attempted to serialize a record (${record}) without an id, but the JSON-API spec requires all resources to have an id.`);
        set_if_not_empty_1.default(serializedRecord, 'attributes', this.attributesForRecord(context, record));
        set_if_not_empty_1.default(serializedRecord, 'relationships', await this.relationshipsForRecord(context, record));
        set_if_not_empty_1.default(serializedRecord, 'links', this.linksForRecord(context, record));
        set_if_not_empty_1.default(serializedRecord, 'meta', this.metaForRecord(context, record));
        return serializedRecord;
    }
    /**
     * Returns the JSONAPI attributes object representing this record's
     * relationships
     *
     * @since 0.1.0
     */
    attributesForRecord(context, record) {
        let serializedAttributes = {};
        let attributes = this.attributesToSerialize(context.action, context.options);
        attributes.forEach((attributeName) => {
            let key = this.serializeAttributeName(context, attributeName);
            let rawValue = record[attributeName];
            if (!lodash_1.isUndefined(rawValue)) {
                let value = this.serializeAttributeValue(context, rawValue, key, record);
                serializedAttributes[key] = value;
            }
        });
        return serializedAttributes;
    }
    /**
     * The JSONAPI spec recommends (but does not require) that property names be
     * dasherized. The default implementation of this serializer therefore does
     * that, but you can override this method to use a different approach.
     *
     * @since 0.1.0
     */
    serializeAttributeName(context, name) {
        return lodash_1.kebabCase(name);
    }
    /**
     * Take an attribute value and return the serialized value. Useful for
     * changing how certain types of values are serialized, i.e. Date objects.
     *
     * The default implementation returns the attribute's value unchanged.
     *
     * @since 0.1.0
     */
    serializeAttributeValue(context, value, key, record) {
        return value;
    }
    /**
     * Returns the JSONAPI relationships object representing this record's
     * relationships
     *
     * @since 0.1.0
     */
    async relationshipsForRecord(context, record) {
        let serializedRelationships = {};
        let relationships = this.relationshipsToSerialize(context.action, context.options);
        // The result of this.relationships is a whitelist of which relationships should be serialized,
        // and the configuration for their serialization
        let relationshipNames = Object.keys(relationships);
        for (let name of relationshipNames) {
            let config = relationships[name];
            let key = config.key || this.serializeRelationshipName(context, name);
            let descriptor = record.constructor.schema[name];
            assert(descriptor, `You specified a '${name}' relationship in your ${record.modelName} serializer, but no such relationship is defined on the ${record.modelName} model`);
            serializedRelationships[key] = await this.serializeRelationship(context, name, config, descriptor, record);
        }
        return serializedRelationships;
    }
    /**
     * Convert the relationship name to it's "over-the-wire" format. Defaults to
     * dasherizing it.
     *
     * @since 0.1.0
     */
    serializeRelationshipName(context, name) {
        return lodash_1.kebabCase(name);
    }
    /**
     * Takes the serializer config and the model's descriptor for a relationship,
     * and returns the serialized relationship object. Also sideloads any full
     * records if the relationship is so configured.
     *
     * @since 0.1.0
     */
    async serializeRelationship(context, name, config, descriptor, record) {
        let relationship = {};
        set_if_not_empty_1.default(relationship, 'links', this.linksForRelationship(context, name, config, descriptor, record));
        set_if_not_empty_1.default(relationship, 'meta', this.metaForRelationship(context, name, config, descriptor, record));
        set_if_not_empty_1.default(relationship, 'data', await this.dataForRelationship(context, name, config, descriptor, record));
        return relationship;
    }
    /**
     * Returns the serialized form of the related Models for the given record and
     * relationship.
     *
     * @since 0.1.0
     */
    async dataForRelationship(context, name, config, descriptor, record) {
        let relatedData = await record.getRelated(name);
        if (descriptor.mode === 'hasMany') {
            return await bluebird_1.map(relatedData, async (relatedRecord) => {
                return await this.dataForRelatedRecord(context, name, relatedRecord, config, descriptor, record);
            });
        }
        return await this.dataForRelatedRecord(context, name, relatedData, config, descriptor, record);
    }
    /**
     * Given a related record, return the resource object for that record, and
     * sideload the record as well.
     *
     * @since 0.1.0
     */
    async dataForRelatedRecord(context, name, relatedRecord, config, descriptor, record) {
        await this.includeRecord(context, name, relatedRecord, config, descriptor);
        return {
            type: inflection_1.pluralize(relatedRecord.modelName),
            id: relatedRecord.id
        };
    }
    /**
     * Takes a relationship descriptor and the record it's for, and returns any
     * links for that relationship for that record. I.e. '/books/1/author'
     *
     * @since 0.1.0
     */
    linksForRelationship(context, name, config, descriptor, record) {
        let recordLinks = this.linksForRecord(context, record);
        let recordURL;
        if (recordLinks) {
            if (typeof recordLinks.self === 'string') {
                recordURL = recordLinks.self;
            }
            else {
                recordURL = recordLinks.self.href;
            }
            return {
                self: path.join(recordURL, `relationships/${name}`),
                related: path.join(recordURL, name)
            };
        }
        return null;
    }
    /**
     * Returns any meta for a given relationship and record. No meta included by
     * default.
     *
     * @since 0.1.0
     */
    metaForRelationship(context, name, config, descriptor, record) {
        // defaults to no meta content
    }
    /**
     * Returns links for a particular record, i.e. self: "/books/1". Default
     * implementation assumes the URL for a particular record maps to that type's
     * `show` action, i.e. `books/show`.
     *
     * @since 0.1.0
     */
    linksForRecord(context, record) {
        let router = container_1.lookup('app:router');
        let url = router.urlFor(`${inflection_1.pluralize(record.modelName)}/show`, record);
        return typeof url === 'string' ? { self: url } : null;
    }
    /**
     * Returns meta for a particular record.
     *
     * @since 0.1.0
     */
    metaForRecord(context, record) {
        // defaults to no meta
    }
    /**
     * Sideloads a record into the top level "included" array
     *
     * @since 0.1.0
     */
    async includeRecord(context, name, relatedRecord, config, descriptor) {
        assert(relatedRecord, 'You tried to sideload an included record, but the record itself was not provided.');
        if (!lodash_1.isArray(context.document.included)) {
            context.document.included = [];
        }
        let relatedOptions = (context.options.relationships && context.options.relationships[name]) || context.options;
        let relatedSerializer = container_1.lookup(`serializer:${config.serializer || relatedRecord.modelName}`);
        let relatedContext = lodash_1.assign({}, context, { options: relatedOptions });
        context.document.included.push(await relatedSerializer.renderRecord(relatedContext, relatedRecord));
    }
    /**
     * Render the supplied error
     *
     * @since 0.1.0
     */
    renderError(context, error) {
        let renderedError = {
            status: String(error.status) || '500',
            code: error.code || error.name || 'InternalServerError',
            detail: error.message
        };
        set_if_not_empty_1.default(renderedError, 'id', this.idForError(context, error));
        set_if_not_empty_1.default(renderedError, 'title', this.titleForError(context, error));
        set_if_not_empty_1.default(renderedError, 'source', this.sourceForError(context, error));
        set_if_not_empty_1.default(renderedError, 'meta', this.metaForError(context, error));
        set_if_not_empty_1.default(renderedError, 'links', this.linksForError(context, error));
        return renderedError;
    }
    /**
     * Given an error, return a unique id for this particular occurence of the
     * problem.
     *
     * @since 0.1.0
     */
    idForError(context, error) {
        return error.id;
    }
    /**
     * A short, human-readable summary of the problem that SHOULD NOT change from
     * occurrence to occurrence of the problem, except for purposes of
     * localization.
     *
     * @since 0.1.0
     */
    titleForError(context, error) {
        return error.title;
    }
    /**
     * Given an error, return a JSON Pointer, a URL query param name, or other
     * info indicating the source of the error.
     *
     * @since 0.1.0
     */
    sourceForError(context, error) {
        return error.source;
    }
    /**
     * Return the meta for a given error object. You could use this for example,
     * to return debug information in development environments.
     *
     * @since 0.1.0
     */
    metaForError(context, error) {
        return error.meta;
    }
    /**
     * Return a links object for an error. You could use this to link to a bug
     * tracker report of the error, for example.
     *
     * @since 0.1.0
     */
    linksForError(context, error) {
        // defaults to no links
    }
    /**
     * Remove duplicate entries from the sideloaded data.
     *
     * @since 0.1.0
     */
    dedupeIncluded(context) {
        if (lodash_1.isArray(context.document.included)) {
            context.document.included = lodash_1.uniqBy(context.document.included, (resource) => {
                return `${resource.type}/${resource.id}`;
            });
        }
    }
}
exports.default = JSONAPISerializer;

});



// lib/render/json.js
//========================================

loader.add('/lib/render/json.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const lodash_1 = require("lodash");
const assert = require("assert");
const bluebird_1 = require("bluebird");
const serializer_1 = require("./serializer");
const model_1 = require("../data/model");
const container_1 = require("../metal/container");
/**
 * Renders the payload as a flat JSON object or array at the top level. Related
 * models are embedded.
 *
 * @package data
 * @since 0.1.0
 */
class JSONSerializer extends serializer_1.default {
    constructor() {
        super(...arguments);
        /**
         * The default content type to apply to responses formatted by this
         * serializer
         *
         * @since 0.1.0
         */
        this.contentType = 'application/json';
    }
    /**
     * Renders the payload, either a primary data model(s) or an error payload.
     *
     * @since 0.1.0
     */
    async serialize(body, action, options = {}) {
        if (body instanceof Error) {
            return this.renderError(body, action, options);
        }
        return this.renderPrimary(body, action, options);
    }
    /**
     * Renders a primary data payload (a model or array of models).
     *
     * @since 0.1.0
     */
    async renderPrimary(payload, action, options) {
        if (lodash_1.isArray(payload)) {
            return await bluebird_1.all(payload.map(async (item) => {
                return await this.renderItem(item, action, options);
            }));
        }
        return await this.renderItem(payload, action, options);
    }
    /**
     * If the primary data isn't a model, just render whatever it is directly
     *
     * @since 0.1.0
     */
    async renderItem(item, action, options) {
        if (item instanceof model_1.default) {
            return await this.renderModel(item, action, options);
        }
        return item;
    }
    /**
     * Renders an individual model
     *
     * @since 0.1.0
     */
    async renderModel(model, action, options) {
        let id = model.id;
        let attributes = this.serializeAttributes(model, action, options);
        let relationships = await this.serializeRelationships(model, action, options);
        return lodash_1.assign({ id }, attributes, relationships);
    }
    /**
     * Serialize the attributes for a given model
     *
     * @since 0.1.0
     */
    serializeAttributes(model, action, options) {
        let serializedAttributes = {};
        let attributes = this.attributesToSerialize(action, options);
        attributes.forEach((attributeName) => {
            let key = this.serializeAttributeName(attributeName);
            let rawValue = model[attributeName];
            if (!lodash_1.isUndefined(rawValue)) {
                let value = this.serializeAttributeValue(rawValue, key, model);
                serializedAttributes[key] = value;
            }
        });
        return serializedAttributes;
    }
    /**
     * Transform attribute names into their over-the-wire representation. Default
     * behavior uses the attribute name as-is.
     *
     * @since 0.1.0
     */
    serializeAttributeName(attributeName) {
        return attributeName;
    }
    /**
     * Take an attribute value and return the serialized value. Useful for
     * changing how certain types of values are serialized, i.e. Date objects.
     *
     * The default implementation returns the attribute's value unchanged.
     *
     * @since 0.1.0
     */
    serializeAttributeValue(value, key, model) {
        return value;
    }
    /**
     * Serialize the relationships for a given model
     *
     * @since 0.1.0
     */
    async serializeRelationships(model, action, options) {
        let serializedRelationships = {};
        let relationships = this.relationshipsToSerialize(action, options);
        // The result of this.relationships is a whitelist of which relationships
        // should be serialized, and the configuration for their serialization
        for (let relationshipName in this.relationships) {
            let config = relationships[relationshipName];
            let key = config.key || this.serializeRelationshipName(relationshipName);
            let descriptor = model.constructor.schema[relationshipName];
            assert(descriptor, `You specified a '${relationshipName}' relationship in your ${this.constructor.name} serializer, but no such relationship is defined on the ${model.modelName} model`);
            serializedRelationships[key] = await this.serializeRelationship(relationshipName, config, descriptor, model, action, options);
        }
        return serializedRelationships;
    }
    /**
     * Serializes a relationship
     *
     * @since 0.1.0
     */
    async serializeRelationship(relationship, config, descriptor, model, action, options) {
        let relatedSerializer = container_1.lookup(`serializer:${descriptor.relatedModelName}`, { loose: true }) || container_1.lookup(`serializer:application`, { loose: true });
        if (typeof relatedSerializer === 'boolean') {
            throw new Error(`No serializer found for ${descriptor.relatedModelName}, and no fallback application serializer found either`);
        }
        if (descriptor.mode === 'hasMany') {
            let relatedModels = await model.getRelated(relationship);
            return await bluebird_1.all(relatedModels.map(async (relatedModel) => {
                if (config.strategy === 'embed') {
                    return await relatedSerializer.renderModel(relatedModel, action, options);
                }
                else if (config.strategy === 'id') {
                    return relatedModel.id;
                }
            }));
        }
        else {
            let relatedModel = await model.getRelated(relationship);
            if (config.strategy === 'embed') {
                return await relatedSerializer.renderModel(relatedModel, action, options);
            }
            else if (config.strategy === 'id') {
                return relatedModel.id;
            }
        }
    }
    /**
     * Transform relationship names into their over-the-wire representation.
     * Default behavior uses the relationship name as-is.
     *
     * @since 0.1.0
     */
    serializeRelationshipName(name) {
        return name;
    }
    /**
     * Render an error payload
     *
     * @since 0.1.0
     */
    renderError(error, action, options) {
        return {
            status: error.status || 500,
            code: error.code || 'InternalServerError',
            message: error.message
        };
    }
}
exports.default = JSONSerializer;

});



// lib/render/serializer.js
//========================================

loader.add('/lib/render/serializer.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const view_1 = require("./view");
const errors_1 = require("../runtime/errors");
const result_1 = require("../utils/result");
const container_1 = require("../metal/container");
/**
 * Serializers allow you to customize what data is returned in the response and
 * apply simple transformations to it. They allow you to decouple what data is
 * sent from how that data is structured / rendered.
 *
 * @package data
 * @since 0.1.0
 */
class Serializer extends view_1.default {
    constructor() {
        super(...arguments);
        /**
         * The content type header to send back with the response
         *
         * @since 0.1.0
         */
        this.contentType = 'application/json';
    }
    /**
     * Convenience method to encapsulate standard attribute whitelist behavior -
     * render options take precedence, then allow this.attributes to be a
     * function or straight definition
     *
     * @since 0.1.0
     */
    attributesToSerialize(action, options) {
        return options.attributes || result_1.default(this.attributes, action);
    }
    /**
     * Convenience method to encapsulate standard relationship whitelist behavior
     * - render options take precedence, then allow this.relationships to be a
     * function or straight definition
     *
     * @since 0.1.0
     */
    relationshipsToSerialize(action, options) {
        return options.relationships || result_1.default(this.relationships, action);
    }
    async render(action, response, body, options) {
        response.setHeader('Content-type', this.contentType);
        if (body instanceof errors_1.default) {
            response.statusCode = body.status;
        }
        body = await this.serialize(body, action, options);
        let isProduction = container_1.lookup('config:environment').environment === 'production';
        response.write(JSON.stringify(body, null, isProduction ? 0 : 2) || '');
        response.end();
    }
}
exports.default = Serializer;

});



// lib/render/view.js
//========================================

loader.add('/lib/render/view.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const object_1 = require("../metal/object");
class View extends object_1.default {
}
exports.default = View;

});



// lib/runtime/action.js
//========================================

loader.add('/lib/runtime/action.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const lodash_1 = require("lodash");
const protochain = require("protochain");
const instrumentation_1 = require("../metal/instrumentation");
const model_1 = require("../data/model");
const createDebug = require("debug");
const assert = require("assert");
const object_1 = require("../metal/object");
const errors_1 = require("./errors");
const container_1 = require("../metal/container");
const debug = createDebug('denali:action');
const beforeFiltersCache = new Map();
const afterFiltersCache = new Map();
/**
 * Actions form the core of interacting with a Denali application. They are the
 * controller layer in the MVC architecture, taking in incoming requests,
 * performing business logic, and handing off to the renderer to send the
 * response.
 *
 * When a request comes in, Denali will invoke the `respond` method on the
 * matching Action class. The return value (or resolved return value) of this
 * method is used to render the response.
 *
 * Actions also support filters. Simply define a method on your action, and add
 * the method name to the `before` or `after` array. Filters behave similar to
 * responders in that they receive the request params and can return a promise
 * which will be waited on before continuing. Filters are inheritable, so child
 * classes will run filters added by parent classes.
 *
 * @package runtime
 * @since 0.1.0
 */
class Action extends object_1.default {
    constructor() {
        super(...arguments);
        /**
         * Application config
         *
         * @since 0.1.0
         */
        this.config = container_1.lookup('service:config');
        /**
         * Force which parser should be used for parsing the incoming request.
         *
         * By default it uses the application parser, but you can override with the
         * name of the parser you'd rather use instead.
         *
         * @since 0.1.0
         */
        this.parser = container_1.lookup('parser:application');
        /**
         * Automatically inject the logger into all actions
         *
         * @since 0.1.0
         */
        this.logger = container_1.lookup('app:logger');
        /**
         * Track whether or not we have rendered yet
         */
        this.hasRendered = false;
    }
    async render(status, body, options) {
        if (typeof status !== 'number') {
            options = body;
            body = status;
            status = 200;
        }
        if (!options) {
            options = {};
        }
        this.hasRendered = true;
        debug(`[${this.request.id}]: rendering`);
        this.response.setHeader('X-Request-Id', this.request.id);
        debug(`[${this.request.id}]: setting response status code to ${status}`);
        this.response.statusCode = status;
        if (!body) {
            debug(`[${this.request.id}]: no response body to render, response finished`);
            this.response.end();
            return;
        }
        // Render with a custom view if requested
        if (options.view) {
            let view = container_1.lookup(`view:${options.view}`);
            assert(view, `No such view: ${options.view}`);
            debug(`[${this.request.id}]: rendering response body with the ${options.view} view`);
            return await view.render(this, this.response, body, options);
        }
        // Pick the serializer to use
        let serializerLookup = 'application';
        if (options.serializer) {
            serializerLookup = options.serializer;
        }
        else {
            let sample = lodash_1.isArray(body) ? body[0] : body;
            if (sample instanceof model_1.default) {
                serializerLookup = sample.modelName;
            }
        }
        // Render with the serializer
        let serializer = container_1.lookup(`serializer:${serializerLookup}`);
        debug(`[${this.request.id}]: rendering response body with the ${serializerLookup} serializer`);
        return await serializer.render(this, this.response, body, options);
    }
    /**
     * Invokes the action. Determines the best responder method for content
     * negotiation, then executes the filter/responder chain in sequence,
     * handling errors and rendering the response.
     *
     * You shouldn't invoke this directly - Denali will automatically wire up
     * your routes to this method.
     *
     * @since 0.1.0
     */
    async run(request, response) {
        this.request = request;
        this.response = response;
        // Parse the incoming request based on the action's chosen parser
        debug(`[${request.id}]: parsing request`);
        assert(typeof this.parser.parse === 'function', 'The parser you supply must define a `parse(request)` method. See the parser docs for details');
        let parsedRequest = await this.parser.parse(request);
        // Build the before and after filter chains
        let { beforeChain, afterChain } = this._buildFilterChains();
        let instrumentation = instrumentation_1.default.instrument('action.run', {
            action: this.actionPath,
            parsed: parsedRequest
        });
        // Before filters
        debug(`[${this.request.id}]: running before filters`);
        await this._invokeFilters(beforeChain, parsedRequest);
        // Responder
        if (!this.hasRendered) {
            debug(`[${this.request.id}]: running responder`);
            let result = await this.respond(parsedRequest);
            // Autorender if render has not been manually called and a value was returned
            if (!this.hasRendered) {
                debug(`[${this.request.id}]: autorendering`);
                await this.render(result);
            }
        }
        // After filters
        debug(`[${this.request.id}]: running after filters`);
        await this._invokeFilters(afterChain, parsedRequest);
        // If no one has rendered, bail
        if (!this.hasRendered) {
            throw new errors_1.default.InternalServerError(`${this.actionPath} did not render anything`);
        }
        instrumentation.finish();
    }
    /**
     * Invokes the filters in the supplied chain in sequence.
     */
    async _invokeFilters(chain, parsedRequest) {
        chain = lodash_1.clone(chain);
        while (chain.length > 0) {
            let filter = chain.shift();
            let instrumentation = instrumentation_1.default.instrument('action.filter', {
                action: this.actionPath,
                request: parsedRequest,
                filter: filter.name
            });
            debug(`[${this.request.id}]: running '${filter.name}' filter`);
            let filterResult = await filter.call(this, parsedRequest);
            instrumentation.finish();
            if (!this.hasRendered && filterResult) {
                return this.render(200, filterResult);
            }
        }
    }
    /**
     * Walk the prototype chain of this Action instance to find all the `before`
     * and `after` arrays to build the complete filter chains.
     *
     * Caches the result on the child Action class to avoid the potentially
     * expensive prototype walk on each request.
     *
     * Throws if it encounters the name of a filter method that doesn't exist.
     */
    _buildFilterChains() {
        let ActionClass = this.constructor;
        if (!beforeFiltersCache.has(ActionClass)) {
            let prototypeChain = protochain(ActionClass).reverse().concat(ActionClass);
            this._buildFilterChain('before', beforeFiltersCache, prototypeChain);
            this._buildFilterChain('after', afterFiltersCache, prototypeChain);
        }
        return {
            beforeChain: beforeFiltersCache.get(ActionClass),
            afterChain: afterFiltersCache.get(ActionClass)
        };
    }
    _buildFilterChain(stageName, cache, prototypes) {
        let ActionClass = this.constructor;
        let compiledFilterList = lodash_1.flatMap(prototypes, (prototype) => {
            let filters = lodash_1.get(prototype, stageName, []);
            filters = lodash_1.castArray(filters);
            return filters.map((filter) => {
                if (typeof filter === 'string') {
                    assert(typeof lodash_1.get(this, filter) === 'function', `${filter} method not found on the ${this.actionPath} action.`);
                    return this[filter];
                }
                return filter;
            });
        });
        cache.set(ActionClass, compiledFilterList);
    }
}
/**
 * Invoked before the `respond()` method. The framework will invoke filters
 * from parent classes and mixins in the same order the mixins were applied.
 *
 * Filters can be synchronous, or return a promise (which will pause the
 * before/respond/after chain until it resolves).
 *
 * If a before filter returns any value (or returns a promise which resolves
 * to any value) other than null or undefined, Denali will attempt to render
 * that response and halt further processing of the request (including
 * remaining before filters).
 *
 * Filters must be defined as static properties to allow Denali to extract
 * the values. Instance fields are not visible until instantiation, so
 * there's no way to build an "accumulated" value from each step in the
 * inheritance chain.
 *
 * @since 0.1.0
 */
Action.before = [];
/**
 * Invoked after the `respond()` method. The framework will invoke filters
 * from parent classes and mixins in the same order the mixins were applied.
 *
 * Filters can be synchronous, or return a promise (which will pause the
 * before/respond/after chain until it resolves).
 *
 * Filters must be defined as static properties to allow Denali to extract
 * the values. Instance fields are not visible until instantiation, so
 * there's no way to build an "accumulated" value from each step in the
 * inheritance chain.
 *
 * @since 0.1.0
 */
Action.after = [];
exports.default = Action;

});



// lib/runtime/addon.js
//========================================

loader.add('/lib/runtime/addon.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const container_1 = require("../metal/container");
/**
 * Addons are the fundamental unit of organization for Denali apps. The
 * Application class is just a specialized Addon, and each Addon can contain
 * any amount of functionality - each one is essentially a mini Denali app.
 *
 * @package runtime
 * @since 0.1.0
 */
class Addon {
    /**
     * The resolver for this addon's loader scope
     */
    get resolver() {
        return this.loader.resolver;
    }
    constructor(loader, options) {
        this.loader = loader;
        this.environment = options.environment;
        container_1.default.register(`addon:${this.name}`, this);
    }
    /**
     * The name of the addon. Override this to use a different name than the
     * package name for your addon.
     *
     * @since 0.1.0
     */
    get name() {
        return `${this.loader.pkgName}@${this.loader.version}`;
    }
    /**
     * A hook to perform any shutdown actions necessary to gracefully exit the
     * application, i.e. close database/socket connections.
     *
     * @since 0.1.0
     */
    async shutdown(application) {
        // defaults to noop
    }
}
exports.default = Addon;

});



// lib/runtime/application.js
//========================================

loader.add('/lib/runtime/application.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const lodash_1 = require("lodash");
const http = require("http");
const https = require("https");
const bluebird_1 = require("bluebird");
const addon_1 = require("./addon");
const topsort_1 = require("../utils/topsort");
const container_1 = require("../metal/container");
/**
 * Application instances are specialized Addons, designed to kick off the
 * loading, mounting, and launching stages of booting up.
 *
 * @package runtime
 */
class Application extends addon_1.default {
    constructor(loader, options) {
        super(loader, lodash_1.defaults(options, { environment: 'development' }));
        /**
         * List of child addons for this app (one-level deep only, i.e. no
         * addons-of-addons are included)
         *
         * @since 0.1.0
         */
        this.addons = [];
        this.loader.children.forEach((addonLoader, addonName) => {
            let AddonClass = addonLoader.resolver.retrieve('app:addon') || addon_1.default;
            this.addons.push(new AddonClass(addonLoader, options));
        });
        this.drainers = [];
        // Setup some helpful container shortcuts
        container_1.default.register('app:main', this);
        this.router = container_1.default.lookup('app:router');
        this.logger = container_1.default.lookup('app:logger');
        // Generate config first, since the loading process may need it
        this.generateConfig();
        this.config = container_1.default.lookup('service:config');
        this.compileRouter();
    }
    /**
     * Take the loaded environment config functions, and execute them.
     * Application config is executed first, and the returned config object is
     * handed off to the addon config files, which add their configuration by
     * mutating that same object.
     *
     * The resulting final config is stored at `application.config`, and is
     * registered in the container under `config:environment`.
     *
     * This is invoked before the rest of the addons are loaded for 2 reasons:
     *
     * - The config values for the application could theoretically impact the
     *   addon loading process
     * - Addons are given a chance to modify the application config, so it must
     *   be loaded before they are.
     */
    generateConfig() {
        let appConfig = this.resolver.retrieve('config:environment') || lodash_1.constant({
            environment: 'development',
            server: {
                port: 3000
            }
        });
        let config = appConfig(this.environment, container_1.default);
        config.environment = this.environment;
        container_1.default.register('config:environment', config);
        this.addons.forEach((addon) => {
            let addonConfig = addon.resolver.retrieve('config:environment');
            if (addonConfig) {
                addonConfig(this.environment, container_1.default, config);
            }
        });
        return config;
    }
    /**
     * Assemble middleware and routes
     */
    compileRouter() {
        // Load addon middleware first
        this.addons.forEach((addon) => {
            let addonMiddleware = addon.resolver.retrieve('config:middleware') || lodash_1.noop;
            addonMiddleware(this.router, this);
        });
        // Then load app middleware
        let appMiddleware = this.resolver.retrieve('config:middleware') || lodash_1.noop;
        appMiddleware(this.router, this);
        // Load app routes first so they have precedence
        let appRoutes = this.resolver.retrieve('config:routes') || lodash_1.noop;
        appRoutes(this.router, this);
        // Load addon routes in reverse order so routing precedence matches addon load order
        this.addons.reverse().forEach((addon) => {
            let addonRoutes = addon.resolver.retrieve('config:routes') || lodash_1.noop;
            addonRoutes(this.router, this);
        });
    }
    /**
     * Start the Denali server. Runs all initializers, creates an HTTP server,
     * and binds to the port to handle incoming HTTP requests.
     *
     * @since 0.1.0
     */
    async start() {
        let port = this.config.getWithDefault('server', 'port', 3000);
        await this.runInitializers();
        if (!this.config.get('server', 'detached')) {
            await this.createServer(port);
            this.logger.info(`${this.name} server up on port ${port}`);
        }
    }
    /**
     * Creates an HTTP or HTTPS server, depending on whether or not SSL
     * configuration is present in config/environment.js
     */
    async createServer(port) {
        await new Promise((resolve) => {
            let handler = this.router.handle.bind(this.router);
            let server;
            if (this.config.get('server', 'ssl')) {
                server = https.createServer(this.config.get('server', 'ssl'), handler).listen(port, resolve);
            }
            else {
                server = http.createServer(handler).listen(port, resolve);
            }
            this.drainers.push(async function drainHttp() {
                await new Promise((resolveDrainer) => {
                    server.close(resolveDrainer);
                    setTimeout(resolveDrainer, 60 * 1000);
                });
            });
        });
    }
    /**
     * Lookup all initializers and run them in sequence. Initializers can
     * override the default load order by including `before` or `after`
     * properties on the exported class (the name or array of names of the other
     * initializers it should run before/after).
     *
     * @since 0.1.0
     */
    async runInitializers() {
        let initializers = lodash_1.values(container_1.default.lookupAll('initializer'));
        initializers = topsort_1.default(initializers);
        for (let initializer of initializers) {
            await initializer.initialize(this);
        }
    }
    /**
     * Shutdown the application gracefully (i.e. close external database
     * connections, drain in-flight requests, etc)
     *
     * @since 0.1.0
     */
    async shutdown() {
        await bluebird_1.all(this.drainers.map((drainer) => drainer()));
        await bluebird_1.all(this.addons.map(async (addon) => {
            await addon.shutdown(this);
        }));
        container_1.default.teardown();
    }
}
exports.default = Application;

});



// lib/runtime/config.js
//========================================

loader.add('/lib/runtime/config.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const service_1 = require("./service");
const lodash_1 = require("lodash");
const container_1 = require("../metal/container");
class ConfigService extends service_1.default {
    constructor() {
        super(...arguments);
        this._config = container_1.lookup('config:environment');
    }
    get environment() {
        return this._config.environment;
    }
    get(...path) {
        // Split on dots in path segments, allowing for `get('foo.bar')` as well as `get('foo', 'bar')`
        path = path.reduce((segments, nextSegment) => segments.concat(nextSegment.split('.')), []);
        return lodash_1.get(this._config, path);
    }
    getWithDefault(...args) {
        let defaultValue = args.pop();
        let path = args;
        // Split on dots in path segments, allowing for `get('foo.bar')` as well as `get('foo', 'bar')`
        path = path.reduce((segments, nextSegment) => segments.concat(nextSegment.split('.')), []);
        return lodash_1.get(this._config, path, defaultValue);
    }
}
exports.default = ConfigService;

});



// lib/runtime/errors.js
//========================================

loader.add('/lib/runtime/errors.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Errors = require("http-errors");
/**
 * Denali uses the **http-errors** package for handling HTTP errors. Check
 * [it's documentation](https://github.com/jshttp/http-errors) for how to use
 * it.
 *
 * @package runtime
 * @since 0.1.0
 */
exports.default = Errors;

});



// lib/runtime/logger.js
//========================================

loader.add('/lib/runtime/logger.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const lodash_1 = require("lodash");
const chalk_1 = require("chalk");
const object_1 = require("../metal/object");
/**
 * A simple Logger class that adds timestamps and supports multiple levels of
 * logging, colorized output, and control over verbosity.
 *
 * @package runtime
 * @since 0.1.0
 */
class Logger extends object_1.default {
    constructor() {
        super(...arguments);
        /**
         * Default log level if none specified.
         *
         * @since 0.1.0
         */
        this.loglevel = 'info';
        /**
         * Specify if logs should be colorized.
         *
         * @since 0.1.0
         */
        this.colorize = true;
        /**
         * Available log levels that can be used.
         */
        this.levels = [
            'info',
            'warn',
            'error'
        ];
        /**
         * Color map for the available levels.
         */
        this.colors = {
            info: chalk_1.default.white,
            warn: chalk_1.default.yellow,
            error: chalk_1.default.red
        };
    }
    /**
     * Log at the 'info' level.
     *
     * @since 0.1.0
     */
    info(msg) {
        this.log('info', msg);
    }
    /**
     * Log at the 'warn' level.
     *
     * @since 0.1.0
     */
    warn(msg) {
        this.log('warn', msg);
    }
    /**
     * Log at the 'error' level.
     *
     * @since 0.1.0
     */
    error(msg) {
        this.log('error', msg);
    }
    /**
     * Log a message to the logger at a specific log level.
     */
    log(level, msg) {
        if (this.levels.indexOf(level) === -1) {
            level = this.loglevel;
        }
        let timestamp = (new Date()).toISOString();
        let padLength = this.levels.reduce((n, label) => Math.max(n, label.length), null);
        let levelLabel = lodash_1.padStart(level.toUpperCase(), padLength);
        if (this.colorize) {
            let colorizer = this.colors[level] || lodash_1.identity;
            msg = colorizer(msg);
            levelLabel = colorizer(levelLabel);
        }
        /* tslint:disable:no-console no-debugger */
        console.log(`[${timestamp}] ${levelLabel} - ${msg}`);
        if (level === 'error') {
            debugger;
        }
        /* tslint:enable:no-console no-debugger*/
    }
}
exports.default = Logger;

});



// lib/runtime/request.js
//========================================

loader.add('/lib/runtime/request.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const lodash_1 = require("lodash");
const accepts = require("accepts");
const net_1 = require("net");
const typeis = require("type-is");
const parseRange = require("range-parser");
const parse = require("parseurl");
const proxyaddr = require("proxy-addr");
const uuid = require("uuid");
const url = require("url");
/**
 * The Request class represents an incoming HTTP request (specifically, Node's
 * IncomingMessage).
 *
 * @package runtime
 * @since 0.1.0
 */
class Request {
    constructor(incomingMessage, serverConfig) {
        /**
         * A UUID generated unqiue to this request. Useful for tracing a request
         * through the application.
         *
         * @since 0.1.0
         */
        this.id = uuid.v4();
        this.incomingMessage = incomingMessage;
        this.config = serverConfig || {};
    }
    /**
     * The uppercase method name for the request, i.e. GET, POST, HEAD
     *
     * @since 0.1.0
     */
    get method() {
        return this.incomingMessage.method.toUpperCase();
    }
    /**
     * The requested path name
     *
     * @since 0.1.0
     */
    get path() {
        return parse(this.incomingMessage).pathname;
    }
    /**
     * The query string, parsed into an object
     *
     * @since 0.1.0
     */
    get query() {
        return url.parse(this.incomingMessage.url, true).query;
    }
    /**
     * The headers for the incoming request
     *
     * @since 0.1.0
     */
    get headers() {
        return this.incomingMessage.headers;
    }
    /**
     * Return subdomains as an array.
     *
     * Subdomains are the dot-separated parts of the host before the main domain
     * of the app. By default, the domain of the app is assumed to be the last
     * two parts of the host. This can be changed by setting
     * config.server.subdomainOffset
     *
     * For example, if the domain is "tobi.ferrets.example.com": If the subdomain
     * offset is not set, req.subdomains is `["ferrets", "tobi"]`. If the
     * subdomain offset is 3, req.subdomains is `["tobi"]`.
     *
     * @since 0.1.0
     */
    get subdomains() {
        let hostname = this.hostname;
        if (!hostname) {
            return [];
        }
        let offset = this.config.subdomainOffset;
        let subdomains = !net_1.isIP(hostname) ? hostname.split('.').reverse() : [hostname];
        return subdomains.slice(offset == null ? 2 : offset);
    }
    /**
     * Return the protocol string "http" or "https" when requested with TLS. When
     * the "server.trustProxy" setting trusts the socket address, the
     * "X-Forwarded-Proto" header field will be trusted and used if present.
     *
     * If you're running behind a reverse proxy that supplies https for you this
     * may be enabled.
     *
     * @since 0.1.0
     */
    get protocol() {
        let rawProtocol = this.incomingMessage.connection.encrypted ? 'https' : 'http';
        let ip = this.incomingMessage.connection.remoteAddress;
        let trustProxyConfig = this.config.trustProxy || lodash_1.constant(false);
        if (trustProxyConfig) {
            let trustProxy;
            if (typeof trustProxyConfig !== 'function') {
                trustProxy = proxyaddr.compile(trustProxyConfig);
            }
            else {
                trustProxy = trustProxyConfig;
            }
            if (trustProxy(ip, 0)) {
                let proxyClaimedProtocol = this.getHeader('X-Forwarded-Proto') || rawProtocol;
                return proxyClaimedProtocol.split(/\s*,\s*/)[0];
            }
        }
        return rawProtocol;
    }
    /**
     * Check if the request was an _XMLHttpRequest_.
     *
     * @since 0.1.0
     */
    get xhr() {
        let val = this.getHeader('X-Requested-With') || '';
        return val.toLowerCase() === 'xmlhttprequest';
    }
    /**
     * Parse the "Host" header field to a hostname.
     *
     * When the "trust proxy" setting trusts the socket address, the
     * "X-Forwarded-Host" header field will be trusted.
     *
     * @since 0.1.0
     */
    get hostname() {
        let host = this.getHeader('X-Forwarded-Host');
        let ip = this.incomingMessage.socket.remoteAddress;
        let trustProxyConfig = this.config.trustProxy || lodash_1.constant(false);
        let trustProxy;
        if (typeof trustProxyConfig !== 'function') {
            trustProxy = proxyaddr.compile(trustProxyConfig);
        }
        else {
            trustProxy = trustProxyConfig;
        }
        if (!host || !trustProxy(ip, 0)) {
            host = this.getHeader('Host');
        }
        if (!host) {
            return;
        }
        // IPv6 literal support
        let offset = host[0] === '[' ? host.indexOf(']') + 1 : 0;
        let index = host.indexOf(':', offset);
        return index !== -1 ? host.substring(0, index) : host;
    }
    /**
     * Return the remote address from the trusted proxy.
     *
     * The is the remote address on the socket unless "trust proxy" is set.
     *
     * @since 0.1.0
     */
    get ip() {
        let trustProxyConfig = this.config.trustProxy || lodash_1.constant(false);
        return proxyaddr(this.incomingMessage, trustProxyConfig);
    }
    /**
     * When "trust proxy" is set, trusted proxy addresses + client.
     *
     * For example if the value were "client, proxy1, proxy2" you would receive
     * the array `["client", "proxy1", "proxy2"]` where "proxy2" is the furthest
     * down-stream and "proxy1" and "proxy2" were trusted.
     *
     * @since 0.1.0
     */
    get ips() {
        let trustProxyConfig = this.config.trustProxy || lodash_1.constant(false);
        let ips = proxyaddr.all(this.incomingMessage, trustProxyConfig);
        ips.reverse().pop();
        return ips;
    }
    /**
     * Does this request have a request body?
     */
    get hasBody() {
        return typeis.hasBody(this.incomingMessage);
    }
    getHeader(name) {
        return this.incomingMessage.headers[name.toLowerCase()];
    }
    accepts(...type) {
        let accept = accepts(this.incomingMessage);
        return accept.types(...type);
    }
    acceptsEncodings(...encoding) {
        let accept = accepts(this.incomingMessage);
        // <any> is needed here because of incorrect types
        // see https://github.com/DefinitelyTyped/DefinitelyTyped/pull/23395
        return accept.encodings(...encoding);
    }
    acceptsCharsets(...charset) {
        let accept = accepts(this.incomingMessage);
        // <any> is needed here because of incorrect types
        // see https://github.com/DefinitelyTyped/DefinitelyTyped/pull/23395
        return accept.charsets(...charset);
    }
    acceptsLanguages(...lang) {
        let accept = accepts(this.incomingMessage);
        // <any> is needed here because of incorrect types
        // see https://github.com/DefinitelyTyped/DefinitelyTyped/pull/23395
        return accept.languages(...lang);
    }
    /**
     * Parse Range header field, capping to the given `size`.
     *
     * Unspecified ranges such as "0-" require knowledge of your resource length.
     * In the case of a byte range this is of course the total number of bytes. If
     * the Range header field is not given `undefined` is returned, `-1` when
     * unsatisfiable, and `-2` when syntactically invalid.
     *
     * When ranges are returned, the array has a "type" property which is the type
     * of range that is required (most commonly, "bytes"). Each array element is
     * an object with a "start" and "end" property for the portion of the range.
     *
     * The "combine" option can be set to `true` and overlapping & adjacent ranges
     * will be combined into a single range.
     *
     * NOTE: remember that ranges are inclusive, so for example "Range: users=0-3"
     * should respond with 4 users when available, not 3.
     *
     * @since 0.1.0
     */
    range(size, options) {
        let range = this.getHeader('Range');
        if (!range) {
            return;
        }
        return parseRange(size, range, options);
    }
    /**
     * Check if the incoming request contains the "Content-Type" header field,
     * and it contains the give mime `type`.
     *
     * Examples:
     *
     *      // With Content-Type: text/html; charset=utf-8
     *      req.is('html');
     *      req.is('text/html');
     *      req.is('text/*');
     *      // => true
     *
     *      // When Content-Type is application/json
     *      req.is('json');
     *      req.is('application/json');
     *      req.is('application/*');
     *      // => true
     *
     *      req.is('html');
     *      // => false
     *
     * @since 0.1.0
     */
    is(...types) {
        if (Array.isArray(types[0])) {
            types = types[0];
        }
        return typeis(this.incomingMessage, types);
    }
}
exports.default = Request;

});



// lib/runtime/route.js
//========================================

loader.add('/lib/runtime/route.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const RouteParser = require("route-parser");
/**
 * Extends the base RouteParser Route class with some additional properties
 * that Denali tacks on.
 *
 * @package runtime
 */
class Route extends RouteParser {
}
exports.default = Route;

});



// lib/runtime/router.js
//========================================

loader.add('/lib/runtime/router.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const ware = require("ware");
const inflection_1 = require("inflection");
const bluebird_1 = require("bluebird");
const createDebug = require("debug");
const errors_1 = require("./errors");
const route_1 = require("./route");
const request_1 = require("./request");
const object_1 = require("../metal/object");
const container_1 = require("../metal/container");
const lodash_1 = require("lodash");
const debug = createDebug('denali:router');
/**
 * The Router handles incoming requests, sending them to the appropriate
 * action. It's also responsible for defining routes in the first place - it's
 * passed into the `config/routes.js` file's exported function as the first
 * argument.
 *
 * @package runtime
 * @since 0.1.0
 */
class Router extends object_1.default {
    constructor() {
        super(...arguments);
        /**
         * The cache of available routes.
         */
        this.routes = {
            GET: [],
            POST: [],
            PUT: [],
            PATCH: [],
            DELETE: [],
            HEAD: [],
            OPTIONS: []
        };
        /**
         * The internal generic middleware handler, responsible for building and
         * executing the middleware chain.
         */
        this.middleware = ware();
    }
    get config() {
        return container_1.lookup('service:config');
    }
    /**
     * Helper method to invoke the function exported by `config/routes.js` in the
     * context of the current router instance.
     *
     * @since 0.1.0
     */
    map(fn) {
        debug('mapping routes');
        fn(this);
    }
    /**
     * Takes an incoming request and it's response from an HTTP server, prepares
     * them, runs the generic middleware first, hands them off to the appropriate
     * action given the incoming URL, and finally renders the response.
     */
    async handle(req, res) {
        let serverConfig = this.config.get('server');
        let request = new request_1.default(req, serverConfig);
        try {
            debug(`[${request.id}]: ${request.method.toUpperCase()} ${request.path}`);
            // Middleware
            await bluebird_1.fromNode((cb) => this.middleware.run(request, res, cb));
            // Find the matching route
            debug(`[${request.id}]: routing request`);
            let routes = this.routes[request.method];
            if (routes) {
                /* tslint:disable-next-line prefer-for-of */
                for (let i = 0; i < routes.length; i += 1) {
                    request.params = routes[i].match(request.path);
                    if (request.params) {
                        request.route = routes[i];
                        break;
                    }
                }
            }
            // Handle 404s
            if (!request.route) {
                let availableRoutes = routes && routes.map((r) => r.spec);
                debug(`[${request.id}]: ${request.method} ${request.path} did match any route. Available ${request.method} routes:\n${availableRoutes.join(',\n') || 'none'}`);
                let error = new errors_1.default.NotFound('Route not recognized');
                error.meta = { availableRoutesForMethod: routes || [] };
                throw error;
            }
            // Create our action to handle the response
            let action = new request.route.action();
            // Run the action
            debug(`[${request.id}]: running action`);
            await action.run(request, res);
        }
        catch (error) {
            await this.handleError(request, res, error);
        }
    }
    /**
     * Takes a request, response, and an error and hands off to the generic
     * application level error action.
     */
    async handleError(request, res, error) {
        request.params = request.params || {};
        request.params.error = error;
        let ErrorAction = container_1.lookup('action:error');
        let errorAction = new ErrorAction();
        return errorAction.run(request, res);
    }
    /**
     * Add the supplied middleware function to the generic middleware stack that
     * runs prior to action handling.
     *
     * @since 0.1.0
     */
    use(middleware) {
        this.middleware.use(middleware);
    }
    /**
     * Add a route to the application. Maps a method and URL pattern to an
     * action, with optional additional parameters.
     *
     * URL patterns can use:
     *
     * * Dynamic segments, i.e. `'foo/:bar'` * Wildcard segments, i.e.
     *   `'foo/*bar'`, captures the rest of the URL up to the querystring
     * * Optional groups, i.e. `'foo(/:bar)'`
     *
     * @since 0.1.0
     */
    route(method, rawPattern, actionPath, params) {
        method = method.toUpperCase();
        // Ensure leading slashes
        let normalizedPattern = rawPattern.replace(/^([^/])/, '/$1');
        // Remove hardcoded trailing slashes
        normalizedPattern = normalizedPattern.replace(/\/$/, '');
        // Ensure optional trailing slashes
        normalizedPattern = `${normalizedPattern}(/)`;
        // Add route
        let ActionClass = container_1.lookup(`action:${actionPath}`);
        let route = new route_1.default(normalizedPattern);
        route.actionPath = actionPath;
        route.action = ActionClass;
        route.additionalParams = params;
        if (!route.action) {
            throw new Error(`No action found at ${actionPath}`);
        }
        this.routes[method].push(route);
    }
    /**
     * Returns the URL for a given action. You can supply a params object which
     * will be used to fill in the dynamic segements of the action's route (if
     * any).
     */
    urlFor(actionPath, data) {
        let actionEntry = container_1.lookup(`action:${actionPath}`, { loose: true });
        if (actionEntry === false) {
            return false;
        }
        let action = actionEntry; // because TS won't narrow the type in the forEach below
        let route;
        lodash_1.forEach(this.routes, (routes) => {
            route = lodash_1.find(routes, { action });
            return !route; // kill the iterator if we found the match
        });
        return route && route.reverse(data);
    }
    /**
     * Shorthand for `this.route('get', ...arguments)`
     *
     * @since 0.1.0
     */
    get(rawPattern, actionPath, params) {
        this.route('get', rawPattern, actionPath, params);
    }
    /**
     * Shorthand for `this.route('post', ...arguments)`
     *
     * @since 0.1.0
     */
    post(rawPattern, actionPath, params) {
        this.route('post', rawPattern, actionPath, params);
    }
    /**
     * Shorthand for `this.route('put', ...arguments)`
     *
     * @since 0.1.0
     */
    put(rawPattern, actionPath, params) {
        this.route('put', rawPattern, actionPath, params);
    }
    /**
     * Shorthand for `this.route('patch', ...arguments)`
     *
     * @since 0.1.0
     */
    patch(rawPattern, actionPath, params) {
        this.route('patch', rawPattern, actionPath, params);
    }
    /**
     * Shorthand for `this.route('delete', ...arguments)`
     *
     * @since 0.1.0
     */
    delete(rawPattern, actionPath, params) {
        this.route('delete', rawPattern, actionPath, params);
    }
    /**
     * Shorthand for `this.route('head', ...arguments)`
     *
     * @since 0.1.0
     */
    head(rawPattern, actionPath, params) {
        this.route('head', rawPattern, actionPath, params);
    }
    /**
     * Shorthand for `this.route('options', ...arguments)`
     *
     * @since 0.1.0
     */
    options(rawPattern, actionPath, params) {
        this.route('options', rawPattern, actionPath, params);
    }
    /**
     * Create all the CRUD routes for a given resource and it's relationships.
     * Based on the JSON-API recommendations for URL design.
     *
     * The `options` argument lets you pass in `only` or `except` arrays to
     * define exceptions. Action names included in `only` will be the only ones
     * generated, while names included in `except` will be omitted.
     *
     * Set `options.related = false` to disable relationship routes.
     *
     * If no options are supplied, the following routes are generated (assuming a
     * 'books' resource as an example):
     *
     *   * `GET /books`
     *   * `POST /books`
     *   * `GET /books/:id`
     *   * `PATCH /books/:id`
     *   * `DELETE /books/:id`
     *   * `GET /books/:id/:relation`
     *   * `GET /books/:id/relationships/:relation`
     *   * `PATCH /books/:id/relationships/:relation`
     *   * `POST /books/:id/relationships/:relation`
     *   * `DELETE /books/:id/relationships/:relation`
     *
     * See http://jsonapi.org/recommendations/#urls for details.
     *
     * @since 0.1.0
     */
    resource(resourceName, options = {}) {
        let plural = inflection_1.pluralize(resourceName);
        let collection = `/${plural}`;
        let resource = `${collection}/:id`;
        let relationship = `${resource}/relationships/:relation`;
        let related = `${resource}/:relation`;
        if (!options.related) {
            options.except = ['related', 'fetch-related', 'replace-related', 'add-related', 'remove-related'].concat(options.except);
        }
        let hasWhitelist = Boolean(options.only);
        options.only = lodash_1.castArray(options.only);
        options.except = lodash_1.castArray(options.except);
        /**
         * Check if the given action should be generated based on the
         * whitelist/blacklist options
         */
        function include(action) {
            let whitelisted = options.only.includes(action);
            let blacklisted = options.except.includes(action);
            return !blacklisted && ((hasWhitelist && whitelisted) ||
                !hasWhitelist);
        }
        [
            ['list', 'get', collection],
            ['create', 'post', collection],
            ['show', 'get', resource],
            ['update', 'patch', resource],
            ['destroy', 'delete', resource],
            ['related', 'get', related],
            ['fetch-related', 'get', relationship],
            ['replace-related', 'patch', relationship],
            ['add-related', 'post', relationship],
            ['remove-related', 'delete', relationship]
        ].forEach((routeTemplate) => {
            let [action, method, url] = routeTemplate;
            if (include(action)) {
                let routeMethod = this[method];
                routeMethod.call(this, url, `${plural}/${action}`);
            }
        });
    }
    /**
     * Enables easy route namespacing. You can supply a method which takes a
     * single argument that works just like the `router` argument in your
     * `config/routes.js`, or you can use the return value just like the router.
     *
     *   router.namespace('users', (namespace) => {
     *     namespace.get('sign-in');
     *   });
     *   // or ...
     *   let namespace = router.namespace('users');
     *   namespace.get('sign-in');
     */
    namespace(namespace, fn) {
        let router = this;
        if (namespace.endsWith('/')) {
            namespace = namespace.slice(0, namespace.length - 1);
        }
        // tslint:disable:completed-docs
        let wrapper = {
            get(pattern, actionPath, params) {
                router.route('get', `${namespace}/${pattern.replace(/^\//, '')}`, actionPath, params);
            },
            post(pattern, actionPath, params) {
                router.route('post', `${namespace}/${pattern.replace(/^\//, '')}`, actionPath, params);
            },
            put(pattern, actionPath, params) {
                router.route('put', `${namespace}/${pattern.replace(/^\//, '')}`, actionPath, params);
            },
            patch(pattern, actionPath, params) {
                router.route('patch', `${namespace}/${pattern.replace(/^\//, '')}`, actionPath, params);
            },
            delete(pattern, actionPath, params) {
                router.route('delete', `${namespace}/${pattern.replace(/^\//, '')}`, actionPath, params);
            },
            head(pattern, actionPath, params) {
                router.route('head', `${namespace}/${pattern.replace(/^\//, '')}`, actionPath, params);
            },
            options(pattern, actionPath, params) {
                router.route('options', `${namespace}/${pattern.replace(/^\//, '')}`, actionPath, params);
            },
            resource(resourceName, options) {
                router.resource.call(this, resourceName, options);
            }
        };
        // tslint:enable:completed-docs
        if (fn) {
            fn(wrapper);
        }
    }
}
exports.default = Router;

});



// lib/runtime/service.js
//========================================

loader.add('/lib/runtime/service.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const object_1 = require("../metal/object");
/**
 * Services are typically used to represent either external systems (i.e. a
 * caching service) or a cross-cutting, reusable piece of application logic
 * (i.e. an authorization / roles service).
 *
 * Services are mostly conventional - they are just singletons with no
 * special behavior. The common base class ensures they are
 * singletons, makes user intent clear, and paves the way for introducing
 * additional common functionality in future versions of Denali.
 *
 * @package runtime
 */
class Service extends object_1.default {
}
exports.default = Service;

});



// lib/test/acceptance-test.js
//========================================

loader.add('/lib/test/acceptance-test.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const path = require("path");
const glob_1 = require("glob");
const bluebird_1 = require("bluebird");
const lodash_1 = require("lodash");
const mock_request_1 = require("./mock-request");
const mock_response_1 = require("./mock-response");
/**
 * The AppAcceptance class represents an app acceptance test. It spins up an
 * in-memory instance of the application under test, and exposes methods to
 * submit simulated requests to the application, and get the response. This
 * helps keep acceptance tests lightweight and easily parallelizable, since
 * they don't need to bind to an actual port.
 *
 * @package test
 * @since 0.1.0
 */
class AcceptanceTest {
    constructor() {
        /**
         * Default headers that are applied to each request. Useful for handling
         * API-wide content-types, sessions, etc.
         *
         * @since 0.1.0
         */
        this.headers = {
            accept: 'application/json',
            'content-type': 'application/json'
        };
        /**
         * An internal registry of container injections.
         */
        this._injections = {};
        let compiledPath = path.join(process.cwd(), process.env.DENALI_TEST_BUILD_DIR);
        let bundleFile = glob_1.sync(path.join(compiledPath, '*.bundle.js'))[0];
        let bundle = require(bundleFile);
        this.container = bundle();
        let Application = this.container.lookup('app:application');
        this.application = new Application(this.container.loader, { environment: process.env.NODE_ENV || 'test' });
    }
    /**
     * A helper method for setting up an app acceptance test. Adds
     * beforeEach/afterEach hooks to the current ava test suite which will setup
     * and teardown the acceptance test. They also setup a test transaction and
     * roll it back once the test is finished (for the ORM adapters that support
     * it), so your test data won't pollute the database.
     *
     * @package test
     * @since 0.1.0
     */
    static setupTest() {
        let ava = require('ava');
        ava.beforeEach(async (t) => {
            let acceptanceTest = new AcceptanceTest();
            await acceptanceTest.setup(t.context);
        });
        ava.afterEach.always(async (t) => {
            await t.context.app.teardown();
        });
        return ava;
    }
    async setup(context) {
        context.app = this;
        await this.start();
        let adapters = this.container.lookupAll('orm-adapter');
        let transactionInitializers = [];
        lodash_1.forEach(adapters, (Adapter) => {
            if (typeof Adapter.startTestTransaction === 'function') {
                transactionInitializers.push(Adapter.startTestTransaction());
            }
        });
        await bluebird_1.all(transactionInitializers);
    }
    async teardown() {
        let transactionRollbacks = [];
        let adapters = this.container.lookupAll('orm-adapter');
        lodash_1.forEach(adapters, (Adapter) => {
            if (typeof Adapter.rollbackTestTransaction === 'function') {
                transactionRollbacks.push(Adapter.rollbackTestTransaction());
            }
        });
        await bluebird_1.all(transactionRollbacks);
        await this.shutdown();
    }
    /**
     * Start the application (note: this won't actually start the HTTP server, but performs all the
     * other startup work for you).
     *
     * @since 0.1.0
     */
    async start() {
        await this.application.runInitializers();
    }
    /**
     * Submit a simulated HTTP request to the application.
     *
     * @since 0.1.0
     */
    async request(options) {
        let body = null;
        options.headers = lodash_1.mapKeys(options.headers, (value, key) => key.toLowerCase()) || {};
        if (options.body) {
            body = typeof options.body === 'string' ? options.body : JSON.stringify(options.body);
            options.headers['transfer-encoding'] = 'chunked';
        }
        let req = new mock_request_1.default({
            method: options.method.toUpperCase(),
            url: options.url,
            headers: lodash_1.assign({}, this.headers, options.headers)
        });
        return new Promise((resolve, reject) => {
            let res = new mock_response_1.default(({ status, body, json }) => {
                if (status < 500) {
                    resolve({ status: res.statusCode, body: json || body });
                }
                else {
                    reject({ response: res, status, body, json });
                }
            });
            // tslint:disable-next-line:no-floating-promises
            this.application.router.handle(req, res);
            let SIMULATED_WRITE_DELAY = 10;
            setTimeout(() => {
                if (body) {
                    req.write(body);
                }
                req.end();
            }, SIMULATED_WRITE_DELAY);
        });
    }
    /**
     * Send a simulated GET request
     *
     * @since 0.1.0
     */
    async get(url, options = {}) {
        return this.request(Object.assign(options, { url, method: 'GET' }));
    }
    /**
     * Send a simulated HEAD request
     *
     * @since 0.1.0
     */
    async head(url, options = {}) {
        return this.request(Object.assign(options, { url, method: 'HEAD' }));
    }
    /**
     * Send a simulated DELETE request
     *
     * @since 0.1.0
     */
    async delete(url, options = {}) {
        return this.request(Object.assign(options, { url, method: 'DELETE' }));
    }
    /**
     * Send a simulated POST request
     *
     * @since 0.1.0
     */
    async post(url, body, options = {}) {
        return this.request(Object.assign(options, { url, body, method: 'POST' }));
    }
    /**
     * Send a simulated PUT request
     *
     * @since 0.1.0
     */
    async put(url, body, options = {}) {
        return this.request(Object.assign(options, { url, body, method: 'PUT' }));
    }
    /**
     * Send a simulated PATCH request
     *
     * @since 0.1.0
     */
    async patch(url, body, options = {}) {
        return this.request(Object.assign(options, { url, body, method: 'PATCH' }));
    }
    /**
     * Get the current value of a default header
     *
     * @since 0.1.0
     */
    getHeader(name) {
        name = name.toLowerCase();
        return this.headers[name];
    }
    /**
     * Set a default header value
     *
     * @since 0.1.0
     */
    setHeader(name, value) {
        this.headers[name.toLowerCase()] = value;
    }
    /**
     * Remove a default header value
     *
     * @since 0.1.0
     */
    removeHeader(name) {
        delete this.headers[name.toLowerCase()];
    }
    /**
     * Lookup an entry in the test application container
     *
     * @since 0.1.0
     */
    lookup(name) {
        return this.container.lookup(name);
    }
    /**
     * Overwrite an entry in the test application container. Use `restore()` to
     * restore the original container entry later.
     *
     * @since 0.1.0
     */
    inject(name, value, options) {
        this._injections[name] = this.container.lookup(name);
        this.container.register(name, value, options);
        this.container.clearCache(name);
    }
    /**
     * Restore the original container entry for an entry that was previously
     * overwritten by `inject()`
     *
     * @since 0.1.0
     */
    restore(name) {
        this.container.register(name, this._injections[name]);
        delete this._injections[name];
    }
    /**
     * Shut down the test application, cleaning up any resources in use
     *
     * @since 0.1.0
     */
    async shutdown() {
        await this.application.shutdown();
    }
}
exports.AcceptanceTest = AcceptanceTest;
exports.default = AcceptanceTest.setupTest.bind(AcceptanceTest);

});



// lib/test/mock-request.js
//========================================

loader.add('/lib/test/mock-request.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const stream_1 = require("stream");
const url = require("url");
const net_1 = require("net");
const lodash_1 = require("lodash");
/**
 * A mock request used to simluate an HTTP request to the application during
 * tests. You shouldn't need to instantiate these directly - instead, use an
 * AppAcceptance test.
 *
 * @package test
 */
class MockRequest extends stream_1.PassThrough {
    constructor(options = {}) {
        super();
        this.httpVersion = '1.1';
        this.headers = {};
        this.method = 'GET';
        this.url = '/';
        this.trailers = {};
        this.readable = true;
        this.method = options.method || this.method;
        let parsedUrl = url.parse(options.url || this.url);
        this.url = parsedUrl.path;
        if (options.headers) {
            this.headers = lodash_1.mapKeys(options.headers, (value, key) => key.toLowerCase());
        }
        if (options.trailers) {
            this.trailers = lodash_1.mapKeys(options.trailers, (value, key) => key.toLowerCase());
        }
        this.httpVersion = options.httpVersion || this.httpVersion;
        this.connection = new net_1.Socket();
        Object.defineProperty(this.connection, 'remoteAddress', {
            value: '192.168.1.1'
        });
        Object.defineProperty(this.connection, 'encrypted', {
            get: () => {
                return parsedUrl.protocol === 'https:';
            }
        });
        let json = options.json;
        if (json) {
            options.body = JSON.stringify(options.json);
            this.headers['content-type'] = this.headers['content-type'] || 'application/json';
        }
        let body = options.body;
        if (body) {
            if (isReadableStream(body)) {
                body.pipe(this);
            }
            else {
                if (!this.headers['content-length']) {
                    this.headers['content-length'] = String(body.length);
                }
                this.write(body);
                this.end();
            }
        }
    }
    get httpVersionMajor() {
        return Number(this.httpVersion.split('.')[0]);
    }
    get httpVersionMinor() {
        return Number(this.httpVersion.split('.')[1]);
    }
    get socket() {
        return this.connection;
    }
    get rawHeaders() {
        return lodash_1.flatMapDeep(this.headers, (value, name) => {
            if (Array.isArray(value)) {
                return value.map((v) => [name, v]);
            }
            return [name, value];
        });
    }
    get rawTrailers() {
        return lodash_1.flatten(lodash_1.toPairs(this.trailers));
    }
    setTimeout(msecs, callback) {
        return this;
    }
    destroy() {
        // noop
    }
}
exports.default = MockRequest;
function isReadableStream(stream) {
    return typeof stream.pipe === 'function';
}

});



// lib/test/mock-response.js
//========================================

loader.add('/lib/test/mock-response.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const stream_1 = require("stream");
const net_1 = require("net");
const http_1 = require("http");
/**
 * A mock response used to simluate the server response to mock requests during
 * tests. You shouldn't need to instantiate these directly - instead, use an
 * AppAcceptance test.
 *
 * @package test
 */
// tslint:disable:completed-docs member-access
class MockResponse extends stream_1.Writable {
    constructor(callback) {
        super();
        this._headers = {};
        // Settings
        this.upgrading = false;
        this.chunkedEncoding = false;
        this.shouldKeepAlive = false;
        this.useChunkedEncodingByDefault = false;
        this.sendDate = true;
        // Response state
        this.finished = false;
        this.headersSent = false;
        this.connection = new net_1.Socket();
        this._body = '';
        this.on('finish', () => {
            try {
                this._json = JSON.parse(this._body);
            }
            catch (e) { }
            if (callback) {
                callback({ status: this.statusCode, body: this._body, json: this._json });
            }
        });
    }
    get statusMessage() {
        return this._customStatusMessage || http_1.STATUS_CODES[this.statusCode];
    }
    write(chunk, encoding, cb) {
        if (Buffer.isBuffer(chunk)) {
            chunk = chunk.toString();
        }
        this._body += chunk;
        if (cb) {
            setImmediate(cb);
        }
        return true;
    }
    // Outgoing Message interface
    _implicitHeader() { }
    setHeader(name, value) {
        this._headers[name] = value;
    }
    getHeader(name) {
        return this._headers[name];
    }
    getHeaders() {
        return this._headers;
    }
    getHeaderNames() {
        return Object.keys(this._headers);
    }
    hasHeader(name) {
        return Boolean(this._headers[name]);
    }
    removeHeader(name) {
        delete this._headers[name];
    }
    addTrailers(headers) {
        throw new Error('Trailing headers are not supported on requests without chunked encoding, and MockResponse does not support chunked encoding yet.');
    }
    flushHeaders() { }
    writeHead(statusCode, statusMessage, headers) {
        this.statusCode = statusCode;
        if (typeof statusMessage === 'string') {
            this._customStatusMessage = statusMessage;
            Object.assign(this._headers, headers);
        }
        else {
            Object.assign(this._headers, statusMessage);
        }
    }
    writeContinue() { }
    assignSocket(socket) { }
    detachSocket(socket) { }
    setTimeout(msecs, callback) {
        this.connection.setTimeout(msecs, callback);
        return this;
    }
}
exports.default = MockResponse;

});



// lib/test/unit-test.js
//========================================

loader.add('/lib/test/unit-test.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const bluebird_1 = require("bluebird");
const lodash_1 = require("lodash");
/**
 * The AppUnitTest class represents an app unit test. Loads up the bundle and
 * lookups up the module under test. The bundle allows for multiple concurrent
 * tests while ensuring state is not shared across them.
 *
 * @package test
 * @since 0.1.0
 */
class UnitTest {
    constructor(_subject, overrideConfig, options = {}) {
        this._subject = _subject;
        this.overrideConfig = overrideConfig;
        this.originalContainerValues = {};
        // Fetch the container for this unit test file (added during the build process)
        this.container = global.unitTestBundleContainer;
        // If the subject is pulled from the container, make sure we preserve it's value
        if (typeof _subject === 'string') {
            overrideConfig[_subject] = true;
        }
        this.applyContainerOverrideConfig(overrideConfig, options.clearContainer);
    }
    /**
     * A helper method for setting up an app unit test. Adds beforeEach/afterEach
     * hooks to the ava test suite which will setup and teardown the unit test.
     * They also setup a test transaction and roll it back once the test is
     * finished (for the ORM adapters that support it), so your test data won't
     * pollute the database.
     *
     * It returns the Ava test interface, but it enforces serial execution. For
     * more details, check out
     * https://gist.github.com/davewasmer/cd8ac4fad5502e9ce5c8055b283f08cb
     *
     * @since 0.1.0
     */
    static setupTest(subject = () => null, overrides = {}, options = {}) {
        let ava = require('ava');
        let unitTest = new this(subject, overrides, options);
        ava.beforeEach(async (t) => await unitTest.setup(t.context));
        ava.afterEach.always(async (t) => await unitTest.teardown());
        return ava.serial;
    }
    async setup(context) {
        // Setup the container with the "allowed world" for this test suite
        lodash_1.forEach(this.startingContainerValues, (value, specifier) => {
            this.container.register(specifier, value);
        });
        // Some shortcuts on the context object
        context.unit = this;
        context.container = this.container;
        context.subject = this.subject.bind(this);
        context.inject = this.inject.bind(this);
        context.restore = this.restore.bind(this);
        context.lookup = this.container.lookup.bind(this.container);
        // Start any database transactions we can
        await this.startTestTransactions();
    }
    /**
     * Takes the supplied override config, and updates the bundle container to
     * match it.
     *
     * @param overrideConfig Container overrides that should be used for this
     * test (see ContainerOverrideConfig)
     */
    applyContainerOverrideConfig(overrideConfig, clearContainer) {
        // Before we potentially wipe the container, grab any "passthrough" entries
        // allowed by the config
        this.startingContainerValues = lodash_1.mapValues(overrideConfig, (config, key) => {
            return config === true ? this.container.lookup(key, { raw: true, loose: true }) : config;
        });
        if (clearContainer !== false) {
            this.container.clear();
        }
    }
    /**
     * Returns the subject of the test. Follows container lookup rules, i.e. if
     * the entry under test is a singleton, will return the singleton instance,
     * not the class.
     *
     * @since 0.1.0
     */
    subject() {
        if (typeof this._subject === 'string') {
            return this.container.lookup(this._subject);
        }
        return this._subject();
    }
    inject(nameOrInjections, value, options) {
        let injections;
        if (typeof nameOrInjections === 'string') {
            let name = nameOrInjections;
            injections = { [name]: { value, options } };
        }
        else {
            injections = lodash_1.mapValues(nameOrInjections, (value) => ({ value }));
        }
        lodash_1.forEach(injections, ({ value, options }, specifier) => {
            this.originalContainerValues[specifier] = this.container.lookup(specifier, { raw: true, loose: true });
            this.container.register(specifier, value, options);
            this.container.clearCache(specifier);
        });
    }
    /**
     * Restore the original container entry for an entry that was previously
     * overwritten by `inject()`. If no arguments are supplied, all injections
     * are restored.
     *
     * @since 0.1.0
     */
    restore(...specifiers) {
        if (specifiers.length === 0) {
            specifiers = Object.keys(this.originalContainerValues);
        }
        specifiers.forEach((specifier) => {
            this.container.clearCache(specifier);
            let originalValue = this.originalContainerValues[specifier];
            if (originalValue != null) {
                this.container.register(specifier, originalValue);
            }
            delete this.originalContainerValues[specifier];
        });
    }
    /**
     * Lookup all the ORM adapters, and give each one a chance to start a
     * transaction that will wrap a test, and be rolled back after
     */
    async startTestTransactions() {
        let adapters = this.container.lookupAll('orm-adapter');
        let transactionInitializers = [];
        lodash_1.forEach(adapters, (Adapter) => {
            if (typeof Adapter.startTestTransaction === 'function') {
                transactionInitializers.push(Adapter.startTestTransaction());
            }
        });
        await bluebird_1.all(transactionInitializers);
    }
    /**
     * Roll back any test transactions started at the beginning of the test
     */
    async rollbackTestTransactions() {
        let transactionRollbacks = [];
        let adapters = this.container.lookupAll('orm-adapter');
        lodash_1.forEach(adapters, (Adapter) => {
            if (typeof Adapter.rollbackTestTransaction === 'function') {
                transactionRollbacks.push(Adapter.rollbackTestTransaction());
            }
        });
        await bluebird_1.all(transactionRollbacks);
    }
    async teardown() {
        this.container.clear();
        await this.rollbackTestTransactions();
    }
}
exports.UnitTest = UnitTest;
exports.default = UnitTest.setupTest.bind(UnitTest);

});



// lib/utils/json-api.js
//========================================

loader.add('/lib/utils/json-api.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });

});



// lib/utils/result.js
//========================================

loader.add('/lib/utils/result.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
function result(valueOrFn, ...args) {
    if (typeof valueOrFn === 'function') {
        return valueOrFn(...args);
    }
    else {
        return valueOrFn;
    }
}
exports.default = result;

});



// lib/utils/rewrap.js
//========================================

loader.add('/lib/utils/rewrap.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const denali_cli_1 = require("denali-cli");
const wrap = require("wordwrap");
/**
 * Take the tagged string and change the word wrapping to 100 columns (or the width of the terminal
 * window, if smaller). Useful for writing paragraphs of text that should wrap in the source code,
 * but may need to wrap to a different width when printed out to the terminal.
 *
 * @package util
 */
function rewrap(strings, ...expressions) {
    let text = denali_cli_1.unwrap(strings, ...expressions);
    text = wrap(text, Math.min(100, process.stdout.columns));
    return text;
}
exports.default = rewrap;

});



// lib/utils/set-if-not-empty.js
//========================================

loader.add('/lib/utils/set-if-not-empty.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const lodash_1 = require("lodash");
function setIfNotEmpty(obj, key, value) {
    if (lodash_1.isArray(value) || !lodash_1.isEmpty(value)) {
        lodash_1.set(obj, key, value);
    }
}
exports.default = setIfNotEmpty;

});



// lib/utils/strings.js
//========================================

loader.add('/lib/utils/strings.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const dedent = require("dedent-js");
const util_1 = require("util");
exports.default = {
    ////////////
    // Errors //
    ////////////
    ContainerEntryNotFound(specifier, registryEntries, resolverNames) {
        let registrationsOverview;
        if (registryEntries.length > 0) {
            registrationsOverview = dedent `
        Available manual registrations (via container.register(...)):
          - ${registryEntries.join('\n  - ')}
      `;
        }
        else {
            registrationsOverview = dedent `
        There were no manually registered entries in the container.
      `;
        }
        let resolversOverview;
        if (resolverNames.length > 0) {
            resolversOverview = dedent `
        Available resolvers:
          - ${resolverNames.join('\n  - ')}
      `;
        }
        else {
            resolversOverview = dedent `
        There were no resolvers available in the container.
      `;
        }
        return dedent `
      You tried to lookup a container entry under ${specifier}, but the
      container has no such entry.

      ${registrationsOverview}

      ${resolversOverview}

      Run with DEBUG=verbose-denali:resolver:<resolver name> to trace a specific
      resolver's resolution
    `;
    },
    ContainerEntryNotAConstructor(specifier, value) {
        let str = dedent `
      You flagged ${specifier} as a singleton, so the container expected to
      a constructor function under that entry.
    `;
        if (value === undefined) {
            str += dedent `
        Instead it found 'undefined'. Did you forget to add 'export default'
        to a file?
      `;
        }
        else {
            str += dedent `
        Instead it found:

        ${util_1.inspect(value)}
      `;
        }
        return str;
    }
};

});



// lib/utils/topsort.js
//========================================

loader.add('/lib/utils/topsort.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const dag_map_1 = require("dag-map");
/**
 * Take an array of vertices (objects with a name, value, and optional before / after), create a
 * directed acyclic graph of them, and return the vertex values in a sorted array.
 *
 * @package util
 */
function topsort(items, options = {}) {
    let graph = new dag_map_1.default();
    items.forEach((item) => {
        let value = options.valueKey ? item[options.valueKey] : item;
        graph.add(item.name, value, item.before, item.after);
    });
    let sorted = [];
    graph.topsort((key, value) => {
        sorted.push(value);
    });
    return sorted;
}
exports.default = topsort;

});



// lib/utils/types.js
//========================================

loader.add('/lib/utils/types.js', {"isMain":false}, function(module, exports, require, __dirname, __filename) {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });

});



  });
})();

//# sourceMappingURL=denali.fragment.map