Required type in Typescript - Mini Project: Build & Apply

Using the Required Type in TypeScript

📖 Scenario: Imagine you are building a simple user profile system where some user information is optional at first but later you want to make sure certain fields are definitely filled in.

🎯 Goal: You will create a user object with optional fields, then use TypeScript's Required type to make all fields mandatory, and finally print the updated user object.

📋 What You'll Learn

Create an interface User with optional properties name, email, and age

Create a variable user of type User with only name set

Create a new type CompleteUser using Required<User>

Create a variable completeUser of type CompleteUser with all properties set

Print the completeUser object

💡 Why This Matters

🌍 Real World

In real projects, you often start with optional data and later require all fields to be filled before saving or processing.

💼 Career

Understanding TypeScript utility types like <code>Required</code> helps you write safer and clearer code, a valuable skill for frontend and backend developers.

1

Create the User interface and user variable

Create an interface called User with optional properties name (string), email (string), and age (number). Then create a variable called user of type User with only name set to "Alice".

Typescript

// Your code here

Hint

Use ? after property names to make them optional in the interface.

2

Create the CompleteUser type using Required

Create a new type called CompleteUser using Required<User> to make all properties required.

Typescript

interface User {
  name?: string;
  email?: string;
  age?: number;
}

const user: User = {
  name: "Alice"
};

// Your code here

Hint

Use type CompleteUser = Required<User>; to make all properties required.

3

Create a completeUser variable with all properties

Create a variable called completeUser of type CompleteUser and set all properties: name to "Alice", email to "[e-mail]", and age to 30.

Typescript

interface User {
  name?: string;
  email?: string;
  age?: number;
}

const user: User = {
  name: "Alice"
};

type CompleteUser = Required;

// Your code here

Hint

All properties must be present because CompleteUser requires them.

4

Print the completeUser object

Write a console.log statement to print the completeUser object.

Typescript

interface User {
  name?: string;
  email?: string;
  age?: number;
}

const user: User = {
  name: "Alice"
};

type CompleteUser = Required;

const completeUser: CompleteUser = {
  name: "Alice",
  email: "[e-mail]",
  age: 30
};

// Your code here

Hint

Use console.log(completeUser); to print the object.

Practice

1. What does the Required utility type do in TypeScript?

easy

A. Makes all properties of a type optional

B. Makes all properties of a type mandatory

C. Removes all properties from a type

D. Allows properties to be undefined

Solution

1. Step 1: Understand the purpose of Required

   The Required utility type transforms all optional properties of a type into required ones.

2. Step 2: Compare options with definition

   Only Makes all properties of a type mandatory correctly states that Required makes all properties mandatory.

3. Final Answer:

   Makes all properties of a type mandatory -> Option B

4. Quick Check:

   Required = all mandatory [OK]

Hint: Remember: Required means no optional properties allowed [OK]

Common Mistakes:

• Confusing Required with Partial (which makes properties optional)
• Thinking Required removes properties
• Assuming Required allows undefined values

2. Which of the following is the correct syntax to make all properties of interface User required using Required?

easy

A. type CompleteUser = Required<User>;

B. type CompleteUser = Partial<User>;

C. type CompleteUser = Optional<User>;

D. type CompleteUser = Readonly<User>;

Solution

1. Step 1: Recall the syntax of Required

   The correct syntax to apply Required is Required<TypeName>.

2. Step 2: Match options with syntax

   type CompleteUser = Required<User>; uses Required<User> correctly. Others use different utility types or incorrect names.

3. Final Answer:

   type CompleteUser = Required<User>; -> Option A

4. Quick Check:

   Use Required<Type> for all mandatory props [OK]

Hint: Use Required<Type> exactly to enforce all properties [OK]

Common Mistakes:

• Using Partial instead of Required
• Typing Optional which doesn't exist in TypeScript
• Confusing Readonly with Required

3. Given the interface and type below, what is the type of user2?

interface User {
  name?: string;
  age?: number;
}

const user2: Required<User> = {
  name: "Alice",
  age: 30
};

medium

A. An object where name and age are required

B. An object where name and age are optional

C. An object where only name is required

D. An object where age is optional

Solution

1. Step 1: Analyze the interface User

   Both name and age are optional properties in User.

2. Step 2: Understand Required<User>

   The Required utility makes all optional properties required, so name and age must be present.

3. Final Answer:

   An object where name and age are required -> Option A

4. Quick Check:

   Required<User> = all required props [OK]

Hint: Required makes all optional props mandatory [OK]

Common Mistakes:

• Thinking optional props stay optional
• Assuming only some props become required
• Confusing Required with Partial

4. What is the error in this code snippet?

interface Product {
  id?: number;
  name?: string;
}

const product: Required<Product> = {
  id: 101
};

medium

A. Cannot assign object to interface Product

B. Type 'number' is not assignable to 'string'

C. No error, code is correct

D. Missing property 'name' in object

Solution

1. Step 1: Check properties in Required<Product>

   Both id and name are required because of Required.

2. Step 2: Compare object properties with interface

   The object only has id, missing name, causing a TypeScript error.

3. Final Answer:

   Missing property 'name' in object -> Option D

4. Quick Check:

   Required means all props must be present [OK]

Hint: Check all required props are present in object [OK]

Common Mistakes:

• Ignoring missing required properties
• Thinking optional props remain optional
• Assuming partial object assignment is allowed

5. You have a type with some optional properties:

type Config = {
  host?: string;
  port?: number;
  secure?: boolean;
};

You want to create a new type FullConfig where all properties are required, but also want to add a new property timeout which is required. Which is the correct way to do this?

hard

A. type FullConfig = Partial<Config> & { timeout?: number };

B. type FullConfig = Required<Config> & { timeout?: number };

C. type FullConfig = Required<Config> & { timeout: number };

D. type FullConfig = Config & { timeout: number };

Solution

1. Step 1: Make all Config properties required

   Use Required<Config> to make host, port, and secure mandatory.

2. Step 2: Add new required property timeout

   Use intersection & with { timeout: number } to add a required timeout property.

3. Final Answer:

   type FullConfig = Required<Config> & { timeout: number }; -> Option C

4. Quick Check:

   Required + intersection adds required props [OK]

Hint: Combine Required<Type> & { newProp: type } for extra required props [OK]

Common Mistakes:

• Using Partial instead of Required
• Making new property optional when it should be required
• Not combining types correctly