Configuration management in Deno - Step-by-Step Execution

Concept Flow - Configuration management

Start Application

↓

Load Config File

↓

Parse Config Data

↓

Apply Defaults if Missing

↓

Provide Config to App

↓

App Uses Config Values

↓

End

The app starts by loading and parsing config data, applies defaults if needed, then uses these settings during runtime.

Execution Sample

Deno

const configText = await Deno.readTextFile("config.json");
const config = JSON.parse(configText);
const port = config.port ?? 8080;
console.log(`Server runs on port ${port}`);

This code loads a JSON config file, parses it, sets a default port if missing, and prints the port used.

Execution Table

Step	Action	Value/Result	Notes
1	Start app	No config loaded	App begins execution
2	Read config.json file	{"port":3000}	Config file content loaded as text
3	Parse JSON text	{ port: 3000 }	Text converted to JS object
4	Check port value	3000	Port found in config
5	Set port variable	3000	Uses config port value
6	Print port	Server runs on port 3000	Output to console
7	End	App ready with config	Execution complete

💡 Config loaded and applied; app ready to use settings.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	Final
configText	undefined	{"port":3000}	{"port":3000}	{"port":3000}	{"port":3000}	{"port":3000}
config	undefined	undefined	{ port: 3000 }	{ port: 3000 }	{ port: 3000 }	{ port: 3000 }
port	undefined	undefined	undefined	3000	3000	3000

Key Moments - 2 Insights

Why do we parse the config file text with JSON.parse?

Because reading the file returns text, not an object. JSON.parse converts the text into a usable JavaScript object, as shown in step 3 of the execution_table.

What happens if the config file does not have a port value?

The code uses the default port 8080 with the nullish coalescing operator (??). This is shown in the sample code and would happen at step 5 if port was undefined.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'port' after step 4?

A undefined

B 3000

C 8080

D null

💡 Hint

Check the 'port' variable value in the variable_tracker after step 4.

At which step does the config file content get converted from text to an object?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look at the 'Action' column in execution_table where JSON.parse is called.

If the config file was empty, what would the 'port' variable be after step 5?

A 8080

B undefined

C 3000

D null

💡 Hint

Recall the default value set with ?? operator in the code sample.

Concept Snapshot

Configuration management in Deno:
- Load config file with Deno.readTextFile
- Parse JSON text to object
- Use ?? to set defaults
- Provide config values to app
- Enables flexible app settings
- Handles missing config gracefully

Full Transcript

This visual execution shows how a Deno app manages configuration by loading a JSON file, parsing it into an object, applying default values if needed, and using those settings during runtime. Step-by-step, the app reads the config file as text, parses it with JSON.parse, checks for a port value, sets a default if missing, and then uses the port value. Variables like configText, config, and port change as the app progresses. Key points include why parsing is needed and how defaults work. The quiz tests understanding of variable values at each step and the flow of config loading.

Practice

1. What is the main purpose of configuration management in a Deno application?

easy

A. To separate settings like API keys from the main code for flexibility and security

B. To write all code and settings in a single file for simplicity

C. To hardcode secret keys directly in the source code

D. To avoid using environment variables altogether

Solution

1. Step 1: Understand configuration management role

   Configuration management separates settings from code to keep apps flexible and secure.

2. Step 2: Identify correct practice in Deno

   Using environment variables or .env files keeps secrets out of code and allows easy changes.

3. Final Answer:

   To separate settings like API keys from the main code for flexibility and security -> Option A

4. Quick Check:

   Config management = separate settings [OK]

Hint: Remember: keep secrets out of code, use config files [OK]

Common Mistakes:

• Hardcoding secrets in source code
• Mixing code and settings in one file
• Ignoring environment-specific configs

2. Which of the following is the correct way to load environment variables from a .env file in Deno?

easy

A. require('dotenv').config();

B. import { config } from "https://deno.land/std/dotenv/mod.ts"; const env = config();

C. import dotenv from "dotenv"; dotenv.load();

D. import { loadEnv } from "deno_env"; loadEnv();

Solution

1. Step 1: Identify Deno's dotenv import syntax

   Deno uses ES module imports from URLs, like importing config from std/dotenv.

2. Step 2: Check correct usage

   Calling config() loads environment variables from .env file correctly in Deno.

3. Final Answer:

   import { config } from "https://deno.land/std/dotenv/mod.ts"; const env = config(); -> Option B

4. Quick Check:

   Deno dotenv import = import { config } from "https://deno.land/std/dotenv/mod.ts"; const env = config(); [OK]

Hint: Use Deno's std/dotenv with ES module import [OK]

Common Mistakes:

• Using Node.js require syntax in Deno
• Using non-existent packages
• Calling wrong functions to load env

3. Given this Deno code snippet:

import { config } from "https://deno.land/std/dotenv/mod.ts";
const env = config();
console.log(env.API_KEY);

If the .env file contains API_KEY=12345, what will be printed?

medium

A. undefined

B. Error: .env file not found

C. API_KEY

D. 12345

Solution

1. Step 1: Understand config() output

   The config() function reads .env and returns an object with keys and values.

2. Step 2: Access API_KEY value

   env.API_KEY accesses the value '12345' from the loaded environment variables.

3. Final Answer:

   12345 -> Option D

4. Quick Check:

   env.API_KEY = '12345' [OK]

Hint: config() returns env vars as object keys [OK]

Common Mistakes:

• Expecting config() to print keys directly
• Forgetting to create .env file
• Assuming env variables are undefined

4. What is wrong with this Deno code snippet for loading environment variables?

import { config } from "https://deno.land/std/dotenv/mod.ts";
const env = config;
console.log(env.API_SECRET);

medium

A. config is not imported correctly

B. API_SECRET is not a valid environment variable name

C. config is assigned without calling it as a function

D. console.log syntax is incorrect

Solution

1. Step 1: Check how config is used

   config is a function and must be called with parentheses to load env variables.

2. Step 2: Identify the error

   Assigning config without () means env is the function itself, not the loaded object.

3. Final Answer:

   config is assigned without calling it as a function -> Option C

4. Quick Check:

   Call config() to load env [OK]

Hint: Always call config() with parentheses [OK]

Common Mistakes:

• Assigning function reference instead of calling it
• Misspelling config import
• Using wrong variable names

5. You want to manage different configurations for development and production in a Deno app. Which approach is best practice?

hard

A. Use separate .env files like .env.development and .env.production and load the correct one based on an environment variable

B. Hardcode production secrets in the code and use .env only for development

C. Use a single .env file with all keys and comment out unused ones manually

D. Store all secrets in a JSON file checked into version control

Solution

1. Step 1: Understand environment-specific configs

   Different environments need different settings to avoid mistakes and leaks.

2. Step 2: Choose best practice for Deno

   Using separate .env files and loading based on an environment variable keeps configs clean and secure.

3. Final Answer:

   Use separate .env files like .env.development and .env.production and load the correct one based on an environment variable -> Option A

4. Quick Check:

   Separate env files per environment = Use separate .env files like .env.development and .env.production and load the correct one based on an environment variable [OK]

Hint: Use multiple .env files and switch by env variable [OK]

Common Mistakes:

• Hardcoding secrets in code
• Using one .env for all environments
• Checking secrets into version control