Exclude column from Query

After more consideration, this is too much of a hack for objection.

Here’s an example plugin that implements the feature using only public interface:

const Metadata = (Model) => {
  class MetadataQueryBuilder extends Model.QueryBuilder {
    constructor(...args) {
      super(...args);

      // Whenever a query builder is created, register a function to be called
      // during it's build phase.
      this.onBuild(builder => {
        // Select all columns except excluded ones, but only if there are no
        // explicit selects.
        if (!builder.hasSelects()) {
          const modelClass = builder.modelClass();
          // The correct table reference. Can be other than the table name
          // for example if an alias is used.
          const table = builder.tableRefFor(modelClass);

          builder.select(modelClass.$$columns
            .filter(col => !builder.$$unselect || !builder.$$unselect.includes(col))
            .map(col => `${table}.${col}`));
        }
      });
    }

    // We need to override `clone` too so that our custom property
    // is cloned too.
    clone(...args) {
      const copy = super.clone(...args);

      if (this.$$unselect) {
        Object.defineProperty(copy, '$$unselect', {
          enumerable: false,
          value: this.$$unselect
        });
      }

      return copy;
    }

    // This is a new query builder method that can be used to exclude columns.
    unselect(columns) {
      // We use `Object.defineProperty` to hide our custom property. 
      // This is not necessary. You could just use `this.$$unselect = something`
      // or even `this.unselected = something`. `$` prefix is just a convention for
      // "internal" properties.
      Object.defineProperty(this, '$$unselect', {
        enumerable: false,
        value: columns
      });

      return this;
    }
  }

  return class extends Model {
    // Register our custom query builder to be used instead of the default one.
    static get QueryBuilder() {
      return MetadataQueryBuilder;
    }

    // An initialization function that fetches the column metadata. This only
    // needs to be called once. `knex` argument is optional and only needed
    // if you haven't given the knex connection using `Model.knex(knex)` or
    // any other supported way.
    static initialize(Models, knex) {
      return Promise.all(Models.map(async (Model) => {
        const columnInfo = await  Model.query(knex).columnInfo();

        // We use `Object.defineProperty` to hide our custom property. 
        // This is not necessary. You could just use `Model.$$columns = something`
        // or even `Model.columns = something`. `$` prefix is just a convention for
        // "internal" properties.
        Object.defineProperty(Model, '$$columns', {
          enumerable: false,
          // Run the properties through `propertyNameToColumnName` to make sure
          // any possible column name conversion (for example snake_case -> camelCase)
          // is done.
          value: Object.keys(columnInfo).map(prop => Model.propertyNameToColumnName(prop))
        });
      }));
    }
  };
}

You would use it like this:

const { Model } = require('objection');

class BaseModel extends Metadata(Model) {

}

...

class Product extends BaseModel {
  ...
}

...

// In some initialization code
await BaseModel.initialize([Product, Foo, Bar, Baz, Spam, All, Your, Models]);

...

// Use it
static findByUUID( uuid ) {
    return this.query().findOne({ uuid }).unselect( [ 'id' ] );
}