fetchAll(options) {
      const collection = this.all();
      return collection
        .once('fetching', (__, columns, opts) => {
          /**
           * Fired before a {@link Model#fetchAll fetchAll} operation. A promise
           * may be returned from the event handler for async behaviour.
           *
           * @event Model#fetching:collection
           * @tutorial events
           * @param {Collection} collection
           *  The collection that is going to be fetched. At this point it's still empty since the
           *  fetch hasn't happened yet.
           * @param {string[]} columns
           *  The columns to be retrieved by the query as provided by the underlying query builder.
           *  If the `columns` option is not specified the value of this will usually be an array
           *  with a single string `'tableName.*'`.
           * @param {Object} options Options object passed to {@link Model#fetchAll fetchAll}.
           * @returns {Promise}
           */
          return this.triggerThen('fetching:collection', collection, columns, opts);
        })
        .once('fetched', (__, response, opts) => {
          /**
           * Fired after a {@link Model#fetchAll fetchAll} operation. A promise
           * may be returned from the event handler for async behaviour.
           *
           * @event Model#fetched:collection
           * @tutorial events
           * @param {Collection} collection The collection that has been fetched.
           * @param {Object} response
           *  The raw response from the underlying query builder. This will be an array with objects
           *  representing each row, similar to the output of a
           *  {@link Model#serialize serialized Model}.
           * @param {Object} options Options object passed to {@link Model#fetchAll fetchAll}.
           * @returns {Promise}
           */
          return this.triggerThen('fetched:collection', collection, response, opts);
        })
        .fetch(options);
    }
Fetches a collection of {@link Model models} from the database, using any
query parameters currently set on the model to constrain the results.

Returns a Promise that will resolve with the fetched collection. If there
are no results it will resolve with an empty collection. If instead you
wish the Promise to be rejected with a {@link Collection.EmptyError},
pass the `require: true` option.

If you need to constrain the results, you can call the {@link Model#query query}
or {@link Model#where where} methods before calling this method.

@method Model#fetchAll
@param {Object} [options] Set of options to modify the request.
@param {boolean} [options.require=false]
  Whether or not to reject the returned Promise with a {@link Collection.EmptyError} if no records can be
  fetched from the database.
@param {Transaction} [options.transacting] Optionally run the query in a transaction.
@param {boolean} [options.debug=false]
  Whether to enable debugging mode or not. When enabled will show information about the
  queries being run.
@fires Model#fetching:collection
@fires Model#fetched:collection
@throws {Collection.EmptyError}
  This error is used to reject the Promise in the event of an empty response from the
  database in case the `require: true` fetch option is used.
@returns {Promise} A Promise resolving to the fetched {@link Collection collection}.