Firebase database schema

Question

I can't understand the way Firebase db works. Yes, I know it is a JSON with my data, I know the ways to set one-to-many and many-to-many relationship between different objects. But is there any way to set up some kind of "schema" to database?

An example to understand what I mean: what if I'm creating an Android app, using Firebase SDK, and my friend is creating an iOS app. I'm pushing this to "users": {name: John, city: LA}. And my friend makes a mistake, pushing {name: Tom, cety: NY}. Than, trying to get Toms city - what will I get? Null?

Is there a way to specify a structure to saved data. In Firebase console I see only way to add exact values, not specify the way it should be structured. How to tell other developers, or "me-in-the-future" that my users should contain, for example "name", "gender" and "dog_eyes_color"? Hope you understand me.

Answer 1

To answer your question, Firebase is a schema-less database. If you push data to a node

users
  uid_0
    name: John
    city: LA

and your friend adds another user

  uid_1
    name: Frank
    cety: NY

Then your users node will have two users with children that have different keys; city vs cety.

As Frank mentioned in his comment, you can 'catch' and prevent data from being written to a node that's invalid. However, ponder this class:

class User {
   userId = ""
   name = ""
   city = ""

   func saveToFirebase() {
      myRef.setValue( user id etc etc)
   }
}

and you tell your friend that any time they want to store a user in Firebase, to use that class. You now have a standardized model in which to interact with Firebase. That class (or structure or whatever you use) defines a schema to work with.

The Firebase database (NoSQL) provides a mechanism for storage and retrieval of data which is modeled in means other than the tabular relations used in relational databases

And as a followup to the users question: Firebase DOES store user authentication data 'in the back end' which is not directly accessible (queryable) to the developer. The idea here is that when a user is created in Firebase with Firebase functions such as createUser(), you are provided the user id (UID) of that user when it's created and that's what you can use to store additional information in a /users node you create.

users
   uid_0
    name: Frank
    location: LA
    fav_food: Pizza
   uid_1
    name: Leroy
    location: NY
    fav_food: Tacos

.validate.... I would not leverage .validate rules to define a structure (schema) or keep other developers in check. Providing coding tools such as the Users class mentioned above will provide far more flexibility and less aggravation (and coding) in the long run and will be much more maintainable.

Answer 2

how about this way of implementation

class User {
  constructor(name, city) {
    this.name = name;
    this.city = city;
    return {
      name: this.name,
      city: this.city,
    };
  }
}

const saveDocument = function (collectionName, obj) {
  db.collection(collectionName)
    .add(obj)
    .then((docRef) => {
      console.log("Document written with ID: ", docRef.id);
    })
    .catch((error) => {
      console.error("Error adding document: ", error);
    });
};



saveDocument("user", new User("Jhon", "NY"));