Implementing Passport authentication with promises
When writing your custom functions that operate on promises, a good habit is to return resulting promises in order to have ability to chain them. For instance:

return DBM.getUser(user_props.id_google).then( (res) =&gt; { (from getOrCreateUser)
or:
return DBM.createUser(user_props).then(() =&gt; {


It will ensure that getOrCreateUser and createUser operations will be chained together properly.


The passportjs uses different API. It does not use promises but callbacks. 
As I see, you mixed them together by mistake! For instance in DBM.createUser from inside your promise you returned an object returned just by done callback when resulting value/other promise is expected. Same in DBM.getUser from passport.deserializeUser
It might be only mine (a little bit nerdy) custom, but I have a habit to wrap 3rd party non promise APIs into promise adapters.


For instance (an easy one):

function serializeUser(idProviderPromise) {
    let resultDeffered = Promise.defer();
    passport.serializeUser((profile, done) =&gt; {
        idProviderPromise(profile).then(function (profileId) {
            done(null, profileId);
            resultDeffered.resolve();
        });
    });
    return resultDeffered;
}


Usage:

passportPromiseApi.serializeUser(new Promise(profile =&gt; profile.id_google));


It can help make us sure not to mix different APIs together.

At the first glance it can look a little bit over complicated, but please take a look how it simplifies more complex cases:

function configure(getOrCreateUserPromise) {
    let resultDeffered = Promise.defer();
    function getOrCreateUser(accessToken, refreshToken, profile, done) {
        getOrCreateUserPromise(accessToken, refreshToken, profile).then(function (userProps) {
            done(null, userProps);
            resultDeffered.resolve(userProps);
        }).catch(function (error) {
            done(error, null);
            resultDeffered.fail(error);
        });
    }
    passport.use('google', new GoogleStrategy(helper.getPassport(), getOrCreateUser));
    return resultDeffered;
}


Usage:

passportPromiseApi.configure(new Promise(function (accessToken, refreshToken, profile) {
    const userProps = obtainProps(profile);
    return DBM.getUser(userProps.id_google).then(res =&gt; {
        return res[0] ? Promise.resolve(userProps) : createUser(userProps);
        //Instead Promise.resolve(userProps) simply userProps should work as well
        //But it is also a good practice for return type in any JS function to be consistent.
    });
}));

function createUser (userProps) {
    return DBM.createUser(userProps).then(() =&gt; userProps); 
    //Error handling is already done by our adapter.
    //We can focus only on business logic here!
}



Last less important thing: let assume some consistent naming convention for function parameters and local variables respectively. You have to decide whether to use xxx_yyy or xxxYyy (camel case). 3-rd party usages doesn't count as it must be used exactly.