Bun

curl -fsSL https://bun.sh/install | bash

# W WSL
curl -fsSL https://bun.sh/install | bash

brew install oven-sh/bun/bun

bun --version
# 1.x.x

# Instalacja zależności (jak npm install)
bun install

# Dodawanie pakietów
bun add react react-dom
bun add -d typescript @types/react  # dev dependency
bun add -g vercel                   # global

# Usuwanie pakietów
bun remove lodash

# Aktualizacja pakietów
bun update
bun update react

# Lista zainstalowanych
bun pm ls

# Cache
bun pm cache    # Pokaż cache
bun pm cache rm # Wyczyść cache

# Konwersja do yarn.lock (dla kompatybilności)
bun install --yarn

// package.json
{
  "name": "my-monorepo",
  "workspaces": [
    "packages/*",
    "apps/*"
  ]
}

# Instalacja w monorepo
bun install

# Dodawanie do konkretnego workspace
bun add lodash --filter my-package

# Uruchamianie skryptu w workspace
bun run --filter my-package build

# Uruchom plik TypeScript (bez transpilacji!)
bun run index.ts

# Uruchom skrypt z package.json
bun run dev
bun dev          # Skrót

# Hot reload (watch mode)
bun --watch run index.ts

# REPL
bun repl

// index.ts - działa natychmiast!
interface User {
  id: number
  name: string
  email: string
}

const users: User[] = [
  { id: 1, name: 'John', email: 'john@example.com' },
]

console.log(users)

bun run index.ts
# [{ id: 1, name: 'John', email: 'john@example.com' }]

// app.tsx
const App = () => (
  <div>
    <h1>Hello Bun!</h1>
    <p>JSX works out of the box</p>
  </div>
)

// Renderowanie do stringa
import { renderToString } from 'react-dom/server'
console.log(renderToString(<App />))

// server.ts
Bun.serve({
  port: 3000,

  fetch(request) {
    const url = new URL(request.url)

    // Routing
    if (url.pathname === '/') {
      return new Response('Hello Bun!')
    }

    if (url.pathname === '/json') {
      return Response.json({
        message: 'Hello JSON',
        timestamp: Date.now(),
      })
    }

    if (url.pathname === '/html') {
      return new Response('<h1>Hello HTML</h1>', {
        headers: { 'Content-Type': 'text/html' },
      })
    }

    // 404
    return new Response('Not Found', { status: 404 })
  },

  // Opcjonalne: obsługa błędów
  error(error) {
    return new Response(`Error: ${error.message}`, {
      status: 500,
    })
  },
})

console.log('Server running at http://localhost:3000')

Bun.serve({
  port: 3000,
  hostname: '0.0.0.0', // Dostępny z zewnątrz

  async fetch(request) {
    const url = new URL(request.url)
    const method = request.method

    // POST z body
    if (method === 'POST' && url.pathname === '/api/users') {
      const body = await request.json()
      return Response.json({ created: true, data: body }, { status: 201 })
    }

    // Query parameters
    if (url.pathname === '/search') {
      const query = url.searchParams.get('q')
      return Response.json({ query, results: [] })
    }

    // Headers
    if (url.pathname === '/auth') {
      const authHeader = request.headers.get('Authorization')
      if (!authHeader) {
        return new Response('Unauthorized', { status: 401 })
      }
      return Response.json({ authenticated: true })
    }

    // Static files
    if (url.pathname.startsWith('/static/')) {
      const filePath = `.${url.pathname}`
      const file = Bun.file(filePath)

      if (await file.exists()) {
        return new Response(file)
      }
      return new Response('File not found', { status: 404 })
    }

    // Streaming response
    if (url.pathname === '/stream') {
      const stream = new ReadableStream({
        async start(controller) {
          for (let i = 0; i < 5; i++) {
            controller.enqueue(`data: ${i}\n\n`)
            await Bun.sleep(1000)
          }
          controller.close()
        },
      })

      return new Response(stream, {
        headers: {
          'Content-Type': 'text/event-stream',
          'Cache-Control': 'no-cache',
        },
      })
    }

    return new Response('Not Found', { status: 404 })
  },
})

Bun.serve({
  port: 443,

  tls: {
    cert: Bun.file('./cert.pem'),
    key: Bun.file('./key.pem'),
  },

  fetch(request) {
    return new Response('Secure!')
  },
})

// Czytanie pliku
const file = Bun.file('./data.json')

// Metadane
console.log(file.name)        // 'data.json'
console.log(file.size)        // rozmiar w bajtach
console.log(file.type)        // 'application/json'

// Różne formaty odczytu
const text = await file.text()       // string
const json = await file.json()       // parsed JSON
const buffer = await file.arrayBuffer() // ArrayBuffer
const stream = file.stream()         // ReadableStream

// Sprawdzenie istnienia
if (await file.exists()) {
  console.log('File exists')
}

// Zapisywanie tekstu
await Bun.write('./output.txt', 'Hello World')

// Zapisywanie JSON
await Bun.write('./data.json', JSON.stringify({ name: 'John' }))

// Zapisywanie z Bun.file
const source = Bun.file('./source.txt')
await Bun.write('./copy.txt', source)

// Zapisywanie Response
const response = await fetch('https://example.com/image.png')
await Bun.write('./image.png', response)

// Zapisywanie Blob
const blob = new Blob(['Hello'], { type: 'text/plain' })
await Bun.write('./blob.txt', blob)

import { readdir, mkdir, rm } from 'fs/promises'

// Tworzenie katalogu
await mkdir('./new-folder', { recursive: true })

// Listowanie plików
const files = await readdir('./src')
console.log(files)

// Usuwanie
await rm('./temp', { recursive: true, force: true })

// Wbudowany glob
const glob = new Bun.Glob('**/*.ts')

// Synchronicznie
for (const file of glob.scanSync('./src')) {
  console.log(file)
}

// Asynchronicznie
for await (const file of glob.scan('./src')) {
  console.log(file)
}

// Match
const pattern = new Bun.Glob('*.{ts,tsx}')
pattern.match('app.ts')    // true
pattern.match('app.js')    // false

import { Database } from 'bun:sqlite'

// Tworzenie/otwieranie bazy
const db = new Database('myapp.db')
// lub w pamięci:
// const db = new Database(':memory:')

// Tworzenie tabeli
db.run(`
  CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    email TEXT UNIQUE NOT NULL,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
  )
`)

// Insert
const insert = db.prepare(`
  INSERT INTO users (name, email) VALUES ($name, $email)
`)

insert.run({ $name: 'John', $email: 'john@example.com' })
insert.run({ $name: 'Jane', $email: 'jane@example.com' })

// Select wszystko
const selectAll = db.prepare('SELECT * FROM users')
const users = selectAll.all()
console.log(users)
// [{ id: 1, name: 'John', ... }, { id: 2, name: 'Jane', ... }]

// Select jeden
const selectOne = db.prepare('SELECT * FROM users WHERE id = $id')
const user = selectOne.get({ $id: 1 })
console.log(user)
// { id: 1, name: 'John', email: 'john@example.com', ... }

// Update
const update = db.prepare('UPDATE users SET name = $name WHERE id = $id')
update.run({ $id: 1, $name: 'John Doe' })

// Delete
const deleteUser = db.prepare('DELETE FROM users WHERE id = $id')
deleteUser.run({ $id: 2 })

// Transakcje
const insertMany = db.transaction((users) => {
  for (const user of users) {
    insert.run(user)
  }
})

insertMany([
  { $name: 'Alice', $email: 'alice@example.com' },
  { $name: 'Bob', $email: 'bob@example.com' },
])

// Zamknięcie
db.close()

import { Database } from 'bun:sqlite'

class UserRepository {
  private db: Database

  constructor(dbPath: string) {
    this.db = new Database(dbPath)
    this.init()
  }

  private init() {
    this.db.run(`
      CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT NOT NULL,
        email TEXT UNIQUE NOT NULL
      )
    `)
  }

  create(name: string, email: string) {
    const stmt = this.db.prepare(
      'INSERT INTO users (name, email) VALUES (?, ?) RETURNING *'
    )
    return stmt.get(name, email)
  }

  findById(id: number) {
    const stmt = this.db.prepare('SELECT * FROM users WHERE id = ?')
    return stmt.get(id)
  }

  findByEmail(email: string) {
    const stmt = this.db.prepare('SELECT * FROM users WHERE email = ?')
    return stmt.get(email)
  }

  findAll(limit = 100, offset = 0) {
    const stmt = this.db.prepare('SELECT * FROM users LIMIT ? OFFSET ?')
    return stmt.all(limit, offset)
  }

  update(id: number, data: { name?: string; email?: string }) {
    const fields = []
    const values: any[] = []

    if (data.name) {
      fields.push('name = ?')
      values.push(data.name)
    }
    if (data.email) {
      fields.push('email = ?')
      values.push(data.email)
    }

    values.push(id)

    const stmt = this.db.prepare(
      `UPDATE users SET ${fields.join(', ')} WHERE id = ? RETURNING *`
    )
    return stmt.get(...values)
  }

  delete(id: number) {
    const stmt = this.db.prepare('DELETE FROM users WHERE id = ?')
    return stmt.run(id)
  }
}

const users = new UserRepository('app.db')
const newUser = users.create('John', 'john@example.com')
console.log(newUser)

// build.ts
await Bun.build({
  entrypoints: ['./src/index.ts'],
  outdir: './dist',
  minify: true,
  sourcemap: 'external',
  target: 'browser', // lub 'bun', 'node'

  // Splitting (code splitting)
  splitting: true,

  // External packages (nie bundluj)
  external: ['react', 'react-dom'],

  // Define (zamiana stałych)
  define: {
    'process.env.NODE_ENV': '"production"',
  },

  // Naming
  naming: {
    entry: '[dir]/[name].[hash].[ext]',
    chunk: '[name]-[hash].[ext]',
    asset: '[name]-[hash].[ext]',
  },
})

# Bundluj do pojedynczego pliku
bun build ./src/index.ts --outdir ./dist

# Z minifikacją
bun build ./src/index.ts --outdir ./dist --minify

# Watch mode
bun build ./src/index.ts --outdir ./dist --watch

# Compile to executable
bun build ./src/cli.ts --compile --outfile mycli

# Skompiluj do pojedynczego pliku wykonywalnego
bun build --compile ./src/cli.ts --outfile ./dist/mycli

# Dla różnych platform
bun build --compile --target=bun-linux-x64 ./src/cli.ts
bun build --compile --target=bun-darwin-arm64 ./src/cli.ts
bun build --compile --target=bun-windows-x64 ./src/cli.ts

// math.ts
export function add(a: number, b: number): number {
  return a + b
}

export function multiply(a: number, b: number): number {
  return a * b
}

export async function fetchData(url: string) {
  const response = await fetch(url)
  return response.json()
}

// math.test.ts
import { describe, it, expect, beforeAll, afterAll, mock } from 'bun:test'
import { add, multiply, fetchData } from './math'

describe('Math functions', () => {
  it('adds two numbers', () => {
    expect(add(2, 3)).toBe(5)
    expect(add(-1, 1)).toBe(0)
  })

  it('multiplies two numbers', () => {
    expect(multiply(2, 3)).toBe(6)
    expect(multiply(0, 100)).toBe(0)
  })
})

describe('Matchers', () => {
  it('demonstrates various matchers', () => {
    // Equality
    expect(1 + 1).toBe(2)
    expect({ a: 1 }).toEqual({ a: 1 })

    // Truthiness
    expect(true).toBeTruthy()
    expect(false).toBeFalsy()
    expect(null).toBeNull()
    expect(undefined).toBeUndefined()
    expect('hello').toBeDefined()

    // Numbers
    expect(10).toBeGreaterThan(5)
    expect(5).toBeLessThanOrEqual(5)
    expect(0.1 + 0.2).toBeCloseTo(0.3)

    // Strings
    expect('hello world').toContain('world')
    expect('hello').toMatch(/ell/)

    // Arrays
    expect([1, 2, 3]).toContain(2)
    expect([1, 2, 3]).toHaveLength(3)

    // Errors
    expect(() => { throw new Error('oops') }).toThrow('oops')
  })
})

describe('Async tests', () => {
  it('handles async/await', async () => {
    const result = await Promise.resolve(42)
    expect(result).toBe(42)
  })

  it('handles promises', () => {
    return Promise.resolve(42).then(result => {
      expect(result).toBe(42)
    })
  })
})

describe('Mocking', () => {
  it('mocks functions', () => {
    const mockFn = mock(() => 42)

    expect(mockFn()).toBe(42)
    expect(mockFn).toHaveBeenCalled()
    expect(mockFn).toHaveBeenCalledTimes(1)
  })

  it('mocks fetch', async () => {
    const originalFetch = globalThis.fetch

    globalThis.fetch = mock(() =>
      Promise.resolve(new Response(JSON.stringify({ data: 'mocked' })))
    )

    const result = await fetchData('https://api.example.com')
    expect(result).toEqual({ data: 'mocked' })

    globalThis.fetch = originalFetch
  })
})

describe('Lifecycle hooks', () => {
  let db: any

  beforeAll(() => {
    db = { connected: true }
  })

  afterAll(() => {
    db = null
  })

  it('uses setup from beforeAll', () => {
    expect(db.connected).toBe(true)
  })
})

# Uruchom wszystkie testy
bun test

# Konkretny plik
bun test math.test.ts

# Pattern matching
bun test --filter "Math"

# Watch mode
bun test --watch

# Coverage
bun test --coverage

# Timeout
bun test --timeout 5000

// .env
DATABASE_URL=postgres://localhost/mydb
API_KEY=secret123
DEBUG=true

// Użycie - automatyczne ładowanie
console.log(Bun.env.DATABASE_URL)  // 'postgres://localhost/mydb'
console.log(Bun.env.API_KEY)       // 'secret123'
console.log(process.env.DEBUG)     // 'true' (kompatybilność z Node.js)

// Sprawdzanie
if (Bun.env.NODE_ENV === 'production') {
  console.log('Production mode')
}

// Różne pliki .env
// .env.local, .env.development, .env.production
// są automatycznie ładowane

// WebSocket server
Bun.serve({
  port: 3000,

  fetch(request, server) {
    // Upgrade do WebSocket
    if (server.upgrade(request)) {
      return // Upgrade succeeded
    }

    return new Response('Not a WebSocket request', { status: 400 })
  },

  websocket: {
    open(ws) {
      console.log('Client connected')
      ws.send('Welcome!')
    },

    message(ws, message) {
      console.log('Received:', message)
      // Echo back
      ws.send(`You said: ${message}`)

      // Broadcast to all
      ws.publish('chat', message)
    },

    close(ws) {
      console.log('Client disconnected')
    },
  },
})

Bun.serve({
  port: 3000,

  fetch(request, server) {
    const url = new URL(request.url)
    const room = url.searchParams.get('room') || 'default'

    if (server.upgrade(request, { data: { room } })) {
      return
    }

    return new Response('Upgrade failed', { status: 400 })
  },

  websocket: {
    open(ws) {
      const room = ws.data.room
      ws.subscribe(room)
      ws.send(`Joined room: ${room}`)
    },

    message(ws, message) {
      const room = ws.data.room
      // Broadcast to room
      ws.publish(room, `[${room}] ${message}`)
    },

    close(ws) {
      const room = ws.data.room
      ws.unsubscribe(room)
    },
  },
})

// Async sleep
await Bun.sleep(1000) // 1 sekunda
await Bun.sleep(500)  // 500ms

// Szybkie hashowanie
const hash = Bun.hash('hello world')
console.log(hash) // number

// Różne algorytmy
Bun.hash.wyhash('data')
Bun.hash.adler32('data')
Bun.hash.crc32('data')
Bun.hash.cityHash32('data')
Bun.hash.cityHash64('data')
Bun.hash.murmur32v3('data')
Bun.hash.murmur64v2('data')

// Hashowanie haseł (bcrypt-like)
const hash = await Bun.password.hash('mypassword')
console.log(hash) // $argon2id$...

// Weryfikacja
const isValid = await Bun.password.verify('mypassword', hash)
console.log(isValid) // true

// Z opcjami
const customHash = await Bun.password.hash('mypassword', {
  algorithm: 'argon2id', // lub 'argon2d', 'argon2i', 'bcrypt'
  memoryCost: 65536,
  timeCost: 3,
})

// Uruchamianie procesów
const proc = Bun.spawn(['ls', '-la'])

// Czekanie na zakończenie
const output = await new Response(proc.stdout).text()
console.log(output)

// Z stdin
const proc2 = Bun.spawn(['cat'], {
  stdin: 'pipe',
})
proc2.stdin.write('Hello from Bun!')
proc2.stdin.end()

// Synchronicznie
const result = Bun.spawnSync(['echo', 'Hello'])
console.log(result.stdout.toString())

const transpiler = new Bun.Transpiler({
  loader: 'tsx',
})

const code = `
  const App: React.FC = () => <div>Hello</div>
  export default App
`

const result = transpiler.transformSync(code)
console.log(result)
// Transpilowany JavaScript

// Większość Node.js APIs działa
import fs from 'fs'
import path from 'path'
import crypto from 'crypto'
import { EventEmitter } from 'events'

// fs
const content = fs.readFileSync('./file.txt', 'utf-8')
fs.writeFileSync('./output.txt', 'Hello')

// path
const fullPath = path.join(__dirname, 'file.txt')
const ext = path.extname('file.txt') // '.txt'

// crypto
const hash = crypto.createHash('sha256').update('data').digest('hex')

// events
const emitter = new EventEmitter()
emitter.on('event', (data) => console.log(data))
emitter.emit('event', 'Hello!')

// process
console.log(process.cwd())
console.log(process.env.PATH)

// Express działa z Bun
import express from 'express'

const app = express()

app.use(express.json())

app.get('/', (req, res) => {
  res.json({ message: 'Hello from Express on Bun!' })
})

app.listen(3000, () => {
  console.log('Server running on port 3000')
})

# Next.js z Bun
bunx create-next-app my-app
cd my-app
bun dev

import { Hono } from 'hono'
import { serveStatic } from 'hono/bun'

const app = new Hono()

app.use('/static/*', serveStatic({ root: './public' }))
app.get('/', (c) => c.text('Hello Hono with Bun!'))

export default {
  port: 3000,
  fetch: app.fetch,
}

import { Elysia } from 'elysia'

const app = new Elysia()
  .get('/', () => 'Hello Elysia!')
  .get('/user/:id', ({ params: { id } }) => ({ userId: id }))
  .post('/users', ({ body }) => ({ created: body }))
  .listen(3000)

console.log(`Server running at ${app.server?.hostname}:${app.server?.port}`)

// package.json
{
  "scripts": {
    "dev": "bun --watch run src/index.ts",
    "build": "bun build src/index.ts --outdir dist --minify",
    "test": "bun test",
    "start": "bun run dist/index.js"
  }
}

# Uruchamianie
bun run dev    # lub po prostu: bun dev
bun run build
bun run test
bun run start

// Zamiast
import fs from 'fs'
const content = fs.readFileSync('file.txt', 'utf-8')

// Preferuj
const file = Bun.file('file.txt')
const content = await file.text()

// Zamiast zewnętrznych pakietów
import { Database } from 'bun:sqlite'

const db = new Database('app.db')

// types/bun.d.ts
declare module 'bun' {
  interface Env {
    DATABASE_URL: string
    API_KEY: string
    NODE_ENV: 'development' | 'production'
  }
}

# npx equivalent
bunx create-next-app
bunx prisma migrate dev
bunx eslint .

curl -fsSL https://bun.sh/install | bash

# In WSL
curl -fsSL https://bun.sh/install | bash

brew install oven-sh/bun/bun

bun --version
# 1.x.x

# Install dependencies (like npm install)
bun install

# Adding packages
bun add react react-dom
bun add -d typescript @types/react  # dev dependency
bun add -g vercel                   # global

# Removing packages
bun remove lodash

# Updating packages
bun update
bun update react

# List installed packages
bun pm ls

# Cache
bun pm cache    # Show cache
bun pm cache rm # Clear cache

# Convert to yarn.lock (for compatibility)
bun install --yarn

// package.json
{
  "name": "my-monorepo",
  "workspaces": [
    "packages/*",
    "apps/*"
  ]
}

# Install in monorepo
bun install

# Add to a specific workspace
bun add lodash --filter my-package

# Run a script in a workspace
bun run --filter my-package build

# Run a TypeScript file (no transpilation needed!)
bun run index.ts

# Run a script from package.json
bun run dev
bun dev          # Shorthand

# Hot reload (watch mode)
bun --watch run index.ts

# REPL
bun repl

// index.ts - works immediately!
interface User {
  id: number
  name: string
  email: string
}

const users: User[] = [
  { id: 1, name: 'John', email: 'john@example.com' },
]

console.log(users)

bun run index.ts
# [{ id: 1, name: 'John', email: 'john@example.com' }]

// app.tsx
const App = () => (
  <div>
    <h1>Hello Bun!</h1>
    <p>JSX works out of the box</p>
  </div>
)

// Rendering to string
import { renderToString } from 'react-dom/server'
console.log(renderToString(<App />))

// server.ts
Bun.serve({
  port: 3000,

  fetch(request) {
    const url = new URL(request.url)

    // Routing
    if (url.pathname === '/') {
      return new Response('Hello Bun!')
    }

    if (url.pathname === '/json') {
      return Response.json({
        message: 'Hello JSON',
        timestamp: Date.now(),
      })
    }

    if (url.pathname === '/html') {
      return new Response('<h1>Hello HTML</h1>', {
        headers: { 'Content-Type': 'text/html' },
      })
    }

    // 404
    return new Response('Not Found', { status: 404 })
  },

  // Optional: error handling
  error(error) {
    return new Response(`Error: ${error.message}`, {
      status: 500,
    })
  },
})

console.log('Server running at http://localhost:3000')

Bun.serve({
  port: 3000,
  hostname: '0.0.0.0', // Accessible from outside

  async fetch(request) {
    const url = new URL(request.url)
    const method = request.method

    // POST with body
    if (method === 'POST' && url.pathname === '/api/users') {
      const body = await request.json()
      return Response.json({ created: true, data: body }, { status: 201 })
    }

    // Query parameters
    if (url.pathname === '/search') {
      const query = url.searchParams.get('q')
      return Response.json({ query, results: [] })
    }

    // Headers
    if (url.pathname === '/auth') {
      const authHeader = request.headers.get('Authorization')
      if (!authHeader) {
        return new Response('Unauthorized', { status: 401 })
      }
      return Response.json({ authenticated: true })
    }

    // Static files
    if (url.pathname.startsWith('/static/')) {
      const filePath = `.${url.pathname}`
      const file = Bun.file(filePath)

      if (await file.exists()) {
        return new Response(file)
      }
      return new Response('File not found', { status: 404 })
    }

    // Streaming response
    if (url.pathname === '/stream') {
      const stream = new ReadableStream({
        async start(controller) {
          for (let i = 0; i < 5; i++) {
            controller.enqueue(`data: ${i}\n\n`)
            await Bun.sleep(1000)
          }
          controller.close()
        },
      })

      return new Response(stream, {
        headers: {
          'Content-Type': 'text/event-stream',
          'Cache-Control': 'no-cache',
        },
      })
    }

    return new Response('Not Found', { status: 404 })
  },
})