Javascript – undefined is not an object firebase.auth.FacebookAuthProvider.credential

facebookfirebasefirebase-authenticationjavascriptreact-native

Here is my code.. its pretty simple.. just trying to allow a user to authenticate through facebook and then add it to the Firebase system!
I should mention that I am using React Native, I did read that various parts of the Firebase library does not work with React Native.

const auth = firebase.auth();
const provider = firebase.auth.FacebookAuthProvider;

LoginManager.logInWithReadPermissions(['public_profile'])
.then(loginResult => {

    alert("login results")
    if (loginResult.isCancelled) {
        alert('user canceled');
        return;
    }
    AccessToken.getCurrentAccessToken()
    .then(accessTokenData => {
        const credential = firebase.auth.FacebookAuthProvider.credential(accessTokenData.accessToken);
        alert("Credential: " + credential )
        return auth.signInWithCredential(credential);
    })
    .then(credData => {
        console.log(credData);
        alert("CRED data:::" + credData)
        alert(firebase)
    })
    .catch(err => {
        console.log(err);
        alert("ERROR:::" + err)
        alert(firebase)

    });
});

The only reasoning I can really think of for this is that Firebase is undefined or it does not finish initializing.. although it seems to be.. maybe I can put in some sort of promise to ensure it has initialized.
(Any ideas on how to do that?)

Although firebase seems to be initalized.. but I went through the api reference and can't really find any reason why .auth.FacebookAuthProvider.credential would not exist

Any help would be great!

Best Answer

I was having this exact same issue, and I have a solution that worked for me, but I'm not sure if it will be the same for you.

I was instantiating my firebase class through a separate module, in a file called FirebaseService.js

'use-strict';

const firebase = require('firebase');
const APP_BASE = 'https://your-unique-url.firebaseapp.com/'

const FIREBASE_CONFIG = {
    apiKey: '[super_unique]',
    authDomain: 'your-unique-url.firebaseapp.com',
    databaseURL: APP_BASE,
    storageBucket: 'your-unique-url.appspot.com',
};

export const Firebase = firebase.initializeApp(FIREBASE_CONFIG);

I was then using it everywhere else in my code by importing it:

const { Firebase } = require ('./services/FirebaseService');

This appeared to be fine until I got around to implementing facebook login, and that's when I started having the same issue.

I had to import firebase in the screen that was trying to login with facebook. instead of requiring my own service, I used the npm module:

const firebase = require('firebase');

After that, I was able to access FacebookAuthProvider.credential. I'm really not sure why this is the case, there may have been something wrong with my use of modules

Related Solutions

Javascript – Length of a JavaScript object

The most robust answer (i.e. that captures the intent of what you're trying to do while causing the fewest bugs) would be:

Object.size = function(obj) {
  var size = 0,
    key;
  for (key in obj) {
    if (obj.hasOwnProperty(key)) size++;
  }
  return size;
};

// Get the size of an object
const myObj = {}
var size = Object.size(myObj);

There's a sort of convention in JavaScript that you don't add things to Object.prototype, because it can break enumerations in various libraries. Adding methods to Object is usually safe, though.

Here's an update as of 2016 and widespread deployment of ES5 and beyond. For IE9+ and all other modern ES5+ capable browsers, you can use Object.keys() so the above code just becomes:

var size = Object.keys(myObj).length;

This doesn't have to modify any existing prototype since Object.keys() is now built-in.

Edit: Objects can have symbolic properties that can not be returned via Object.key method. So the answer would be incomplete without mentioning them.

Symbol type was added to the language to create unique identifiers for object properties. The main benefit of the Symbol type is the prevention of overwrites.

Object.keys or Object.getOwnPropertyNames does not work for symbolic properties. To return them you need to use Object.getOwnPropertySymbols.

var person = {
  [Symbol('name')]: 'John Doe',
  [Symbol('age')]: 33,
  "occupation": "Programmer"
};

const propOwn = Object.getOwnPropertyNames(person);
console.log(propOwn.length); // 1

let propSymb = Object.getOwnPropertySymbols(person);
console.log(propSymb.length); // 2

Javascript – Detecting an undefined object property

The usual way to check if the value of a property is the special value undefined, is:

if(o.myProperty === undefined) {
  alert("myProperty value is the special value `undefined`");
}

To check if an object does not actually have such a property, and will therefore return undefined by default when you try and access it:

if(!o.hasOwnProperty('myProperty')) {
  alert("myProperty does not exist");
}

To check if the value associated with an identifier is the special value undefined, or if that identifier has not been declared. Note: this method is the only way of referring to an undeclared (note: different from having a value of undefined) identifier without an early error:

if(typeof myVariable === 'undefined') {
  alert('myVariable is either the special value `undefined`, or it has not been declared');
}

In versions of JavaScript prior to ECMAScript 5, the property named "undefined" on the global object was writeable, and therefore a simple check foo === undefined might behave unexpectedly if it had accidentally been redefined. In modern JavaScript, the property is read-only.

However, in modern JavaScript, "undefined" is not a keyword, and so variables inside functions can be named "undefined" and shadow the global property.

If you are worried about this (unlikely) edge case, you can use the void operator to get at the special undefined value itself:

if(myVariable === void 0) {
  alert("myVariable is the special value `undefined`");
}

Best Answer

Related Solutions

Javascript – Length of a JavaScript object

Javascript – Detecting an undefined object property

Related Topic