Strict configuration objects in Typescript - Mini Project: Build & Apply

Strict configuration objects

📖 Scenario: You are building a simple app that uses a configuration object to control its behavior. To avoid mistakes, you want to make sure the configuration object only accepts specific properties and types.

🎯 Goal: Create a strict configuration object in TypeScript that only allows certain properties with exact types. Then, use this object in a function that reads the config and prints a message.

📋 What You'll Learn

Create a TypeScript interface called AppConfig with properties appName (string), version (string), and debug (boolean).

Create a constant config of type AppConfig with exact values: appName: 'MyApp', version: '1.0.0', debug: true.

Write a function printConfig that takes a parameter config of type AppConfig and prints the app name, version, and debug status.

Call printConfig with the config object and print the output.

💡 Why This Matters

🌍 Real World

Strict configuration objects help prevent bugs by ensuring only allowed settings are used in apps, making code safer and easier to maintain.

💼 Career

Many software jobs require writing clear and safe code. Using strict types for configuration is a common practice in professional TypeScript projects.

1

Create the AppConfig interface

Create a TypeScript interface called AppConfig with these exact properties: appName of type string, version of type string, and debug of type boolean.

Typescript

// Your code here

Hint

Use the interface keyword to define the shape of the configuration object.

2

Create the config object

Create a constant called config of type AppConfig with these exact values: appName: 'MyApp', version: '1.0.0', and debug: true.

Typescript

interface AppConfig {
  appName: string;
  version: string;
  debug: boolean;
}

// Your code here

Hint

Use const and specify the type AppConfig for the config object.

3

Write the printConfig function

Write a function called printConfig that takes one parameter config of type AppConfig. Inside the function, use console.log to print: App: {appName}, Version: {version}, Debug mode: {debug} using the values from config.

Typescript

interface AppConfig {
  appName: string;
  version: string;
  debug: boolean;
}

const config: AppConfig = {
  appName: 'MyApp',
  version: '1.0.0',
  debug: true
};

// Your code here

Hint

Use a function with typed parameter and template strings for printing.

4

Call printConfig with config

Call the function printConfig with the config object to print the configuration details.

Typescript

interface AppConfig {
  appName: string;
  version: string;
  debug: boolean;
}

const config: AppConfig = {
  appName: 'MyApp',
  version: '1.0.0',
  debug: true
};

function printConfig(config: AppConfig) {
  console.log(`App: ${config.appName}, Version: ${config.version}, Debug mode: ${config.debug}`);
}

// Your code here

Hint

Simply call printConfig(config); to see the output.

Practice

1.

What is the main benefit of using strict configuration objects in TypeScript?

easy

A. They allow any keys to be added without errors.

B. They make the code run faster at runtime.

C. They catch errors early by enforcing exact keys and types.

D. They automatically generate UI forms for settings.

Solution

1. Step 1: Understand strict configuration objects

   Strict configs define exactly which keys and types are allowed in an object.

2. Step 2: Identify the main benefit

   This strictness helps catch mistakes early, before running the code.

3. Final Answer:

   They catch errors early by enforcing exact keys and types. -> Option C

4. Quick Check:

   Strict config = early error detection [OK]

Hint: Strict configs prevent wrong keys and types early [OK]

Common Mistakes:

• Thinking strict configs improve runtime speed
• Believing strict configs allow any keys
• Confusing strict configs with UI generation

2.

Which of the following is the correct way to declare a strict configuration object type in TypeScript?

interface Config {
  host: string;
  port: number;
}

easy

A. const config: Config = { host: 'localhost', port: 8080 };

B. const config: Config = { host: 'localhost' };

C. const config: Config = { host: 'localhost', port: '8080' };

D. const config = { host: 'localhost', port: 8080 };

Solution

1. Step 1: Check interface requirements

   The Config interface requires both 'host' as string and 'port' as number.

2. Step 2: Match object to interface

   const config: Config = { host: 'localhost', port: 8080 }; has both keys with correct types, so it matches Config exactly.

3. Final Answer:

   const config: Config = { host: 'localhost', port: 8080 }; -> Option A

4. Quick Check:

   All required keys with correct types = const config: Config = { host: 'localhost', port: 8080 }; [OK]

Hint: Match all keys and types exactly to interface [OK]

Common Mistakes:

• Omitting required keys
• Using wrong types for keys
• Not specifying the type annotation

3.

What will be the output of this TypeScript code?

interface Settings {
  debug: boolean;
  version: string;
}

const config: Settings = { debug: true, version: '1.0' };
console.log(config.debug, config.version);

medium

A. true 1.0

B. true '1.0'

C. undefined undefined

D. Error: Missing properties

Solution

1. Step 1: Check object matches interface

   The object has 'debug' as true (boolean) and 'version' as '1.0' (string), matching Settings.

2. Step 2: Understand console.log output

   console.log prints the boolean true and string '1.0' without quotes, so output is: true 1.0

3. Final Answer:

   true 1.0 -> Option A

4. Quick Check:

   Matching keys print their values correctly [OK]

Hint: Check object keys match interface and print values directly [OK]

Common Mistakes:

• Expecting quotes around string in console output
• Thinking missing keys cause runtime error
• Confusing type errors with runtime output

4.

Identify the error in this TypeScript code using a strict configuration object:

interface Options {
  timeout: number;
  verbose: boolean;
}

const opts: Options = { timeout: 5000, verbose: 'yes' };

medium

A. Property 'timeout' is missing.

B. Property 'verbose' should be a boolean, not a string.

C. Extra property 'verbose' is not allowed.

D. No error, code is correct.

Solution

1. Step 1: Check property types against interface

   'timeout' is number 5000, correct. 'verbose' is string 'yes', but interface requires boolean.

2. Step 2: Identify type mismatch error

   Assigning string to boolean property causes a type error.

3. Final Answer:

   Property 'verbose' should be a boolean, not a string. -> Option B

4. Quick Check:

   Type mismatch on 'verbose' property [OK]

Hint: Check each property type matches interface exactly [OK]

Common Mistakes:

• Ignoring type mismatch errors
• Thinking missing properties cause this error
• Confusing extra properties with wrong types

5.

You want to create a strict configuration object that only allows keys mode (string), retry (number), and enabled (boolean). Which TypeScript type definition ensures no extra keys are allowed?

hard

A. interface Config { mode: string; retry: number; enabled: boolean; }

B. type Config = { mode: string; retry: number; enabled: boolean; [key: string]: any }

C. type Config = { mode?: string; retry?: number; enabled?: boolean }

D. interface Config { mode: string; retry: number; enabled: boolean; [key: string]: never }

Solution

1. Step 1: Understand how to forbid extra keys

   Using an index signature with [key: string]: never forbids any keys not explicitly declared.

2. Step 2: Compare options

   interface Config { mode: string; retry: number; enabled: boolean; } allows extra keys implicitly. type Config = { mode: string; retry: number; enabled: boolean; [key: string]: any } allows any extra keys. type Config = { mode?: string; retry?: number; enabled?: boolean } makes keys optional but doesn't forbid extras. Only interface Config { mode: string; retry: number; enabled: boolean; [key: string]: never } forbids extra keys.

3. Final Answer:

   interface Config { mode: string; retry: number; enabled: boolean; [key: string]: never } -> Option D

4. Quick Check:

   Index signature with never forbids extra keys [OK]

Hint: Use [key: string]: never to forbid extra keys [OK]

Common Mistakes:

• Thinking interface alone forbids extra keys
• Using any type index signature allowing extras
• Making keys optional but not forbidding extras