Loopback HasOne

LoopBack is a popular Node.js framework for building REST APIs. The hasOne relation is one of the many relation types offered by LoopBack. In this article, we will learn what hasOne is, how it works, and how to use it.

What is hasOne?

In LoopBack, hasOne is a type of relation between two models. It represents a one-to-one relationship between a parent model and a child model. For instance, a User model can have a Profile model associated with it, using the hasOne relation. The User model is the parent model, and the Profile model is the child model.

How hasOne works?

The hasOne relation creates a foreign key on the child model pointing to the parent model's ID. In our example, the Profile model will have a foreign key column named userId, which will reference the id column of the User model.

How to use hasOne?

In order to use the hasOne relation, you need to define it in your LoopBack model definition. Here's an example:

{
  "name": "User",
  "base": "PersistedModel",
  "properties": {
    "email": {
      "type": "string"
    },
    "password": {
      "type": "string"
    }
  },
  "relations": {
    "profile": {
      "type": "hasOne",
      "model": "Profile",
      "foreignKey": "userId"
    }
  }
}

In this example, we define a User model with two properties: email and password. We also define a profile relation using the hasOne type, which references the Profile model. We specify the foreign key column name as userId.

Now, if you create a Profile model with a userId property referencing a User model's id, you can retrieve the associated User model using the profile property on the Profile model instance.

const user = await User.create({ email: 'john@example.com', password: 'password' });
const profile = await Profile.create({ bio: 'Some bio', userId: user.id });
const userWithProfile = await profile.profile.get();
console.log(userWithProfile); // { id: 1, email: 'john@example.com', password: 'password }

In this example, we create a new User instance and a new Profile instance. We set the userId property on the Profile instance to the id of the User instance. Finally, we retrieve the associated User instance using the profile property on the Profile instance.

Conclusion

The hasOne relation is a convenient way to represent one-to-one relationships between models in LoopBack. By defining the relation in your model definition, you can easily retrieve associated models using properties on your model instances.