import { serve, sql } from "bun";

const server = serve({
  port: 3000,
  routes: {
    "/": new Response("Welcome to Bun!"),
    "/api/users/:id": async req => {
      const [user] = await sql`SELECT * FROM users WHERE id = ${req.params.id}`;
      return Response.json(user);
    },
  },
});

console.log(`Listening on ${server.url}`);

Bun.serve({
  fetch(req, server) {
    if (server.upgrade(req, { data: { room: "lobby" } })) return;
    return new Response("Expected a WebSocket", { status: 400 });
  },
  websocket: {
    open(ws) {
      ws.subscribe(ws.data.room);
    },
    message(ws, message) {
      // broadcast to everyone in the room
      ws.publish(ws.data.room, message);
    },
  },
});

import { sql } from "bun";

// Parameters are escaped automatically
const active = await sql`
  SELECT * FROM users
  WHERE active = ${true}
  LIMIT 10
`;

// Insert with object notation
const [user] = await sql`
  INSERT INTO users ${sql({ name: "Alice", email: "[email protected]" })}
  RETURNING *
`;

import { redis } from "bun";

await redis.set("greeting", "Hello from Bun!");
const greeting = await redis.get("greeting");

await redis.hset("user:1", { name: "Alice", plan: "pro" });
await redis.expire("user:1", 3600);

const subscriber = redis.duplicate();
await subscriber.subscribe("events", message => {
  console.log("event:", message);
});

import { s3 } from "bun";

const file = s3.file("uploads/avatar.png");

await file.write(await Bun.file("./avatar.png").bytes(), {
  type: "image/png",
});

const url = file.presign({ expiresIn: 3600 });
const exists = await file.exists();

import { $ } from "bun";

// Works the same on macOS, Linux and Windows
const branch = await $`git rev-parse --abbrev-ref HEAD`.text();

await $`bun run build`;

// Pipe a fetch() Response straight through gzip
const res = await fetch("https://example.com/data.json");
await $`gzip -9 < ${res} > data.json.gz`;

console.log(`deployed ${branch.trim()}`);

import { describe, expect, mock, test } from "bun:test";

describe("math", () => {
  test("addition", () => {
    expect(2 + 2).toBe(4);
  });

  test.concurrent("fetches a user", async () => {
    const res = await fetch("https://api.example.com/users/1");
    expect(res.status).toBe(200);
  });

  test("mocks", () => {
    const fn = mock(() => 42);
    fn();
    expect(fn).toHaveBeenCalledTimes(1);
  });
});

const password = "super-secure-pa$$word";

const hash = await Bun.password.hash(password);
// => $argon2id$v=19$m=65536,t=2,p=1$tFq+9AVr1bf...

const ok = await Bun.password.verify(password, hash);
// => true

const legacy = await Bun.password.hash(password, {
  algorithm: "bcrypt",
  cost: 12,
});

import { serve } from "bun";
import homepage from "./index.html";
import dashboard from "./dashboard.html";

serve({
  routes: {
    "/": homepage,
    "/dashboard": dashboard,
    "/api/health": () => Response.json({ ok: true }),
  },
  development: {
    hmr: true,      // hot module reloading
    console: true,  // stream browser logs to this terminal
  },
});

import { dlopen, FFIType, suffix } from "bun:ffi";

// "dylib" on macOS, "so" on Linux, "dll" on Windows
const lib = dlopen(`libsqlite3.${suffix}`, {
  sqlite3_libversion: {
    args: [],
    returns: FFIType.cstring,
  },
});

console.log(`SQLite ${lib.symbols.sqlite3_libversion()}`);