Bun v1.2.3

import { serve, sql } from "bun";
import App from "./myReactSPA.html";

serve({
  port: 3000,
  routes: {
    "/*": App,
    "/api/users": {
      GET: async () => Response.json(await sql`SELECT * FROM users LIMIT 10`),

      POST: async (req) => {
        const { name, email } = await req.json();
        const [user] =
          await sql`INSERT INTO users (name, email) VALUES (${name}, ${email}) RETURNING *`;
        return Response.json(user);
      },
    },

    "/api/users/:id": async (req) => {
      const { id } = req.params;
      const [user] = await sql`SELECT * FROM users WHERE id = ${id} LIMIT 1`;
      if (!user) {
        return new Response("User not found", { status: 404 });
      }
      return Response.json(user);
    },
  },
});

bun install --analyze src/**/*.ts

export NODE_EXTRA_CA_CERTS="/path/to/full/bundle.crt"

const buffer = new ArrayBuffer(16, { maxByteLength: 32 });
const uint8 = new Uint8Array(buffer);
buffer.resize(32); // Now works correctly

let b = Buffer.allocUnsafe(4);
b.fill("1234");
b.specialnumber = 42;
console.log(b);

 ❯ bun ./test.js
-Buffer(4) [ 49, 50, 51, 52 ]
+<Buffer 31 32 33 34, specialnumber: 42>

// napi_is_buffer() now correctly returns true for:
new Uint8Array();
new BigUint64Array();
Buffer.alloc(0);
new DataView(new ArrayBuffer());

// napi_is_typedarray() returns true for:
new Uint8Array();
new BigUint64Array();

// These now work in single-file executables:
import { promises as fs } from "node:fs";
import myEmbeddedFile from "./myEmbeddedFile.txt" with {type: "file"};
await fs.readFile(myEmbeddedFile);
await fs.stat(myEmbeddedFile);

import fs from "node:fs";
fs.readFileSync(myEmbeddedFile);
fs.statSync(myEmbeddedFile);
fs.existsSync(myEmbeddedFile);

// Multiple statements in one query
await sql`
  SELECT 1;
  SELECT 2;
`.simple();

const sql = new SQL({
  // ... other options ...
  prepare: false, // Disable prepared statements
});

const result = await sql`SELECT ARRAY[0, 1, 2, 3, 4, 5, NULL]::integer[]`;
console.log(result[0].array); // [0, 1, 2, 3, 4, 5, null]

const strings = await sql`SELECT ARRAY['Hello', 'World', NULL]::text[]`;
console.log(strings[0].array); // ['Hello', 'World', null]

// ✅ Correct: Use as tagged template literal
const users = await sql`SELECT * FROM users`;

// ❌ Incorrect: Will throw ERR_POSTGRES_NOT_TAGGED_CALL
const users = await sql("SELECT * FROM users");

import { sql } from "bun";
import { expect } from "bun:test";

const result = await sql`SELECT 1.23::numeric`;
expect(result).toEqual([{ "?column?": "1.23" }]);

const sql = new SQL({
  url: "postgres://127.0.0.1:5432/mydb",
  idleTimeout: 30, // Won't disconnect while processing results
});

const results = await sql`SELECT * FROM large_table`;

// This now works correctly
const sql = new Bun.SQL(
  "postgres://user%40domain:pass%40word@localhost/db%40name",
);

// Create reusable query fragments
const orderBy = (field) => sql`ORDER BY ${sql(field)} DESC`;

// Use fragments in queries
const results = await sql`
  SELECT * FROM posts
  WHERE author_id = ${userId}
  ${shouldSort ? orderBy("created_at") : sql``}
`;

import { sql } from "bun";

// Memory is now properly released after each query
for (let i = 0; i < 1000; i++) {
  await sql`SELECT * FROM large_table WHERE id = ${i}`;
}

const reader = Bun.file(path).stream().getReader();
while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  console.log(value);
}

import { S3Client } from "bun";

const s3 = new S3Client({
  accessKeyId: "access-key",
  secretAccessKey: "secret-key",
  bucket: "my-bucket",
  virtualHostedStyle: true,
});

// Or specify the endpoint directly
const s3WithEndpoint = new S3Client({
  accessKeyId: "access-key",
  secretAccessKey: "secret-key",
  endpoint: "https://my-bucket.s3.us-east-1.amazonaws.com",
  virtualHostedStyle: true,
});

import { expect } from "bun:test";

const err1 = new Error("message");
err1.cause = "cause";
err1.extra = "data";

const err2 = new Error("message");
err2.cause = "cause";
err2.extra = "data";

expect(err1).toEqual(err2); // Now passes

{
  "name": "my-package",
  "version": "1.0.0",
  "files": ["./dist", "!./subdir", "./src/index.ts"]
}

[serve.static]
# Make all BUN_PUBLIC_* environment variables available to client-side code via process.env.BUN_PUBLIC_MY_VAR
env = "BUN_PUBLIC_*"

@-webkit-keyframes slide {
  from {
    transform: translateX(0);
  }
  to {
    transform: translateX(100px);
  }
}

const fileHandle = await fsPromises.open("file.txt", "w");
const fd = fileHandle.fd;

// Previously this would incorrectly close the fd
await Bun.file(fd).writer().end();

// Now the fd remains open for use
await fsPromises.close(fd);

// Before
{
"pkg1-1": "bin-1.js""pkg1-2": "bin-2.js"
}

// After
{
  "pkg1-1": "bin-1.js",
  "pkg1-2": "bin-2.js"
}

// Development (NODE_ENV=development)
import * as jsx from "react/jsx-dev-runtime";

// Production (NODE_ENV=production)
import * as jsx from "react/jsx-runtime";

import dgram from "node:dgram";

const socket = dgram.createSocket("udp4");
socket.addMembership("224.0.0.1"); // No longer crashes

// This now works correctly
process.stdin.ref();
process.stdin.unref();
process.stdin.ref();

process.stdin.on("readable", () => {
  const chunk = process.stdin.read();
  if (chunk !== null) {
    console.log(chunk.toString());
  }
});

// Simple logging decorator
function log(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = function (...args: any[]) {
    console.log(`Calling ${propertyKey} with:`, args);
    return originalMethod.apply(this, args);
  };
}
const kGreet = Symbol("greet");

class Example {
  @log
  [kGreet](name: string) {
    return `Hello ${name}!`;
  }
}

{
  "compilerOptions": {
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true
  }
}

const file = Bun.file("😀.txt");
await file.stat();
await file.delete();