Bun v0.8.0

const server = Bun.serve({
  fetch(req){
    console.log(req.url);
    return new Response("Hello world!");
  }
});

console.log(`Listening on https://127.0.0.1:${server.port}`);

const res = await fetch("https://example.com/bigfile.txt");

// read the response chunk-by-chunk!
for await (const chunk of res.body) {
  console.log(chunk);
}

import OpenAI from "openai";

const openai = new OpenAI({
  apiKey: "my api key",
});

const stream = await openai.chat.completions.create({
  model: "gpt-4",
  messages: [{ role: "user", content: "Say this is a test" }],
  stream: true,
});

for await (const part of stream) {
  process.stdout.write(part.choices[0]?.delta?.content || "");
}

import { serve, sleep } from "bun";
serve({
  fetch(req) {
    return new Response(
      new ReadableStream({
        async pull(controller) {
          for (let i = 0; i < 20; i++) {
            controller.enqueue("Hello world!");
            await sleep(42);
          }

          controller.close();
        },
      }),
    );
  },
});

// Hello World!Hello World!Hello World!...[~840ms]

import { serve, sleep } from "bun";
serve({
  fetch(req) {
    return new Response(
      new ReadableStream({
        async pull(controller) {
          for (let i = 0; i < 20; i++) {
            controller.enqueue("Hello world!");
            await sleep(42);
          }

          controller.close();
        },
      }),
    );
  },
});

// Hello world! [42ms]
// Hello world! [42ms]
// Hello world! [42ms]

import { serve, sleep } from "bun";
serve({
  port: 3000,
  fetch(req) {
    return new Response(
      new ReadableStream({
        // bun specific option
        type: "direct",

        async pull(controller) {
          for (let i = 0; i < 20; i++) {
            controller.write("Hello world!");

            // in bun < 0.8.0, flush() was required
            controller.flush();

            // now bun will automatically flush pending writes once the microtask queue is drained
            await sleep(42);
          }

          controller.end();
        },
      }),
    );
  },
});

// Hello world! [42ms]
// Hello world! [42ms]
// Hello world! [42ms]
// Hello world! [42ms]

process.stdin.setRawMode(true);

describe.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])("add(%i, %i)", (a, b, expected) => {
  test(`returns ${expected}`, () => {
    expect(a + b).toBe(expected);
  });
});

const isOdd = (value: number) => value % 2 !== 0;
it("toSatisfy", () => {
  expect(1).toSatisfy(isOdd);
  expect(2).not.toSatisfy(isOdd);
});

test("toIncludeRepeated", () => {
  // check if string contains substring exactly 2 times
  expect("hello hello").toIncludeRepeated("hello", 2);
  // works with .not
  expect("hello hello world").not.toIncludeRepeated("hello", 1);
});

class Password {
  value: string;
  constructor(value: string) {
    this.value = value;
  }
  [Bun.inspect.custom]() {
    return "Password <********>";
  }
}

const p = new Password("secret");
console.log(p);
// => "Password <********>"

const file = new File(["hello world"], "hello.txt", {
  type: "text/plain",
  lastModified: Date.now() - 1000,
});

file.size; // 11
file.name; // "hello.txt"
file.type; // "text/plain"
file.lastModified; // 1693597759310573

const { json } = new Response(`"hello"`);
json();
// ^ TypeError: Expected `this` to be instanceof Response