@depup/bookshelf 1.2.0-depup.0

package/lib/base/collection.js

@@ -0,0 +1,802 @@
+// Base Collection
+// ---------------
+'use strict';
+
+const _ = require('lodash');
+const inherits = require('util').inherits;
+
+const Events = require('./events');
+const Promise = require('bluebird');
+const ModelBase = require('./model');
+const extend = require('../extend');
+
+// List of attributes attached directly from the constructor's options object.
+//
+// RE: 'relatedData'
+// It's okay for two `Collection`s to share a `Relation` instance.
+// `relatedData` does not mutate itself after declaration. This is only
+// here because `clone` needs to duplicate this property. It should not
+// be documented as a valid argument for consumer code.
+//
+// RE: 'attach', 'detach', 'updatePivot', 'withPivot', '_processPivot', '_processPlainPivot', '_processModelPivot'
+// It's okay to whitelist also given method references to be copied when cloning
+// a collection. These methods are present only when `relatedData` is present and
+// its `type` is 'belongsToMany'. So it is safe to put them in the list and use them
+// without any additional verification.
+// These should not be documented as a valid arguments for consumer code.
+const collectionProps = [
+  'model',
+  'comparator',
+  'relatedData',
+  // `belongsToMany` pivotal collection properties
+  'attach',
+  'detach',
+  'updatePivot',
+  'withPivot',
+  '_processPivot',
+  '_processPlainPivot',
+  '_processModelPivot'
+];
+
+/**
+ * @class CollectionBase
+ * @extends Events
+ * @inheritdoc
+ */
+function CollectionBase(models, options) {
+  if (options) _.extend(this, _.pick(options, collectionProps));
+  this._reset();
+  this.initialize.apply(this, arguments);
+  if (!_.isFunction(this.model)) {
+    throw new Error('A valid `model` constructor must be defined for all collections.');
+  }
+  if (models) this.reset(models, _.extend({silent: true}, options));
+}
+
+/**
+ * Registers an event listener.
+ *
+ * @method CollectionBase#on
+ * @example
+ * const ships = new bookshelf.Collection
+ * ships.on('fetched', function(collection) {
+ *   // Do something after the data has been fetched from the database
+ * })
+ * @see Events#on
+ */
+
+/**
+ * @method CollectionBase#off
+ * @example
+ *
+ * ships.off('fetched') // Remove the 'fetched' event listener
+ *
+ * @see Events#off
+ */
+
+/**
+ * @method CollectionBase#trigger
+ * @example
+ *
+ * ships.trigger('fetched')
+ *
+ * @see Events#trigger
+ */
+inherits(CollectionBase, Events);
+
+// Copied over from Backbone.
+const setOptions = {add: true, remove: true, merge: true};
+const addOptions = {add: true, remove: false};
+
+/**
+ * @member {Number}
+ * @default 0
+ * @description
+ *
+ * This is the total number of models in the collection. Note that this may not represent how many
+ * models there are in total in the database.
+ *
+ * @example
+ *
+ * var vanHalen = new bookshelf.Collection([eddie, alex, stone, roth]);
+ * console.log(vanHalen.length) // 4
+ */
+CollectionBase.prototype.length = 0;
+
+/**
+ * @method CollectionBase#initialize
+ * @description
+ * Called by the {@link Collection Collection constructor} when creating a new instance.
+ * Override this function to add custom initialization, such as event listeners.
+ * Because plugins may override this method in subclasses, make sure to call
+ * your super (extended) class. e.g.
+ *
+ *     initialize: function() {
+ *       this.constructor.__super__.initialize.apply(this, arguments);
+ *       // Your initialization code ...
+ *     }
+ *
+ * @see Collection
+ */
+CollectionBase.prototype.initialize = function() {};
+
+/**
+ * @method
+ * @private
+ * @description
+ * The `tableName` on the associated Model, used in relation building.
+ * @returns {string} The {@link Model#tableName tableName} of the associated model.
+ */
+CollectionBase.prototype.tableName = function() {
+  return _.result(this.model.prototype, 'tableName');
+};
+
+/**
+ * Returns the first model in the collection or `undefined` if the collection is empty.
+ *
+ * @return {Model|undefined} The first model or `undefined`.
+ */
+CollectionBase.prototype.first = function() {
+  return this.at(0);
+};
+
+/**
+ * Returns the last model in the collection or `undefined` if the collection is empty.
+ *
+ * @return {Model|undefined} The last model or `undefined`.
+ */
+CollectionBase.prototype.last = function() {
+  return this.slice(-1)[0];
+};
+
+/**
+ * @method
+ * @private
+ * @description
+ * The `idAttribute` on the associated Model, used in relation building.
+ * @returns {string} The {@link Model#idAttribute idAttribute} of the associated model.
+ */
+CollectionBase.prototype.idAttribute = function() {
+  return this.model.prototype.idAttribute;
+};
+
+/**
+ * @method
+ * @private
+ * @description
+ * When keying a collection by ID, ensure that it is safe to use as a key
+ * @param {any} id
+ * @return {string|number} The id safe for using as a key in a collection
+ */
+CollectionBase.prototype.idKey = function(id) {
+  return _.isBuffer(id) ? id.toString('hex') : id;
+};
+
+CollectionBase.prototype.toString = function() {
+  return '[Object Collection]';
+};
+
+/**
+ * @method
+ * @description
+ *
+ * Return a raw array of the collection's {@link Model#attributes
+ * attributes} for JSON stringification. If the {@link Model models} have any
+ * relations defined, this will also call {@link Model#toJSON toJSON} on
+ * each of the related objects, and include them on the object unless
+ * `{shallow: true}` is passed as an option.
+ *
+ * `serialize` is called internally by {@link Collection#toJSON toJSON}.
+ * Override this function if you want to customize its output.
+ *
+ * @param {Object=} options
+ * @param {Boolean}    [options.shallow=false]   Exclude relations.
+ * @param {Boolean}    [options.omitPivot=false] Exclude pivot values.
+ * @param {Boolean}    [options.omitNew=false]   Exclude models that return true for isNew.
+ * @returns {Object} Serialized model as a plain object.
+ */
+CollectionBase.prototype.serialize = function(options) {
+  return this.invokeMap('toJSON', options).filter(_.negate(_.isNull));
+};
+
+/**
+ * @method
+ * @description
+ *
+ * Called automatically by {@link
+ * https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#toJSON()_behavior
+ * `JSON.stringify`}. To customize serialization, override {@link
+ * Collection#serialize serialize}.
+ *
+ * @param {options} Options passed to {@link Collection#serialize}.
+ */
+CollectionBase.prototype.toJSON = function(options) {
+  return this.serialize(options);
+};
+
+/**
+ * @method
+ * @description
+ *
+ * The set method performs a smart update of the collection with the passed
+ * model or list of models by following the following rules:
+ * - If a model in the list isn't yet in the collection it will be added
+ * - if the model is already in the collection its attributes will be merged
+ * - if the collection contains any models that aren't present in the list,
+ * they'll be removed.
+ *
+ * If you'd like to customize the behavior, you can do so with the `add`,
+ * `merge` and `remove` options.
+ *
+ * Since version 0.14.0 if both `remove` and `merge` options are set to
+ * `false`, then any duplicate models present will be added to the collection,
+ * otherwise they will either be removed or merged, according to the chosen
+ * option.
+ *
+ * @example
+ *
+ * var vanHalen = new bookshelf.Collection([eddie, alex, stone, roth]);
+ * vanHalen.set([eddie, alex, stone, hagar]);
+ *
+ * @param {Object[]|Model[]|Object|Model} models One or more models or raw
+ * attribute objects.
+ * @param {Object=} options
+ *   Options for controlling how models are added or removed.
+ * @param {Boolean=} options.add=true
+ *   If set to `true` it will add any new models to the collection, otherwise
+ *   any new models will be ignored.
+ * @param {Boolean=} options.merge=true
+ *   If set to `true` it will merge the attributes of duplicate models with the
+ *   attributes of existing models in the collection, otherwise duplicate
+ *   models in the list will be ignored.
+ * @param {Boolean=} options.remove=true
+ *   If set to `true` any models in the collection that are not in the list
+ *   will be removed from the collection, otherwise they will be kept.
+ * @returns {Collection} Self, this method is chainable.
+ */
+CollectionBase.prototype.set = function(models, options) {
+  options = _.defaults({}, options, setOptions);
+  if (!Array.isArray(models)) models = models ? [models] : [];
+  if (options.parse) models = this.parse(models, options);
+  let i, l, id, model, attrs;
+  const at = options.at;
+  const targetModel = this.model;
+  const toAdd = [];
+  const toRemove = [];
+  const modelMap = {};
+  let order = options.add && options.remove ? [] : false;
+
+  // Turn bare objects into model references, and prevent invalid models
+  // from being added.
+  for (i = 0, l = models.length; i < l; i++) {
+    attrs = models[i];
+    if (attrs instanceof ModelBase) {
+      id = model = attrs;
+    } else {
+      id = attrs[targetModel.prototype.idAttribute];
+    }
+
+    // If a duplicate is found, prevent it from being added and
+    // optionally merge it into the existing model.
+    const existing = this.get(id);
+    if (existing && (options.merge || options.remove)) {
+      if (options.remove) {
+        modelMap[existing.cid] = true;
+      }
+      if (options.merge) {
+        attrs = attrs === model ? model.attributes : attrs;
+        if (options.parse) attrs = existing.parse(attrs, options);
+        existing.set(attrs, options);
+      }
+
+      // This is a new model, push it to the `toAdd` list.
+    } else if (options.add) {
+      if (!(model = this._prepareModel(attrs, options))) continue;
+      toAdd.push(model);
+      this._byId[this.idKey(model.cid)] = model;
+      if (model.id != null) this._byId[this.idKey(model.id)] = model;
+    }
+
+    if (order && !(existing && order.indexOf(existing) > -1)) order.push(existing || model);
+  }
+
+  // Remove nonexistent models if appropriate.
+  if (options.remove) {
+    for (i = 0, l = this.length; i < l; ++i) {
+      if (!modelMap[(model = this.models[i]).cid]) toRemove.push(model);
+    }
+    if (toRemove.length) this.remove(toRemove, options);
+  }
+
+  // See if sorting is needed, update `length` and splice in new models.
+  if (toAdd.length || (order && order.length)) {
+    this.length += toAdd.length;
+    if (at != null) {
+      Array.prototype.splice.apply(this.models, [at, 0].concat(toAdd));
+    } else {
+      if (order) {
+        this.models.length = 0;
+      } else {
+        order = toAdd;
+      }
+      for (i = 0, l = order.length; i < l; ++i) {
+        this.models.push(order[i]);
+      }
+    }
+  }
+
+  if (options.silent) return this;
+
+  // Trigger `add` events.
+  for (i = 0, l = toAdd.length; i < l; i++) {
+    (model = toAdd[i]).trigger('add', model, this, options);
+  }
+  return this;
+};
+
+/**
+ * @method
+ * @private
+ * @description
+ * Prepare a model or hash of attributes to be added to this collection.
+ */
+CollectionBase.prototype._prepareModel = function(attrs, options) {
+  if (attrs instanceof ModelBase) return attrs;
+  return new this.model(attrs, options);
+};
+
+/**
+ * @method
+ * @private
+ * @description
+ * Run "Promise.map" over the models
+ */
+CollectionBase.prototype.mapThen = function(iterator, context) {
+  return Promise.bind(context)
+    .thenReturn(this.models)
+    .map(iterator);
+};
+
+/**
+ * @method
+ * @description
+ * Shortcut for calling `Promise.all` around a {@link Collection#invoke}, this
+ * will delegate to the collection's `invoke` method, resolving the promise with
+ * an array of responses all async (and sync) behavior has settled. Useful for
+ * bulk saving or deleting models:
+ *
+ *     collection.invokeThen('save', null, options).then(function() {
+ *       // ... all models in the collection have been saved
+ *     });
+ *
+ *     collection.invokeThen('destroy', options).then(function() {
+ *       // ... all models in the collection have been destroyed
+ *     });
+ *
+ * @param {string} method The {@link Model model} method to invoke.
+ * @param {...mixed} arguments Arguments to `method`.
+ * @returns {Promise<mixed[]>}
+ *   Promise resolving to array of results from invocation.
+ */
+CollectionBase.prototype.invokeThen = function() {
+  return Promise.all(this.invokeMap.apply(this, arguments));
+};
+
+/**
+ * This iterator is used by the reduceThen method to ietrate over all models in the collection.
+ *
+ * @callback Collection~reduceThenIterator
+ * @param {mixed} acumulator
+ * @param {Model} model The current model being iterated over.
+ * @param {Number} index
+ * @param {Number} length Total number of models being iterated over.
+ */
+
+/**
+ * @method
+ * @description
+ * Iterate over all the models in the collection and reduce this array to a single value using the
+ * given iterator function.
+ * @see {@link http://bluebirdjs.com/docs/api/promise.reduce.html|Bluebird `Promise.reduce` reference}.
+ * @param {Collection~reduceThenIterator} iterator
+ * @param {mixed} initialValue
+ * @param {Object} context Bound to `this` in the `iterator` callback.
+ * @returns {Promise<mixed>}
+ *   Promise resolving to the single result from the reduction.
+ *
+ */
+CollectionBase.prototype.reduceThen = function(iterator, initialValue, context) {
+  return Promise.bind(context)
+    .thenReturn(this.models)
+    .reduce(iterator, initialValue)
+    .bind();
+};
+
+CollectionBase.prototype.fetch = function() {
+  return Promise.rejected('The fetch method has not been implemented');
+};
+
+/**
+ * @method
+ * @description
+ *
+ * Add a {@link Model model}, or an array of models, to the collection. You may
+ * also pass raw attribute objects, which will be converted to proper models
+ * when being added to the collection.
+ *
+ * You can pass the `{at: index}` option to splice the model into the
+ * collection at the specified `index`.
+ *
+ * By default if you're adding models to the collection that are already
+ * present, they'll be ignored, unless you pass `{merge: true}`, in
+ * which case their {@link Model#attributes attributes} will be merged with the
+ * corresponding models.
+ *
+ * @example
+ *
+ * const ships = new bookshelf.Collection;
+ *
+ * ships.add([
+ *   {name: "Flying Dutchman"},
+ *   {name: "Black Pearl"}
+ * ]);
+ *
+ * @param {Object[]|Model[]|Object|Model} models
+ *   One or more models or raw attribute objects.
+ * @param {Object=} options Options for controlling how models are added.
+ * @param {Boolean=} options.merge=false
+ *   If set to `true` it will merge the attributes of duplicate models with the
+ *   attributes of existing models in the collection.
+ * @param {Number=} options.at
+ *   If set to a number equal to or greater than 0 it will splice the model
+ *   into the collection at the specified index number.
+ * @returns {Collection} Self, this method is chainable.
+ */
+CollectionBase.prototype.add = function(models, options) {
+  return this.set(models, Object.assign({merge: false}, options, addOptions));
+};
+
+/**
+ * Remove a {@link Model model}, or an array of models, from the collection. Note that this does not remove the affected
+ * models from the database. For that purpose you have to use the model's {@link Model#destroy destroy} method.
+ *
+ * If you wish to actually remove all the models in a collection from the database you can use this method:
+ *
+ *     myCollection.invokeThen('destroy').then(() => {
+ *       // models have been destroyed
+ *     })
+ *
+ * @param {Model|Model[]} models The model, or models, to be removed.
+ * @param {Object} [options] Set of options for the operation.
+ * @param {Boolean} [options.silent] If set to `true` will not trigger a `remove` event on the removed model.
+ * @returns {Model|Model[]} The same value passed in the `models` argument.
+ */
+CollectionBase.prototype.remove = function(models, options) {
+  const singular = !Array.isArray(models);
+  models = singular ? [models] : _.clone(models);
+  options = options || {};
+  for (let i = 0; i < models.length; i++) {
+    const model = (models[i] = this.get(models[i]));
+    if (!model) continue;
+    delete this._byId[this.idKey(model.id)];
+    delete this._byId[model.cid];
+    const index = this.models.indexOf(model);
+    this.models.splice(index, 1);
+    this.length = this.length - 1;
+    if (!options.silent) {
+      options.index = index;
+      model.trigger('remove', model, this, options);
+    }
+  }
+  return singular ? models[0] : models;
+};
+
+/**
+ * @method
+ * @description
+ *
+ * Adding and removing models one at a time is all well and good, but sometimes
+ * you have so many models to change that you'd rather just update the
+ * collection in bulk. Use `reset` to replace a collection with a new list of
+ * models (or attribute hashes). Calling `collection.reset()` without passing
+ * any models as arguments will empty the entire collection.
+ *
+ * @param {Object[]|Model[]|Object|Model} models One or more models or raw
+ * attribute objects.
+ * @param {Object} options See {@link Collection#add add}.
+ * @returns {Model[]} Array of models.
+ */
+CollectionBase.prototype.reset = function(models, options) {
+  options = options || {};
+  options.previousModels = this.models;
+  this._reset();
+  models = this.set(models, Object.assign({silent: true}, options));
+  if (!options.silent) this.trigger('reset', this, options);
+  return models;
+};
+
+/**
+ * @method
+ * @description
+ * Add a model to the end of the collection.
+ * @param {Object[]|Model[]|Object|Model} model One or more models or raw
+ * attribute objects.
+ * @returns {Collection} Self, this method is chainable.
+ */
+CollectionBase.prototype.push = function(model, options) {
+  return this.add(model, _.extend({at: this.length}, options));
+};
+
+/**
+ * @method
+ * @description
+ * Remove a model from the end of the collection.
+ */
+CollectionBase.prototype.pop = function(options) {
+  const model = this.at(this.length - 1);
+  this.remove(model, options);
+  return model;
+};
+
+/**
+ * @method
+ * @description
+ * Add a model to the beginning of the collection.
+ */
+CollectionBase.prototype.unshift = function(model, options) {
+  return this.add(model, _.extend({at: 0}, options));
+};
+
+/**
+ * @method
+ * @description
+ * Remove a model from the beginning of the collection.
+ */
+CollectionBase.prototype.shift = function(options) {
+  const model = this.at(0);
+  this.remove(model, options);
+  return model;
+};
+
+/**
+ * @method
+ * @description
+ * Slice out a sub-array of models from the collection.
+ */
+CollectionBase.prototype.slice = function() {
+  return Array.prototype.slice.apply(this.models, arguments);
+};
+
+/**
+ * @method
+ * @description
+ *
+ * Get a model from a collection, specified by an {@link Model#id id}, a {@link
+ * Model#cid cid}, or by passing in a {@link Model model}.
+ *
+ * @example
+ *
+ * const book = library.get(110);
+ *
+ * @returns {Model} The model, or `undefined` if it is not in the collection.
+ */
+CollectionBase.prototype.get = function(obj) {
+  if (obj == null) return void 0;
+  return this._byId[this.idKey(obj.id)] || this._byId[obj.cid] || this._byId[this.idKey(obj)];
+};
+
+/**
+ * @method
+ * @description
+ * Get a model from a collection, specified by index. Useful if your collection
+ * is sorted, and if your collection isn't sorted, `at` will still retrieve
+ * models in insertion order.
+ */
+CollectionBase.prototype.at = function(index) {
+  return this.models[index];
+};
+
+/**
+ * @method
+ * @private
+ * @description
+ * Force the collection to re-sort itself, based on a comporator defined on the model.
+ */
+CollectionBase.prototype.sort = function(options) {
+  if (!this.comparator) throw new Error('Cannot sort a set without a comparator');
+  options = options || {};
+
+  // Run sort based on type of `comparator`.
+  if (_.isString(this.comparator) || this.comparator.length === 1) {
+    this.models = this.sortBy(this.comparator, this);
+  } else {
+    this.models.sort(_.bind(this.comparator, this));
+  }
+
+  if (!options.silent) this.trigger('sort', this, options);
+  return this;
+};
+
+/**
+ * @method
+ * @description
+ * Pluck an attribute from each model in the collection.
+ * @returns {mixed[]} An array of attribute values.
+ */
+CollectionBase.prototype.pluck = function(attr) {
+  return this.invokeMap('get', attr);
+};
+
+/**
+ * @method
+ * @description
+ * The `parse` method is called whenever a collection's data is returned in a
+ * {@link Collection#fetch fetch} call. The function is passed the raw
+ * database `response` array, and should return an array to be set on the
+ * collection. The default implementation is a no-op, simply passing through
+ * the JSON response.
+ *
+ * @param {Object[]} resp Raw database response array.
+ */
+CollectionBase.prototype.parse = function(resp) {
+  return resp;
+};
+
+/**
+ * @method
+ * @description
+ * Create a new collection with an identical list of models as this one.
+ */
+CollectionBase.prototype.clone = function() {
+  // Iterate over the selected list of collection properties and invoke `clone` for
+  // each property that has a method for that porpose.
+  const clonedProps = _(this)
+    .pick(collectionProps)
+    .mapValues((val) => {
+      return val && typeof val.clone === 'function' ? val.clone() : val;
+    })
+    .value();
+  return new this.constructor(this.models, clonedProps);
+};
+
+/**
+ * @method
+ * @private
+ * @description
+ * Reset all internal state. Called when the collection is first initialized or reset.
+ */
+CollectionBase.prototype._reset = function() {
+  this.length = 0;
+  this.models = [];
+  this._byId = Object.create(null);
+};
+
+// Make collection iterable in for of loops
+CollectionBase.prototype[Symbol.iterator] = function*() {
+  yield* this.models;
+};
+
+/**
+ * @method CollectionBase#forEach
+ * @see http://lodash.com/docs/#forEach
+ */
+/**
+ * @method CollectionBase#map
+ * @see http://lodash.com/docs/#map
+ */
+/**
+ * @method CollectionBase#reduce
+ * @see http://lodash.com/docs/#reduce
+ */
+/**
+ * @method CollectionBase#reduceRight
+ * @see http://lodash.com/docs/#reduceRight
+ */
+/**
+ * @method CollectionBase#find
+ * @see http://lodash.com/docs/#find
+ */
+/**
+ * @method CollectionBase#filter
+ * @see http://lodash.com/docs/#filter
+ */
+/**
+ * @method CollectionBase#reject
+ * @see http://lodash.com/docs/#reject
+ */
+/**
+ * @method CollectionBase#every
+ * @see http://lodash.com/docs/#every
+ */
+/**
+ * @method CollectionBase#some
+ * @see http://lodash.com/docs/#some
+ */
+/**
+ * @method CollectionBase#includes
+ * @see http://lodash.com/docs/#includes
+ */
+/**
+ * @method CollectionBase#invokeMap
+ * @see http://lodash.com/docs/#invokeMap
+ */
+/**
+ * @method CollectionBase#toArray
+ * @see http://lodash.com/docs/#toArray
+ */
+/**
+ * @method CollectionBase#isEmpty
+ * @see http://lodash.com/docs/#isEmpty
+ */
+// Lodash methods that we want to implement on the Collection.
+// 90% of the core usefulness of Backbone Collections is actually implemented
+// right here:
+const methods = [
+  'forEach',
+  'map',
+  'reduce',
+  'reduceRight',
+  'find',
+  'filter',
+  'every',
+  'some',
+  'includes',
+  'invokeMap',
+  'toArray',
+  'isEmpty'
+];
+
+// Mix in each Lodash method as a proxy to `Collection#models`.
+_.each(methods, function(method) {
+  CollectionBase.prototype[method] = function() {
+    return _[method].apply(_, [this.models].concat(Array.from(arguments)));
+  };
+});
+
+/**
+ * @method CollectionBase#groupBy
+ * @see http://lodash.com/docs/#groupBy
+ */
+// Underscore methods that we want to implement on the Collection.
+/**
+ * @method CollectionBase#countBy
+ * @see http://lodash.com/docs/#countBy
+ */
+// Underscore methods that we want to implement on the Collection.
+/**
+ * @method CollectionBase#sortBy
+ * @see http://lodash.com/docs/#sortBy
+ */
+// Lodash methods that take a property name as an argument.
+const attributeMethods = ['groupBy', 'countBy', 'sortBy'];
+
+// Use attributes instead of properties.
+_.each(attributeMethods, function(method) {
+  CollectionBase.prototype[method] = function(value, context) {
+    const iterator = _.isFunction(value)
+      ? value
+      : function(model) {
+          return model.get(value);
+        };
+    return _[method](this.models, _.bind(iterator, context));
+  };
+});
+
+/**
+ * @method Collection.extend
+ * @description
+ *
+ * To create a {@link Collection} class of your own, extend
+ * `Bookshelf.Collection`.
+ *
+ * @param {Object=} prototypeProperties
+ *   Instance methods and properties to be attached to instances of the new
+ *   class.
+ * @param {Object=} classProperties
+ *   Class (ie. static) functions and properties to be attached to the
+ *   constructor of the new class.
+ * @returns {Function} Constructor for new `Collection` subclass.
+ */
+CollectionBase.extend = extend;
+
+module.exports = CollectionBase;