DEV Community: Amit Kumar Raikwar

Validate and Mask Environment Variables in Node.js and TypeScript

Amit Kumar Raikwar — Thu, 11 Jun 2026 18:38:55 +0000

Configuring environment variables seems simple, but it frequently leads to two common issues in production-grade applications:

Missing Variables: A developer adds a new variable locally but forgets to update the .env.example file. Other team members pull the changes, and their local environments crash.
Leaked Credentials: A debug log like console.log(process.env) prints database connection strings or API tokens to the terminal, leaving them visible in plaintext logs.

To solve this, we created @novaedgedigitallabs/envkit. It is a zero-dependency (other than Zod) utility that validates, loads, and masks environment variables, and keeps your example configurations updated automatically.

Key Features

Schema Validation: Define your environment variables with Zod to enforce types and formats.
Log Masking: Automatically redact sensitive credentials in console output.
Example Syncing: Automatically append missing variables to your .env.example file without overwriting comments or values.
Module Support: Runs in ESM and CommonJS.

Getting Started

Install the package and Zod:

npm install @novaedgedigitallabs/envkit zod

Initialize your configuration in a file like env.ts:

import { createEnv } from '@novaedgedigitallabs/envkit';
import { z } from 'zod';

export const env = createEnv({
  schema: {
    DATABASE_URL: z.string().url(),
    JWT_SECRET: z.string().min(32),
    PORT: z.coerce.number().default(3000),
    NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
  },
  secrets: ['JWT_SECRET', 'DATABASE_URL'],
  generateExample: true, // Appends new keys to .env.example at runtime
});

Because the variables are validated using Zod, your editor will provide full TypeScript autocomplete and type safety:

env.PORT;         // Resolved as a number
env.JWT_SECRET;   // Resolved as a string

Preventing Secret Leaks in Logs

Logging environment configs is a common debugging habit. With envkit, any variables listed in the secrets array are automatically masked when printed:

console.log(env);
// Output:
// { 
//   PORT: 3000, 
//   NODE_ENV: 'development', 
//   JWT_SECRET: '[MASKED]', 
//   DATABASE_URL: '[MASKED]' 
// }

The underlying code still accesses the correct, unmasked values when called directly (e.g., env.JWT_SECRET), keeping your database connections and authentications functional while protecting your log files.

Keeping .env.example Files Synchronized

Updating example files manually is tedious. Envkit offers two ways to sync them:

1. Runtime Syncing

By setting generateExample: true in createEnv, the library reads your schema during startup and appends any missing keys directly to .env.example.

2. CLI Tool

If you prefer to sync before running your code, you can use the CLI tool:

npx envkit generate

This parses your .env file and appends only the new, missing keys to .env.example. Unlike standard tools that overwrite the entire target file, this command is non-destructive: it preserves all your existing values, custom comments, and spacing.

If you use non-standard file names, you can specify them manually:

npx envkit generate --env .env.production --out .env.production.example

Comparison with Existing Tools

Feature	dotenv	t3-env	envkit
Loads env files	Yes	Yes	Yes
Zod validation	No	Yes	Yes
Framework agnostic	Yes	Limited	Yes
Secrets masking in logs	No	No	Yes
Auto `.env.example` sync	No	No	Yes
ESM + CommonJS support	Yes	ESM only	Yes

Support

If envkit saved you time → novaedgedigitallabs.tech/pay

Conclusion

Validating your environment configurations and keeping your example files updated should not require manual tracking. By integrating validation, log masking, and automated syncing, @novaedgedigitallabs/envkit ensures your environment is consistent and secure.

If you want to view the source code, report issues, or contribute, you can find the project on GitHub: github.com/novaedgedigitallabs/envkit.

I built a zero-dependency city search library with 50,000 cities built-in

Amit Kumar Raikwar — Wed, 10 Jun 2026 20:29:44 +0000

Most geo projects need city search, distance calculation, or nearest location logic at some point. The usual answer is "hit a third-party API." But that means latency, rate limits, API keys, and cost.

I built @novaedgedigitallabs/citykit to solve this — a zero-dependency utility library that ships with a full dataset of 49,992 cities across 242 countries, ready to use offline.

Install

npm install @novaedgedigitallabs/citykit

No API key. No setup. Works in Node.js and TypeScript out of the box.

What it can do

1. Search cities

import { search } from '@novaedgedigitallabs/citykit';

const results = search('Mumbai');
console.log(results);
// [{ name: 'Mumbai', country: 'IN', lat: 19.0760, lng: 72.8777, ... }]

Fuzzy-friendly, returns ranked matches.

2. Calculate distance between two cities (Haversine)

import { distance } from '@novaedgedigitallabs/citykit';

const km = distance(
  { lat: 22.7196, lng: 75.8577 }, // Indore
  { lat: 19.0760, lng: 72.8777 }  // Mumbai
);

console.log(km); // ~590 km

Uses the Haversine formula — accurate great-circle distance, no API needed.

3. Find nearest cities to a location

import { nearest } from '@novaedgedigitallabs/citykit';

const cities = nearest({ lat: 22.7196, lng: 75.8577 }, 5);
// Returns 5 closest cities to Indore

Great for "cities near me" features.

4. Filter by country, state, or continent

import { filterByCountry, filterByContinent } from '@novaedgedigitallabs/citykit';

const indianCities = filterByCountry('IN');
const europeanCities = filterByContinent('EU');

5. Country and capital data

import { getCountry, getCapital } from '@novaedgedigitallabs/citykit';

getCountry('IN');   // { name: 'India', code: 'IN', continent: 'AS', ... }
getCapital('IN');   // 'New Delhi'

Why zero dependencies?

Most libraries in this space pull in heavy geo packages or call external APIs. citykit bundles the dataset directly — the tradeoff is a slightly larger install size, but you get:

Works fully offline
No rate limits
No API keys to manage
No latency from network calls
Predictable behavior in serverless / edge environments

There's also a lightweight variant if you only need basic search without the full dataset.

Real use cases I've used it for

Autocomplete city input on a form (no API call on every keystroke)
Distance filter for a property listing platform
"Nearest branch" feature for a business directory
Seeding a database with city/country data

15 functions, one import

The full list: search, distance, nearest, filterByCountry, filterByState, filterByContinent, filterByRadius, getCountry, getCapital, getAllCountries, getCitiesByPopulation, getCity, getContinents, listCountries, lightSearch