Deno 2 in Practice: Node Compatibility, JSR, and Whether It's Finally Ready | Akousa

typescript

// This works in Deno 2. No flags, no configuration.
import express from "npm:express";
import { readFile } from "node:fs/promises";
 
const app = express();
 
app.get("/", async (req, res) => {
  const content = await readFile("./data.json", "utf-8");
  res.json(JSON.parse(content));
});
 
app.listen(3000);

typescript

// server.ts
import { Hono } from "npm:hono@4";
import { z } from "npm:zod@3";
 
const app = new Hono();
 
const UserSchema = z.object({
  name: z.string().min(1),
  email: z.string().email(),
});
 
app.post("/users", async (c) => {
  const body = await c.req.json();
  const result = UserSchema.safeParse(body);
 
  if (!result.success) {
    return c.json({ errors: result.error.flatten() }, 400);
  }
 
  return c.json({ user: result.data }, 201);
});
 
export default app;

json

{
  "imports": {
    "hono": "npm:hono@^4",
    "zod": "npm:zod@^3",
    "@std/path": "jsr:@std/path@^1",
    "@std/assert": "jsr:@std/assert@^1"
  },
  "tasks": {
    "dev": "deno run --watch --allow-net --allow-read --allow-env main.ts",
    "test": "deno test --allow-net --allow-read",
    "lint": "deno lint",
    "fmt": "deno fmt"
  }
}

typescript

// mod.ts
/**
 * Calculates the rolling average of a numeric array.
 * @param values - The array of numbers
 * @param window - The rolling window size
 */
export function rollingAverage(values: number[], window: number): number[] {
  if (window <= 0 || window > values.length) {
    throw new RangeError("Window size must be between 1 and array length");
  }
 
  const result: number[] = [];
  for (let i = window - 1; i < values.length; i++) {
    const slice = values.slice(i - window + 1, i + 1);
    const avg = slice.reduce((a, b) => a + b, 0) / window;
    result.push(avg);
  }
  return result;
}

typescript

import { join, resolve } from "@std/path";
import { parse } from "@std/csv";
import { assertEquals } from "@std/assert";
import { delay } from "@std/async";
import { encodeBase64 } from "@std/encoding";

bash

# Deny everything (default)
deno run server.ts
 
# Grant specific permissions
deno run --allow-net=0.0.0.0:3000,api.example.com --allow-read=./data --allow-env=DATABASE_URL server.ts
 
# Grant broad permissions (development mode)
deno run --allow-all server.ts

json

// deno.json -- the few things you can configure
{
  "fmt": {
    "useTabs": false,
    "lineWidth": 100,
    "indentWidth": 2,
    "singleQuote": false,
    "proseWrap": "always",
    "exclude": ["vendor/"]
  }
}

typescript

// deno lint catches this
const x = 1;
if ((x = 2)) {
  // Suspicious assignment in condition
  console.log("oops");
}
 
// And this
const arr = [1, 2, 3];
for (const i in arr) {
  // for-in on array
  console.log(arr[i]);
}

typescript

// math_test.ts
import { assertEquals, assertThrows } from "@std/assert";
 
Deno.test("rollingAverage computes correctly", () => {
  const result = rollingAverage([1, 2, 3, 4, 5], 3);
  assertEquals(result, [2, 3, 4]);
});
 
Deno.test("rollingAverage rejects invalid window", () => {
  assertThrows(() => rollingAverage([1, 2, 3], 0), RangeError, "Window size must be between 1 and array length");
});
 
Deno.test({
  name: "async test with permissions",
  permissions: { net: true },
  fn: async () => {
    const response = await fetch("https://httpbin.org/get");
    assertEquals(response.status, 200);
    await response.body?.cancel();
  },
});

bash

deno test                          # run all tests
deno test --filter "rollingAvg"    # filter by name
deno test --parallel               # run in parallel
deno test --coverage=./coverage    # with coverage
deno test --watch                  # re-run on changes
deno test --doc                    # test code blocks in JSDoc/markdown

typescript

// parse_bench.ts
Deno.bench("JSON.parse small object", () => {
  JSON.parse('{"name": "test", "value": 42}');
});
 
Deno.bench("JSON.parse large array", () => {
  JSON.parse(JSON.stringify(Array.from({ length: 1000 }, (_, i) => i)));
});
 
Deno.bench({
  name: "custom parser",
  group: "parsing",
  baseline: true,
  fn: () => {
    customParse('{"name": "test", "value": 42}');
  },
});

json

{
  "tasks": {
    "dev": "deno run --watch --allow-all main.ts",
    "test": "deno test --allow-all --parallel",
    "build": "deno compile --output=myapp main.ts",
    "db:migrate": "deno run --allow-all scripts/migrate.ts",
    "check": "deno fmt --check && deno lint && deno test --allow-all"
  }
}

json

// Deno's default TypeScript config (you can override in deno.json)
{
  "compilerOptions": {
    "strict": true,
    "noImplicitAny": true,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true,
    "exactOptionalPropertyTypes": true
  }
}

typescript

// utils.ts
export function parseConnectionString(url: string): {
  host: string;
  port: number;
  database: string;
} {
  const parsed = new URL(url);
  return {
    host: parsed.hostname,
    port: parseInt(parsed.port, 10),
    database: parsed.pathname.slice(1),
  };
}
 
// main.ts
import { parseConnectionString } from "./utils.ts"; // .ts extension required in Deno
 
const config = parseConnectionString(Deno.env.get("DATABASE_URL")!);
console.log(`Connecting to ${config.host}:${config.port}/${config.database}`);

typescript

// All of these are built-in, matching browser APIs exactly
 
// Fetch API
const response = await fetch("https://api.example.com/data");
const data = await response.json();
 
// Web Streams
const readable = new ReadableStream({
  start(controller) {
    controller.enqueue(new TextEncoder().encode("Hello "));
    controller.enqueue(new TextEncoder().encode("World"));
    controller.close();
  },
});
 
// WebSocket
const ws = new WebSocket("wss://echo.websocket.org");
ws.onmessage = (event) => console.log(event.data);
 
// Crypto API
const key = await crypto.subtle.generateKey({ name: "AES-GCM", length: 256 }, true, ["encrypt", "decrypt"]);
 
const iv = crypto.getRandomValues(new Uint8Array(12));
const encrypted = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, new TextEncoder().encode("sensitive data"));
 
// URL Pattern (the new way to match URLs)
const pattern = new URLPattern({ pathname: "/users/:id" });
const match = pattern.exec("https://example.com/users/42");
console.log(match?.pathname.groups.id); // "42"
 
// Structured Clone
const original = { date: new Date(), map: new Map([["key", "value"]]) };
const clone = structuredClone(original);
 
// AbortController
const controller = new AbortController();
setTimeout(() => controller.abort(), 5000);
const res = await fetch("https://slow-api.example.com", {
  signal: controller.signal,
});
 
// Cache API
const cache = await caches.open("v1");
await cache.put("/api/data", new Response(JSON.stringify(data)));

my-api/
  src/
    index.ts
    routes/
      users.ts
      health.ts
    middleware/
      auth.ts
      rateLimit.ts
    db/
      client.ts
      queries.ts
    utils/
      logger.ts
      validation.ts
  package.json
  tsconfig.json
  .eslintrc.json
  .prettierrc
  jest.config.ts

json

{
  "imports": {
    "hono": "npm:hono@^4",
    "drizzle-orm": "npm:drizzle-orm@^0.30",
    "postgres": "npm:postgres@^3",
    "zod": "npm:zod@^3",
    "jose": "npm:jose@^5",
    "@std/assert": "jsr:@std/assert@^1",
    "@std/log": "jsr:@std/log@^0.224"
  },
  "tasks": {
    "dev": "deno run --watch --allow-net --allow-env --allow-read main.ts",
    "start": "deno run --allow-net=0.0.0.0:3000 --allow-env=DATABASE_URL,JWT_SECRET --allow-read=./public main.ts",
    "test": "deno test --allow-all --parallel",
    "check": "deno fmt --check && deno lint && deno check main.ts"
  },
  "fmt": {
    "lineWidth": 100
  },
  "lint": {
    "rules": {
      "exclude": ["no-explicit-any"]
    }
  }
}

typescript

// Before (Node.js)
import express from "express";
import { Pool } from "pg";
import jwt from "jsonwebtoken";
 
// After (Deno with import map)
import { Hono } from "hono";
import postgres from "postgres";
import * as jose from "jose";

typescript

// Before (Node.js)
import { readFile } from "fs/promises";
import { join } from "path";
import { createHash } from "crypto";
 
const configPath = join(process.cwd(), "config.json");
const config = JSON.parse(await readFile(configPath, "utf-8"));
const hash = createHash("sha256").update("data").digest("hex");
console.log(`PID: ${process.pid}`);
 
// After (Deno -- using web standards where possible)
const configPath = new URL("./config.json", import.meta.url);
const config = JSON.parse(await Deno.readTextFile(configPath));
const hashBuffer = await crypto.subtle.digest("SHA-256", new TextEncoder().encode("data"));
const hash = Array.from(new Uint8Array(hashBuffer))
  .map((b) => b.toString(16).padStart(2, "0"))
  .join("");
console.log(`PID: ${Deno.pid}`);

typescript

// Before (Jest)
import { describe, it, expect } from "@jest/globals";
 
describe("UserService", () => {
  it("should create a user", async () => {
    const user = await createUser({ name: "Test", email: "test@example.com" });
    expect(user.id).toBeDefined();
    expect(user.name).toBe("Test");
  });
});
 
// After (Deno test)
import { assertEquals, assertExists } from "@std/assert";
 
Deno.test("UserService - should create a user", async () => {
  const user = await createUser({ name: "Test", email: "test@example.com" });
  assertExists(user.id);
  assertEquals(user.name, "Test");
});
 
// Or with test steps for grouping:
Deno.test("UserService", async (t) => {
  await t.step("should create a user", async () => {
    const user = await createUser({ name: "Test", email: "test@example.com" });
    assertExists(user.id);
    assertEquals(user.name, "Test");
  });
 
  await t.step("should reject duplicate email", async () => {
    // ...
  });
});

typescript

// A complete API with database, scheduled tasks, and edge deployment
const kv = await Deno.openKv();
 
// HTTP handler
Deno.serve(async (req: Request) => {
  const url = new URL(req.url);
 
  if (url.pathname === "/api/visits") {
    const key = ["visits", "total"];
    const result = await kv.get<number>(key);
    const count = (result.value ?? 0) + 1;
    await kv.set(key, count);
    return Response.json({ visits: count });
  }
 
  return new Response("Not Found", { status: 404 });
});
 
// Cron job -- runs on Deploy
Deno.cron("cleanup old data", "0 0 * * *", async () => {
  const cutoff = Date.now() - 30 * 24 * 60 * 60 * 1000;
  const entries = kv.list({ prefix: ["logs"] });
  for await (const entry of entries) {
    if (entry.value && (entry.value as any).timestamp < cutoff) {
      await kv.delete(entry.key);
    }
  }
});

typescript

// routes/index.tsx -- server-rendered, zero JS sent to client
export default function Home() {
  return (
    <div>
      <h1>Welcome to Fresh</h1>
      <p>This page sends zero bytes of JavaScript to the browser.</p>
      <Counter start={0} />
    </div>
  );
}
 
// islands/Counter.tsx -- this component hydrates on the client
import { useSignal } from "@preact/signals";
 
export default function Counter({ start }: { start: number }) {
  const count = useSignal(start);
  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={() => count.value++}>Increment</button>
    </div>
  );
}

Runtime	Req/s (p50)	Latency (p99)	Memory
Node.js 22 (Fastify)	48,200	4.1ms	82MB
Deno 2 (Hono)	52,800	3.7ms	71MB
Bun 1.2 (Hono)	71,400	2.8ms	64MB

Runtime	Req/s (p50)	Latency (p99)	Memory
Node.js 22 (Fastify)	8,400	23ms	105MB
Deno 2 (Hono)	8,100	25ms	94MB
Bun 1.2 (Hono)	9,200	21ms	88MB

Runtime	Cold Start
Node.js 22	180ms
Deno 2	140ms
Bun 1.2	85ms

Deno 2 in Practice: Node Compatibility, JSR, and Whether It's Finally Ready

The Deno 1 Problem, Honestly#

Deno 2's Big Bet: Full Node.js Compatibility#

npm Support in Practice#

The Minimal Approach (No package.json)#

The package.json Approach#

The deno.json Approach (Recommended)#

JSR: The New Registry#

The Permission System in Practice#

Built-in Tooling: The Underrated Advantage#

Formatter (`deno fmt`)#

Linter (`deno lint`)#

Test Runner (`deno test`)#

Benchmarking (`deno bench`)#

Task Runner#

TypeScript: Actually First-Class#

Web Standard APIs#

Migrating From Node.js: A Real Example#

Step 1: Replace Configuration Files#

Step 2: Update Imports#

Step 3: Replace Node.js-Specific APIs#

Step 4: Update Tests#

What Broke#

Deno Deploy#

Fresh: Deno's Web Framework#

Performance: Deno vs Node.js vs Bun#

HTTP Throughput (requests/second, simple JSON response)#

With Database Queries (PostgreSQL, 10 concurrent)#

Cold Start Time#

Startup and Compile Performance#

Ecosystem Gaps That Still Matter#

When to Choose Deno 2#

My Verdict#

Artículos relacionados

Regex Cheat Sheet 2026 — Regular Expressions Made Simple

TypeScript Compiler API: Building Custom Linters, Codemods, and Type Analyzers

The Deno 1 Problem, Honestly#

Deno 2's Big Bet: Full Node.js Compatibility#

npm Support in Practice#

The Minimal Approach (No package.json)#

The package.json Approach#

The deno.json Approach (Recommended)#

JSR: The New Registry#

The Permission System in Practice#

Built-in Tooling: The Underrated Advantage#

Formatter (deno fmt)#

Linter (deno lint)#

Test Runner (deno test)#

Benchmarking (deno bench)#

Task Runner#

TypeScript: Actually First-Class#

Web Standard APIs#

Migrating From Node.js: A Real Example#

Step 1: Replace Configuration Files#

Step 2: Update Imports#

Step 3: Replace Node.js-Specific APIs#

Step 4: Update Tests#

What Broke#

Deno Deploy#

Fresh: Deno's Web Framework#

Performance: Deno vs Node.js vs Bun#

HTTP Throughput (requests/second, simple JSON response)#

With Database Queries (PostgreSQL, 10 concurrent)#

Cold Start Time#

Startup and Compile Performance#

Ecosystem Gaps That Still Matter#

When to Choose Deno 2#

My Verdict#

Artículos relacionados

Regex Cheat Sheet 2026 — Regular Expressions Made Simple

TypeScript Compiler API: Building Custom Linters, Codemods, and Type Analyzers

Formatter (`deno fmt`)#

Linter (`deno lint`)#

Test Runner (`deno test`)#

Benchmarking (`deno bench`)#