Bun v0.5 | Bun Weblog

Bun v0.5 is full of new options together with npm workspaces, Bun.dns, and help for node:readline. There’s improved compatibility with node:tls and node:internet so a number of database drivers now work in Bun for the primary time, together with Postgres.js, mysql2, node-redis, and others. Bun additionally continues to get quicker and extra secure — Buffer instantiation is 10x quicker, crypto.createHasher() is 50x quicker, and bun set up bought dozens of bugfixes.

# Set up Bun
curl https://bun.sh/set up | bash

# Improve to newest launch of Bun
bun improve

Bun now helps workspaces in bundle.json, and it is quick. Bun installs the Remix monorepo in about 500ms on Linux.

• 28x quicker than npm set up
• 12x quicker than yarn set up (v1)
• 8x quicker than pnpm set up

What are workspaces?

Workspaces make it simple to develop advanced software program as a monorepo consisting of a number of impartial packages. To strive it, specify an inventory of sub-packages within the workspaces subject of your bundle.json; it is typical to put these sub-packages in a listing known as packages.

{
  "identify": "my-project",
  "model": "1.0.0",
  "workspaces": ["packages/a", "packages/b"]
}

This has a pair main advantages.

• Code could be break up into logical components. If one bundle depends on one other, you may merely add it as a dependency with bun add. If bundle b depends upon a, bun set up will symlink your native packages/a listing into the node_modules folder of b, as an alternative of attempting to obtain it from the npm registry.
• Dependencies could be de-duplicated. If a and b share a standard dependency, it will likely be hoisted to the basis node_modules listing. This reduces redundant disk utilization and minimizes “dependency hell” points related to having a number of variations of a bundle put in concurrently.

Bun can now resolve domains utilizing the built-in Bun.dns API. In the intervening time, Bun.dns exposes a single perform: lookup.

import { dns } from "bun";

const information = await dns.lookup("instance.com", { household: 4 });
console.log(information); // [{ address: "93.184.216.34" }]

We have additionally added a minimal implementation of Node.js’ node:dns that makes use of Bun.dns beneath the hood. It is powered by c-ares and non-blocking getaddrinfo on MacOS.

import { resolve4 } from "node:dns/guarantees";

const information = await resolve4("instance.com");
console.log(information); // [ "93.184.216.34" ]

Bun now helps the creation of sockets utilizing net.connect() and tls.connect(). This unblocks a number of database driver libraries. A handful of consultant examples:

Hook up with Postgres in Bun utilizing Postgres.js by @porsager:

import postgres from "postgres";

const sql = postgres();
const [{ version }] = await sql`SELECT model()`;

console.log(model); // "PostgreSQL 14.2 ..."

Hook up with MySQL in Bun utilizing mysql2 shopper by @sidorares:

import { createConnection } from "mysql2/promise";

const connection = await createConnection({
  host: "localhost",
  consumer: "root",
  database: "take a look at",
});

const [rows] = await connection.execute("SELECT 1+2 AS rely");
console.log(rows); // [{ count: 3 }]

Hook up with Redis from Bun utilizing the official Node.js client:

import { createClient } from "redis";

const shopper = createClient();
await shopper.join();

await shopper.set("key", "Hiya!");
const worth = await shopper.get("key");

console.log(worth); // "Hiya!"

Bulding CLI instruments must be a lot simpler now that Bun helps the node:readline module.

import * as readline from "node:readline/guarantees";

const rl = readline.createInterface({
  enter: course of.stdin,
  output: course of.stdout,
  terminal: true,
});

const reply = await rl.query("How briskly is Bun from 1 to 10?n");
if (parseInt(reply) > 10) {
  console.log("Good reply!");
}

Operating this script yields:

$ bun readline.ts
How briskly is Bun from 1 to 10?
> 11
Good reply!

A long-standing function request on the WebSocket spec is the power to set customized headers when opening a WebSocket. Whereas this hasn’t but landed within the WebSocket commonplace, Bun now implements it. This permits customers to customise the headers used for the WebSocket shopper handshake request.

const ws = new WebSocket("ws://localhost/chat", {
  headers: {
    Authorization: "...",
  },
});

Whereas bun wiptest remains to be a piece in progress, we proceed to extend Bun’s compatibility with Jest.

test.skip()

You need to use test.skip() to skip undesirable exams.

import { describe, take a look at, count on } from "bun:take a look at";

describe("fetch()", () => {
  take a look at.skip("can hook up with localhost", async () => {
    const response = await fetch("http://localhost");
    count on(response.okay).toBe(true);
  });

  take a look at("can hook up with instance.com", async () => {
    const response = await fetch("http://instance.com");
    count on(response.okay).toBe(true);
  });
});

If you skip a take a look at, it would seem as grayed out within the take a look at output.

expect(fn).toThrow()

You need to use expect(fn).toThrow() to catch anticipated errors.

import { take a look at, count on } from "bun:take a look at";

take a look at("catch error", async () => {
  count on(() => {
    throw new Error();
  }).toThrow();
});

describe labels are included in the output

Beforehand, nested describe labels weren’t included within the take a look at runner output. Due to @ethanburrell, this has been fastened.

Earlier than:

After:

✓ outer > inside > my take a look at

Check file:

See Also

Amazon’s Fallout TV sequence will get a 2024 launch date

import { describe, take a look at } from "bun:take a look at";

describe("outer", () => {
  describe("inside", () => {
    take a look at("my take a look at", () => {});
  });
});

10x faster new Buffer()

Beforehand, the Buffer implementation in Bun was utilizing Object.setPrototypeOf() to create every new occasion. Eliminating this bottleneck makes it 10x quicker to instantiate a small Buffer in Bun.

50x faster crypto.createHash()

Beforehand, Bun was utilizing a pure JavaScript implementation of crypto.createHash(). Now it is applied utilizing native code from BoringSSL, yielding a 50x pace enchancment.

Bun will now acknowledge the HTTPS_PROXY, HTTP_PROXY, and NO_PROXY enviroment variables when making outgoing HTTP requests, which incorporates fetch() and bun set up. These variables can help you specify a proxy to ahead, or not ahead, sure HTTP requests and are helpful when operating Bun inside a company firewall.

export HTTPS_PROXY="http://proxy.instance.com:8080"
export NO_PROXY="localhost,noproxy.instance.com"

If you wish to be taught extra about these variables, GitLab wrote a pleasant explainer.

There are two modifications to module decision which will influence a number of packages.

1. Bun now not checks the browser property in bundle.json. It’s because some packages would disable Node.js performance, which isn’t what we wish for Bun.
2. For higher Node.js & npm compatibility, Bun’s JavaScript runtime now reads the "node" export situation in bundle.json exports.

The order Bun’s JavaScript runtime reads bundle.json "exports" situations is:

["bun", "worker", "module", "node", "browser", "default"];

Because of this if a bundle has a "node" export situation, it will likely be used as an alternative of the "default" or "browser" export situation.

Whereas we proceed so as to add new options to Bun, we’re nonetheless targeted on enhancing stability and fixing bugs. This launch fixes plenty of points

Fixes to bun install

A number of bugs with Bun’s bundle supervisor are fastened on this launch, principally by @alexlamsl. Thanks Alex!

New APIs

Additional fixes

Thanks to everybody who contributed to Bun v0.5!