sequelize: "result.get is not a function" when querying with global raw: true and includes

Hi guys! I encountered a problem, when trying to do includes. I have already saw a couple of similar issues here, but not equal to mine. The case is simpliest - users and roles. Here are the models:

const UserScheme = require('server/dataAccess/schemes/userScheme');

module.exports = function (sequelize, DataTypes) {
    const UserDataModel = sequelize.define(UserScheme.tableName, UserScheme.columnsDescription, {
        schema: UserScheme.schema
    });

    return UserDataModel;
};

const UserScheme = require('server/dataAccess/schemes/userScheme');
const UserRoleScheme = require('server/dataAccess/schemes/userRoleScheme');
const UserRoleAssociationScheme = require('server/dataAccess/schemes/userRoleAssociationScheme');

module.exports = function (sequelize, DataTypes) {
    const UserRoleDataModel = sequelize.define(UserRoleScheme.tableName, UserRoleScheme.columnsDescription, {
        schema: UserRoleScheme.schema,
        classMethods: {
            associate: models => {
                models[UserRoleScheme.tableName].belongsToMany(models[UserScheme.tableName], {
                    as: 'Users',
                    through: UserRoleAssociationScheme.tableName,
                    foreignKey: {
                        name: UserRoleAssociationScheme.columnsDescription.userRoleId.field
                    }
                });
                models[UserScheme.tableName].belongsToMany(models[UserRoleScheme.tableName], {
                    as: 'Roles',
                    through: UserRoleAssociationScheme.tableName,
                    foreignKey: {
                        name: UserRoleAssociationScheme.columnsDescription.userInfoId.field
                    }
                });
            }
        }
    });

    return UserRoleDataModel;
};

And here are the schemas:

const Sequelize = require('sequelize');

class UserDataScheme extends BaseInternalScheme {
    constructor(dataTypes) {
        super(dataTypes);

        this.defineTable('userInfo');
        this.defineColumns({
            id: {
                type: Sequelize.UUID,
                field: 'id',
                allowNull: false,
                unique: true,
                primaryKey: true
            },
            createdAt: {
                type: Sequelize.DATE,
                field: 'createdAt'
            },
            updatedAt: {
                type: Sequelize.DATE,
                field: 'updatedAt'
            },
            fullName: {
                type: Sequelize.STRING,
                field: 'fullName',
                allowNull: false,
                validate: {
                    notEmpty: true,
                    len: [0, 255]
                }
            },
            firstName: {
                type: Sequelize.STRING,
                field: 'firstName',
                allowNull: false,
                validate: {
                    notEmpty: true,
                    len: [0, 255]
                }
            },
            lastName: {
                type: Sequelize.STRING,
                field: 'lastName',
                allowNull: false,
                validate: {
                    notEmpty: true,
                    len: [0, 255]
                }
            },
            phone: {
                type: Sequelize.STRING,
                field: 'phone',
                allowNull: false,
                validate: {
                    notEmpty: true,
                    len: [0, 255]
                }
            }
        });
    }
}

module.exports = new UserDataScheme();

const BaseInternalScheme = require('server/dataAccess/schemes/baseInternalScheme');
const Sequelize = require('sequelize');

class UserRoleScheme extends BaseInternalScheme {
    constructor() {
        super();

        this.defineTable('userRole');
        this.defineColumns({
           id: {
                type: Sequelize.UUID,
                field: 'id',
                allowNull: false,
                unique: true,
                primaryKey: true
            },
            createdAt: {
                type: Sequelize.DATE,
                field: 'createdAt'
            },
            updatedAt: {
                type: Sequelize.DATE,
                field: 'updatedAt'
            },
            name: {
                type: Sequelize.STRING,
                field: 'name',
                allowNull: false,
                validate: {
                    notEmpty: true,
                    len: [0, 255]
                }
            }
        });
    }
}

module.exports = new UserRoleScheme();

const BaseScheme = require('server/dataAccess/schemes/baseScheme');
const Sequelize = require('sequelize');

class UserRoleAssociationScheme extends BaseScheme {
    constructor() {
        super('public');

        this.defineTable('userRoleAssociation');
        this.defineColumns({
           id: {
                type: Sequelize.UUID,
                field: 'id',
                allowNull: false,
                unique: true,
                primaryKey: true
            },
            createdAt: {
                type: Sequelize.DATE,
                field: 'createdAt'
            },
            updatedAt: {
                type: Sequelize.DATE,
                field: 'updatedAt'
            },
            userInfoId: {
                type: Sequelize.UUID,
                allowNull: false,
                field: 'userInfoId'
            },
            userRoleId: {
                type: Sequelize.UUID,
                allowNull: false,
                field: 'userRoleId'
            },
            createdAt: {
                type: Sequelize.DATE,
                field: 'createdAt'
            },
            updatedAt: {
                type: Sequelize.DATE,
                field: 'updatedAt'
            }
        });
    }
}

module.exports = new UserRoleAssociationScheme();

The problem is in the code below:

return this._users.findOne({
            attributes: userAttributes, // Some list of attributes
            where: { id },
            include: {
                as: 'Roles',
                attributes: [UserRoleScheme.columnsDescription.id.field],
                model: this._roles, //this._roles is realy a userRole model
            }
        });

What is expected?

I expect that code will query user with necessary id and join the information about his roles.

What is actually happening?

Our logger shows the query generated, and when we execute it in the postgres it works fine, but in the application the sequelize throws an error and I haven’t found any information about it.

error: TypeError: result.get is not a function
    at sequelize\lib\model.js:1424:37
    at Array.reduce (native)
    at sequelize\lib\model.js:1423:17
    at tryCatcher (\sequelize\node_modules\bluebird\js\release\util.js:16:23)
    at MappingPromiseArray._promiseFulfilled (sequelize\node_modules\bluebird\js\release\map.js:57:38)
    at MappingPromiseArray.PromiseArray._iterate (sequelize\node_modules\bluebird\js\release\promise_array.js:113:31)
    at MappingPromiseArray.init (\sequelize\node_modules\bluebird\js\release\promise_array.js:77:10)
    at new MappingPromiseArray (sequelize\node_modules\bluebird\js\release\map.js:25:10)
    at map (sequelize\node_modules\bluebird\js\release\map.js:152:12)
    at Function.Promise.map (sequelize\node_modules\bluebird\js\release\map.js:160:12)

This is the problematic code:

...
  return Model.$findSeparate(
        results.reduce(function (memo, result) {
          var associations = result.get(include.association.as); <- The error

          // Might be an empty belongsTo relation
          if (!associations) return memo;
...

I have already saw that message when we were trying to follow custom approach in model defining and in that case includes not worked at all, but we got rid of it and followed the approach described in the docs when working with Node and Express.

Maybe I am misunderstood something or there is some error in the model definition, please help me to solve it 😃

Dialect:_ postgres __Database version: 9.5 Sequelize version: “^3.23.3”