Stop Writing Manual Cleanup Logic: Explicit Resource Management (using) in Modern TypeScript
Every developer knows the standard ritual for handling disposables: initialize the resource, nest your logic in a try block, and remember to call .close(), .release(), or .dispose() inside a finally block.
One missed finally or an unhandled rethrow in an asynchronous generator, and your application quietly bleeds open sockets or file descriptors.
JavaScript and TypeScript now standardize resource lifecycle management directly at the syntax level through the TC39 Explicit Resource Management proposal (Symbol.dispose and Symbol.asyncDispose).
Instead of trusting developers to clean up manually:
The runtime binds the resource lifetime directly to the lexical block scope.
Disposal executes deterministically the microsecond the block terminates—whether by return, break, or a raised exception.
Nested resource cleanup happens in reverse order of initialization (LIFO), replicating RAII (Resource Acquisition Is Initialization) patterns from C++ and Rust.
The Coding Lesson: Refactoring to using
Before: Defensive try...finally nesting
TypeScript
async function processBatch(fileId: string) {
const client = await pool.connect();
const reader = await openTelemetrySpan("batch-process");
try {
const data = await client.query("SELECT * FROM jobs WHERE id = $1", [fileId]);
return transform(data);
} finally {
reader.end();
client.release(); // Forgetting this or throwing here leaks the connection
}
}
After: Deterministic Lexical Disposal with await using
Make your client implement Symbol.asyncDispose, then bind it with using:
TypeScript
// 1. Define the disposable interface
class ManagedConnection {
// ... connection logic
async [Symbol.asyncDispose]() {
await this.release();
}
}
// 2. Consume with zero cleanup overhead
async function processBatch(fileId: string) {
await using client = await pool.connect();
using span = openTelemetrySpan("batch-process");
const data = await client.query("SELECT * FROM jobs WHERE id = $1", [fileId]);
return transform(data);
// 'span' and 'client' dispose automatically in LIFO order right here!
}
How to Adopt It Today
Set "target": "ES2022" or later in your tsconfig.json.
Add "lib": ["ESNext.Disposable"] or run on modern Node.js / Bun runtimes.
Replace manual wrapper classes around connection pools, Redis locks, and file handlers with Symbol.dispose and Symbol.asyncDispose.
Discussion Question
Have you migrated your backend service layers to using declarations, or are you still relying on traditional wrapper classes and try...finally blocks? What is holding your team back from adopting modern disposables?
CTA
Join Developers & Coding: Connect with software engineers, systems architects, and developers mastering modern programming paradigms, language primitives, and clean architectures
Every developer knows the standard ritual for handling disposables: initialize the resource, nest your logic in a try block, and remember to call .close(), .release(), or .dispose() inside a finally block.
One missed finally or an unhandled rethrow in an asynchronous generator, and your application quietly bleeds open sockets or file descriptors.
JavaScript and TypeScript now standardize resource lifecycle management directly at the syntax level through the TC39 Explicit Resource Management proposal (Symbol.dispose and Symbol.asyncDispose).
Instead of trusting developers to clean up manually:
The runtime binds the resource lifetime directly to the lexical block scope.
Disposal executes deterministically the microsecond the block terminates—whether by return, break, or a raised exception.
Nested resource cleanup happens in reverse order of initialization (LIFO), replicating RAII (Resource Acquisition Is Initialization) patterns from C++ and Rust.
The Coding Lesson: Refactoring to using
Before: Defensive try...finally nesting
TypeScript
async function processBatch(fileId: string) {
const client = await pool.connect();
const reader = await openTelemetrySpan("batch-process");
try {
const data = await client.query("SELECT * FROM jobs WHERE id = $1", [fileId]);
return transform(data);
} finally {
reader.end();
client.release(); // Forgetting this or throwing here leaks the connection
}
}
After: Deterministic Lexical Disposal with await using
Make your client implement Symbol.asyncDispose, then bind it with using:
TypeScript
// 1. Define the disposable interface
class ManagedConnection {
// ... connection logic
async [Symbol.asyncDispose]() {
await this.release();
}
}
// 2. Consume with zero cleanup overhead
async function processBatch(fileId: string) {
await using client = await pool.connect();
using span = openTelemetrySpan("batch-process");
const data = await client.query("SELECT * FROM jobs WHERE id = $1", [fileId]);
return transform(data);
// 'span' and 'client' dispose automatically in LIFO order right here!
}
How to Adopt It Today
Set "target": "ES2022" or later in your tsconfig.json.
Add "lib": ["ESNext.Disposable"] or run on modern Node.js / Bun runtimes.
Replace manual wrapper classes around connection pools, Redis locks, and file handlers with Symbol.dispose and Symbol.asyncDispose.
Discussion Question
Have you migrated your backend service layers to using declarations, or are you still relying on traditional wrapper classes and try...finally blocks? What is holding your team back from adopting modern disposables?
CTA
Join Developers & Coding: Connect with software engineers, systems architects, and developers mastering modern programming paradigms, language primitives, and clean architectures
Stop Writing Manual Cleanup Logic: Explicit Resource Management (using) in Modern TypeScript
Every developer knows the standard ritual for handling disposables: initialize the resource, nest your logic in a try block, and remember to call .close(), .release(), or .dispose() inside a finally block.
One missed finally or an unhandled rethrow in an asynchronous generator, and your application quietly bleeds open sockets or file descriptors.
JavaScript and TypeScript now standardize resource lifecycle management directly at the syntax level through the TC39 Explicit Resource Management proposal (Symbol.dispose and Symbol.asyncDispose).
Instead of trusting developers to clean up manually:
The runtime binds the resource lifetime directly to the lexical block scope.
Disposal executes deterministically the microsecond the block terminates—whether by return, break, or a raised exception.
Nested resource cleanup happens in reverse order of initialization (LIFO), replicating RAII (Resource Acquisition Is Initialization) patterns from C++ and Rust.
The Coding Lesson: Refactoring to using
Before: Defensive try...finally nesting
TypeScript
async function processBatch(fileId: string) {
const client = await pool.connect();
const reader = await openTelemetrySpan("batch-process");
try {
const data = await client.query("SELECT * FROM jobs WHERE id = $1", [fileId]);
return transform(data);
} finally {
reader.end();
client.release(); // Forgetting this or throwing here leaks the connection
}
}
After: Deterministic Lexical Disposal with await using
Make your client implement Symbol.asyncDispose, then bind it with using:
TypeScript
// 1. Define the disposable interface
class ManagedConnection {
// ... connection logic
async [Symbol.asyncDispose]() {
await this.release();
}
}
// 2. Consume with zero cleanup overhead
async function processBatch(fileId: string) {
await using client = await pool.connect();
using span = openTelemetrySpan("batch-process");
const data = await client.query("SELECT * FROM jobs WHERE id = $1", [fileId]);
return transform(data);
// 'span' and 'client' dispose automatically in LIFO order right here!
}
How to Adopt It Today
Set "target": "ES2022" or later in your tsconfig.json.
Add "lib": ["ESNext.Disposable"] or run on modern Node.js / Bun runtimes.
Replace manual wrapper classes around connection pools, Redis locks, and file handlers with Symbol.dispose and Symbol.asyncDispose.
Discussion Question
Have you migrated your backend service layers to using declarations, or are you still relying on traditional wrapper classes and try...finally blocks? What is holding your team back from adopting modern disposables?
CTA
Join Developers & Coding: Connect with software engineers, systems architects, and developers mastering modern programming paradigms, language primitives, and clean architectures
English
French
Spanish
Portuguese
Deutsch
Turkish
Dutch
Italiano
Russian
Romaian
Portuguese (Brazil)
Greek