Why One-to-one relationships in GraphQL? - Purpose & Use Cases

The Big Idea

What if you could instantly connect two pieces of data without any confusion or mistakes?

The Scenario

Imagine you have two separate lists on paper: one with people's names and another with their passport details. You want to match each person to their passport, but you have to flip back and forth between the lists every time.

The Problem

This manual matching is slow and confusing. You might mix up passports or miss someone entirely. It's hard to keep track and easy to make mistakes when the data grows.

The Solution

One-to-one relationships link each person directly to their passport in a clear, organized way. This means you can find all related information quickly without flipping through separate lists.

Before vs After

✗ Before

personList = [{name: 'Alice'}, {name: 'Bob'}]
passportList = [{number: 'X123'}, {number: 'Y456'}]
// Need to manually match by index or name

✓ After

type Person {
  name: String
  passport: Passport
}
type Passport {
  number: String
  owner: Person
}

What It Enables

It lets you easily access connected data in one place, making your queries simple and your data trustworthy.

Real Life Example

In a hospital system, each patient has exactly one medical record. Using one-to-one relationships, doctors can quickly see a patient's record without searching through many files.

Key Takeaways

Manual matching of related data is slow and error-prone.

One-to-one relationships link exactly two pieces of data directly.

This makes data access faster, clearer, and more reliable.

Practice

1. What does a one-to-one relationship in GraphQL represent?

easy

A. Each item in one type is linked to exactly one item in another type.

B. Each item in one type can link to many items in another type.

C. Items are not linked between types.

D. One item links to zero or many items in the same type.

Solution

1. Step 1: Understand relationship types

   One-to-one means each item in one set matches exactly one item in another set.

2. Step 2: Apply to GraphQL context

   In GraphQL, this means a field in one type points to exactly one item in another type.

3. Final Answer:

   Each item in one type is linked to exactly one item in another type. -> Option A

4. Quick Check:

   One-to-one = single matching pair [OK]

Hint: One-to-one means exactly one match per item [OK]

Common Mistakes:

• Confusing one-to-one with one-to-many
• Thinking items can link to multiple items
• Assuming no links exist

2. Which of the following is the correct GraphQL syntax to define a one-to-one relationship between User and Profile types?

easy

A. type User { profile: String }

B. type User { profiles: [Profile] }

C. type User { profile: [Profile] }

D. type User { profile: Profile }

Solution

1. Step 1: Identify one-to-one field type

   One-to-one means a single object, so the field should be of type Profile, not a list.

2. Step 2: Check syntax correctness

   type User { profile: Profile } uses profile: Profile, which is correct syntax for one-to-one.

3. Final Answer:

   type User { profile: Profile } -> Option D

4. Quick Check:

   Single object field = one-to-one [OK]

Hint: Use single type, not list, for one-to-one fields [OK]

Common Mistakes:

• Using list syntax for one-to-one
• Using wrong field type like String
• Missing colon or braces

3. Given the schema:

type User { id: ID! name: String profile: Profile }

type Profile { id: ID! bio: String }

And the query:

{ user(id: "1") { name profile { bio } } }

If user with id "1" has name "Alice" and profile bio "Loves cats", what is the expected output?

medium

A. { "data": { "user": { "name": "Alice", "profile": { "bio": "Loves cats" } } } }

B. { "data": { "user": { "name": "Alice", "profile": null } } }

C. { "data": { "user": { "name": "Alice" } } }

D. Error: profile field missing

Solution

1. Step 1: Understand query fields

   The query requests user's name and profile's bio.

2. Step 2: Match data to query

   User "Alice" has a profile with bio "Loves cats", so both fields return data.

3. Final Answer:

   { "data": { "user": { "name": "Alice", "profile": { "bio": "Loves cats" } } } } -> Option A

4. Quick Check:

   Query fields match data output [OK]

Hint: Returned data matches requested fields exactly [OK]

Common Mistakes:

• Assuming profile is null when data exists
• Omitting nested profile field
• Expecting error when schema is correct

4. Identify the error in this GraphQL schema for one-to-one relationship:

type User { id: ID! profile: [Profile] }

type Profile { id: ID! user: User }

medium

A. User type must not have profile field.

B. Using list syntax [Profile] for one-to-one relationship is incorrect.

C. Missing exclamation mark after Profile.

D. Profile type cannot reference User.

Solution

1. Step 1: Check field type for one-to-one

   One-to-one means a single object, not a list. Using [Profile] means many profiles.

2. Step 2: Confirm correct syntax

   Field should be profile: Profile without brackets for one-to-one.

3. Final Answer:

   Using list syntax [Profile] for one-to-one relationship is incorrect. -> Option B

4. Quick Check:

   List means many, not one [OK]

Hint: No brackets for one-to-one fields [OK]

Common Mistakes:

• Confusing one-to-one with one-to-many
• Adding unnecessary exclamation marks
• Thinking references are not allowed

5. You want to model a one-to-one relationship between Author and Biography in GraphQL. Which schema design ensures each author has exactly one biography and each biography belongs to exactly one author?

hard

A. type Author { id: ID! name: String biography: Biography } type Biography { id: ID! text: String }

B. type Author { id: ID! name: String biographies: [Biography]! } type Biography { id: ID! text: String author: Author }

C. type Author { id: ID! name: String biography: Biography! } type Biography { id: ID! text: String author: Author! }

D. type Author { id: ID! name: String biographyId: ID! } type Biography { id: ID! text: String }

Solution

1. Step 1: Check for required one-to-one fields

   Both Author and Biography have non-nullable fields pointing to each other, ensuring exactly one match.

2. Step 2: Validate mutual references

   Each Author has one Biography! and each Biography has one Author!, enforcing one-to-one.

3. Final Answer:

   type Author { id: ID! name: String biography: Biography! } type Biography { id: ID! text: String author: Author! } -> Option C

4. Quick Check:

   Mutual non-null fields = strict one-to-one [OK]

Hint: Use non-null mutual fields for strict one-to-one [OK]

Common Mistakes:

• Using lists instead of single objects
• Making fields nullable allowing missing links
• Not linking both types mutually