Forem: Deni Irawan Nugraha

Introducing node-ip-ts: A Modern Type-Safe IP Utility Library for Node.js

Deni Irawan Nugraha — Thu, 05 Mar 2026 06:57:45 +0000

Working with IP addresses in Node.js is a common task for backend developers.
Whether you're building authentication systems, rate limiters, firewall rules, analytics pipelines, or networking tools — sooner or later you'll need utilities for handling IP addresses.

For years, the popular ip package has been the go-to solution. It has millions of weekly downloads and provides a simple API for working with IPv4 and IPv6.

However, the ecosystem has evolved.

Today, most modern Node.js projects use:

TypeScript
ES Modules
strict type checking
modern bundlers

Unfortunately, the original ip package does not fully support these modern workflows.

That is exactly why node-ip-ts was created.

What is `node-ip-ts`?

node-ip-ts is a modern rewrite of the popular ip library with a focus on:

Full TypeScript support
ES Module compatibility
Strict typing
Zero dependencies
API compatibility with the original library

It allows developers to keep the familiar API while gaining the benefits of modern TypeScript development.

npm install node-ip-ts

Why create another IP library?

The original ip package works well, but it has some limitations in modern TypeScript environments.

Feature	`ip`	`node-ip-ts`
TypeScript types	❌	✅
ES Modules	❌	✅
CommonJS	✅	✅
Strict typing	❌	✅
External dependencies	0	0
API compatibility	—	✅

The goal of node-ip-ts is simple:

Provide a drop-in replacement for ip that works seamlessly with modern TypeScript projects.

This means you can migrate by changing just one line.

- const ip = require('ip')
+ const ip = require('node-ip-ts')

Or in TypeScript:

import * as ip from "node-ip-ts"

Example Usage

Here are some common operations you can perform with node-ip-ts.

Address Classification

import * as ip from "node-ip-ts"

ip.isPrivate("192.168.1.1") // true
ip.isPublic("8.8.8.8") // true
ip.isLoopback("127.0.0.1") // true

The library supports both IPv4 and IPv6.

ip.isPrivate("fd12:3456:789a:1::1") // true

Working with CIDR and Subnets

Network calculations are one of the most common needs.

const subnet = ip.cidrSubnet("192.168.1.134/26")

subnet.networkAddress
// "192.168.1.128"

subnet.firstAddress
// "192.168.1.129"

subnet.lastAddress
// "192.168.1.190"

subnet.contains("192.168.1.150")
// true

This is useful for things like:

firewall rules
IP allowlists / blocklists
internal network tools
infrastructure automation

Bitwise Operations on IP Addresses

The library also supports bitwise operations often required for networking logic.

ip.not("255.255.255.0")
// "0.0.0.255"

ip.or("0.0.0.255", "192.168.1.10")
// "192.168.1.255"

These operations are helpful when computing:

wildcard masks
broadcast addresses
subnet boundaries

Converting IP Addresses

Sometimes IPs must be converted to integers for storage or comparison.

ip.toLong("127.0.0.1")
// 2130706433

ip.fromLong(2130706433)
// "127.0.0.1"

The library also supports normalization of various IPv4 formats.

ip.normalizeToLong("0x7f.0.0.1")
// 2130706433

Works in Node.js and the Browser

Most functions are environment agnostic, meaning they work in:

Node.js
Vite
webpack
esbuild
browser bundlers

The only exception is address() because it uses the Node.js os module.

Zero Dependencies

node-ip-ts intentionally has zero runtime dependencies.

This provides several benefits:

smaller install size
faster installs
lower supply-chain risk
easier auditing

Security tools like Snyk and Socket.dev can easily verify the package.

Designed for Modern TypeScript

The library is written entirely in TypeScript strict mode, providing:

accurate types
safer refactoring
better IDE autocomplete
fewer runtime errors

Example types:

type IPFamily = "ipv4" | "ipv6"

interface SubnetInfo {
  networkAddress: string
  firstAddress: string
  lastAddress: string
  broadcastAddress: string
  subnetMask: string
  subnetMaskLength: number
  numHosts: number
  length: number
  contains(other: string): boolean
}

Who Should Use `node-ip-ts`?

This library is useful if you are building:

backend APIs
security tools
IP allowlist / denylist systems
networking utilities
infrastructure tools
analytics pipelines
rate limiters

Especially if your project uses TypeScript.

Contributing

The project is open source and contributions are welcome.

You can:

report bugs
suggest features
submit pull requests

GitHub repository:

https://github.com/denycode-dev/ip-ts

Docs:

node-ip-ts — Type-safe IP Address Utility Library for Node.js

A modern, zero-dependency TypeScript rewrite of the ip package. Full ESM + CJS support, strict types, and drop-in API compatibility.

node-ip-ts.vercel.app

Try it out

If you're working with IP addresses in Node.js and want a modern TypeScript-first alternative to the classic ip library, give node-ip-ts a try.

⭐ If you find it useful, consider starring the repository.

npm install node-ip-ts

Solving Async Race Conditions in JavaScript with a 500B Library

Deni Irawan Nugraha — Thu, 05 Mar 2026 06:40:27 +0000

Solving Async Race Conditions in JavaScript with a 500B Library

JavaScript is single-threaded, but race conditions still happen.

Any time multiple asynchronous operations modify the same resource, you risk inconsistent state.

Examples include:

double charging a customer
processing the same webhook twice
creating duplicate database records
cache stampedes
concurrent file writes

To solve this problem, I built a tiny utility:

async-mutex-lite — a keyed async mutex for JavaScript & TypeScript.

🔒 Sequential execution per key
⚡ Parallel execution across different keys
📦 ~400–600 bytes gzip
🧩 Zero dependencies
🟦 Full TypeScript support

npm install async-mutex-lite

The Problem: Async Race Conditions

Consider a typical checkout endpoint.

Two requests arrive at nearly the same time for the same user.

app.post("/checkout", async (req) => {
  const balance = await getBalance(req.userId)

  if (balance >= req.amount) {
    await deductBalance(req.userId, req.amount)
    await createOrder(req.userId)
  }
})

What happens if both requests read the balance before either deducts it?

Request A -> balance = 100
Request B -> balance = 100

Request A deducts
Request B deducts

Now the balance has been deducted twice.

This is a classic race condition.

The Solution: Keyed Async Mutex

async-mutex-lite ensures tasks with the same key run sequentially, while tasks with different keys run in parallel.

import { mutex } from "async-mutex-lite"

app.post("/checkout", async (req) => {
  await mutex(`checkout:${req.userId}`, async () => {
    const balance = await getBalance(req.userId)

    if (balance >= req.amount) {
      await deductBalance(req.userId, req.amount)
      await createOrder(req.userId)
    }
  })
})

Now the execution becomes:

checkout:user1 -> taskA -> taskB -> taskC (sequential)
checkout:user2 -> taskD (parallel)

Requests for the same user are queued.

Requests for different users still run concurrently.

How It Works Internally

Instead of maintaining a traditional queue, the library uses Promise chaining.

Each key has its own promise chain.

mutex("user:1", taskA)  ─┐
mutex("user:1", taskB)  ─┼─► taskA → taskB → taskC
mutex("user:1", taskC)  ─┘

mutex("user:2", taskD)  ───► taskD

Benefits of this approach:

minimal code
extremely small bundle size
FIFO execution
automatic cleanup
no memory leaks

Basic Usage

Using the mutex is simple.

import { mutex } from "async-mutex-lite"

const result = await mutex("my-key", async () => {
  const data = await fetchSomething()
  return data
})

Synchronous functions also work:

const value = await mutex("my-key", () => {
  return 42
})

Real World Use Cases

Prevent Double Charges

await mutex(`wallet:${userId}`, async () => {
  await processPayment(userId, amount)
})

Prevent Duplicate Webhook Processing

await mutex(`webhook:${webhookId}`, async () => {
  await processWebhook(webhookId)
})

Cache Stampede Protection

async function getUser(userId: string) {
  if (cache.has(userId)) return cache.get(userId)

  return mutex(`cache:${userId}`, async () => {
    if (cache.has(userId)) return cache.get(userId)

    const user = await db.findUser(userId)
    cache.set(userId, user)

    return user
  })
}

Inventory Updates

await mutex(`product:${productId}`, async () => {
  const stock = await getStock(productId)

  if (stock > 0) {
    await decrementStock(productId)
  }
})

Error Handling Strategy

The library supports configurable error handling.

Default: `"continue"`

The queue continues even if a task fails.

await mutex("key", () => {
  throw new Error("failed")
}).catch(console.error)

await mutex("key", () => {
  console.log("this task still runs")
})

`"stop"` Strategy

Stop all queued tasks when an error occurs.

await mutex("key", () => {
  throw new Error("failed")
}, { onError: "stop" }).catch(console.error)

await mutex("key", () => {
  console.log("this will never run")
})

This is useful for transaction-like workflows.

When Should You Use It?

Good use cases:

financial transactions
idempotent APIs
webhook processing
per-user locking
cache rebuilding
inventory updates
sequential file writes

When You Should NOT Use It

Mutexes are unnecessary for:

stateless operations
pure read queries
CPU-bound workloads
operations that are already sequential

A mutex only helps when multiple async tasks modify the same resource.

Why `async-mutex-lite`?

Many mutex libraries exist, but most of them are heavier than necessary.

Library	Size	Keyed Lock	Error Strategy	TypeScript
async-lock	~5 KB	✅	❌	Partial
async-mutex	~3 KB	❌	❌	✅
await-lock	~1 KB	❌	❌	❌
async-mutex-lite	~0.5 KB	✅	✅	✅

Goals of this library:

minimal bundle size
modern TypeScript support
simple API
zero dependencies

Serverless Note

This mutex works within a single process.

In serverless environments:

each instance has its own memory
mutex only applies inside that instance

If you need cross-instance locking, use:

Redis locks
database transactions
distributed lock systems

Try It Out

If you're dealing with async race conditions in JavaScript, this tiny utility might save you a lot of headaches.

npm install async-mutex-lite

GitHub:

https://github.com/denycode-dev/async-mutex-lite

NPM:

https://npmjs.com/package/async-mutex-lite

Docs:

https://async-mutex-lite.vercel.app/

⭐ If you find it useful, consider giving the repository a star.

Forem: Deni Irawan Nugraha

Introducing node-ip-ts: A Modern Type-Safe IP Utility Library for Node.js

What is node-ip-ts?

Why create another IP library?

Example Usage

Address Classification

Working with CIDR and Subnets

Bitwise Operations on IP Addresses

Converting IP Addresses

Works in Node.js and the Browser

Zero Dependencies

Designed for Modern TypeScript

Who Should Use node-ip-ts?

Contributing

node-ip-ts — Type-safe IP Address Utility Library for Node.js

Try it out

Solving Async Race Conditions in JavaScript with a 500B Library

Solving Async Race Conditions in JavaScript with a 500B Library

The Problem: Async Race Conditions

The Solution: Keyed Async Mutex

How It Works Internally

Basic Usage

Real World Use Cases

Prevent Double Charges

Prevent Duplicate Webhook Processing

Cache Stampede Protection

Inventory Updates

Error Handling Strategy

Default: "continue"

"stop" Strategy

When Should You Use It?

When You Should NOT Use It

Why async-mutex-lite?

Serverless Note

Try It Out

What is `node-ip-ts`?

Who Should Use `node-ip-ts`?

Default: `"continue"`

`"stop"` Strategy

Why `async-mutex-lite`?