Q:

StandardJs + ES6 extended class - Useless constructor?

This is my model class:
'use strict'

import MongoDb from 'database/mongodb'

export default class Model {
  constructor (options) {
    this.data = this.sanitize(options)
  }

  objectId (_id) {
    // https://stackoverflow.com/questions/17545311/correct-way-to-search-for-mongodb-entries-by-id-in-node
    const mongodb = new MongoDb()
    const objectId = mongodb.objectId
    return objectId(_id)
  }

  async db () {
    const mongodb = new MongoDb()
    const connection = await mongodb.connect()
    return connection
  }

  sanitize (options) {
    return options
  }

  async insert (options) {
    //
  }

  async find (options) {
    //
  }

  async remove (options) {
    //
  }
}

And I have a user class extends from it:
'use strict'

import lodash from 'lodash'
import Model from 'model'
import schemas from './schemas'

export default class User extends Model {
  constructor (options) {
    super(options)
  }

  sanitize (options) {
    let data = options || {}
    let schema = schemas.user
    let keys = lodash.keys(schema)
    let defaults = lodash.defaults(data, schema)
    let picked = lodash.pick(defaults, keys)    
    return picked
  }
  ...
  ...
}

But according to standardjs:
standard: Use JavaScript Standard Style (https://standardjs.com)
  /var/www/html/.../user/models/user.js:8:3: Useless constructor.

Why my constructor is Useless?
From what I understand, I must use super() in my extended class even though I don't quite fully understand it yet. Did I use it wrong?
Any ideas?
EDIT:
If I omit the constructor in the extended class, I will get this error:
Syntax Error: missing super() call in constructor

A:

  constructor (...args) {
    super(...args);
  }

will be default constructor in extended class when constructor is omitted. That's why it was marked as 'useless'.
super should be specified in extended class only when there is constructor, and constructor should be specified only when there should be some logic besides calling parent constructor with exact same arguments.

