bun-types 1.3.2-canary.20251105T140650 → 1.3.2

package/docs/guides/ecosystem/{drizzle.md → drizzle.mdx}

@@ -1,5 +1,7 @@
 ---
-name: Use Drizzle ORM with Bun
+title: Use Drizzle ORM with Bun
+sidebarTitle: Drizzle with Bun
+mode: center
 ---
 
 Drizzle is an ORM that supports both a SQL-like "query builder" API and an ORM-like [Queries API](https://orm.drizzle.team/docs/rqb). It supports the `bun:sqlite` built-in module.
@@ -8,17 +10,17 @@ Drizzle is an ORM that supports both a SQL-like "query builder" API and an ORM-l
 
 Let's get started by creating a fresh project with `bun init` and installing Drizzle.
 
-```sh
-$ bun init -y
-$ bun add drizzle-orm
-$ bun add -D drizzle-kit
+```sh terminal icon="terminal"
+bun init -y
+bun add drizzle-orm
+bun add -D drizzle-kit
 ```
 
 ---
 
 Then we'll connect to a SQLite database using the `bun:sqlite` module and create the Drizzle database instance.
 
-```ts#db.ts
+```ts db.ts icon="/icons/typescript.svg"
 import { drizzle } from "drizzle-orm/bun-sqlite";
 import { Database } from "bun:sqlite";
 
@@ -30,7 +32,7 @@ export const db = drizzle(sqlite);
 
 To see the database in action, add these lines to `index.ts`.
 
-```ts#index.ts
+```ts index.ts icon="/icons/typescript.svg"
 import { db } from "./db";
 import { sql } from "drizzle-orm";
 
@@ -43,8 +45,11 @@ console.log(result);
 
 Then run `index.ts` with Bun. Bun will automatically create `sqlite.db` and execute the query.
 
-```sh
-$ bun run index.ts
+```sh terminal icon="terminal"
+bun run index.ts
+```
+
+```txt
 {
   text: "hello world"
 }
@@ -54,7 +59,7 @@ $ bun run index.ts
 
 Lets give our database a proper schema. Create a `schema.ts` file and define a `movies` table.
 
-```ts#schema.ts
+```ts schema.ts icon="/icons/typescript.svg"
 import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
 
 export const movies = sqliteTable("movies", {
@@ -68,15 +73,15 @@ export const movies = sqliteTable("movies", {
 
 We can use the `drizzle-kit` CLI to generate an initial SQL migration.
 
-```sh
-$ bunx drizzle-kit generate --dialect sqlite --schema ./schema.ts
+```sh terminal icon="terminal"
+bunx drizzle-kit generate --dialect sqlite --schema ./schema.ts
 ```
 
 ---
 
 This creates a new `drizzle` directory containing a `.sql` migration file and `meta` directory.
 
-```txt
+```txt File Tree icon="folder-tree"
 drizzle
 ├── 0000_ordinary_beyonder.sql
 └── meta
@@ -90,7 +95,7 @@ We can execute these migrations with a simple `migrate.ts` script.
 
 This script creates a new connection to a SQLite database that writes to `sqlite.db`, then executes all unexecuted migrations in the `drizzle` directory.
 
-```ts#migrate.ts
+```ts migrate.ts icon="/icons/typescript.svg"
 import { migrate } from "drizzle-orm/bun-sqlite/migrator";
 
 import { drizzle } from "drizzle-orm/bun-sqlite";
@@ -105,15 +110,15 @@ migrate(db, { migrationsFolder: "./drizzle" });
 
 We can run this script with `bun` to execute the migration.
 
-```sh
-$ bun run migrate.ts
+```sh terminal icon="terminal"
+bun run migrate.ts
 ```
 
 ---
 
 Now that we have a database, let's add some data to it. Create a `seed.ts` file with the following contents.
 
-```ts#seed.ts
+```ts seed.ts icon="/icons/typescript.svg"
 import { db } from "./db";
 import * as schema from "./schema";
 
@@ -139,8 +144,11 @@ console.log(`Seeding complete.`);
 
 Then run this file.
 
-```sh
-$ bun run seed.ts
+```sh terminal icon="terminal"
+bun run seed.ts
+```
+
+```txt
 Seeding complete.
 ```
 
@@ -148,7 +156,7 @@ Seeding complete.
 
 We finally have a database with a schema and some sample data. Let's use Drizzle to query it. Replace the contents of `index.ts` with the following.
 
-```ts#index.ts
+```ts index.ts icon="/icons/typescript.svg"
 import * as schema from "./schema";
 import { db } from "./db";
 
@@ -160,9 +168,11 @@ console.log(result);
 
 Then run the file. You should see the three movies we inserted.
 
-```sh
-$ bun run index.ts
+```sh terminal icon="terminal"
 bun run index.ts
+```
+
+```txt
 [
   {
     id: 1,

package/docs/guides/ecosystem/{edgedb.md → edgedb.mdx}

@@ -1,5 +1,7 @@
 ---
-name: Use EdgeDB with Bun
+title: Use EdgeDB with Bun
+sidebarTitle: EdgeDB with Bun
+mode: center
 ---
 
 EdgeDB is a graph-relational database powered by Postgres under the hood. It provides a declarative schema language, migrations system, and object-oriented query language, in addition to supporting raw SQL queries. It solves the object-relational mapping problem at the database layer, eliminating the need for an ORM library in your application code.
@@ -8,34 +10,37 @@ EdgeDB is a graph-relational database powered by Postgres under the hood. It pro
 
 First, [install EdgeDB](https://www.edgedb.com/install) if you haven't already.
 
-{% codetabs %}
+<CodeGroup>
 
-```sh#Linux/macOS
-$ curl --proto '=https' --tlsv1.2 -sSf https://sh.edgedb.com | sh
+```sh Linux/macOS terminal icon="terminal"
+curl --proto '=https' --tlsv1.2 -sSf https://sh.edgedb.com | sh
 ```
 
-```sh#Windows
-$ iwr https://ps1.edgedb.com -useb | iex
+```sh Windows terminal icon="windows"
+iwr https://ps1.edgedb.com -useb | iex
 ```
 
-{% /codetabs %}
+</CodeGroup>
 
 ---
 
 Use `bun init` to create a fresh project.
 
-```sh
-$ mkdir my-edgedb-app
-$ cd my-edgedb-app
-$ bun init -y
+```sh terminal icon="terminal"
+mkdir my-edgedb-app
+cd my-edgedb-app
+bun init -y
 ```
 
 ---
 
 We'll use the EdgeDB CLI to initialize an EdgeDB instance for our project. This creates an `edgedb.toml` file in our project root.
 
-```sh
-$ edgedb project init
+```sh terminal icon="terminal"
+edgedb project init
+```
+
+```txt
 No `edgedb.toml` found in `/Users/colinmcd94/Documents/bun/fun/examples/my-edgedb-app` or above
 Do you want to initialize a new project? [Y/n]
 > Y
@@ -64,12 +69,18 @@ To connect to my_edgedb_app, run `edgedb`
 
 To see if the database is running, let's open a REPL and run a simple query.
 
-Then run `\quit` to exit the REPL.
-
-```sh
-$ edgedb
+```sh terminal icon="terminal"
+edgedb
 edgedb> select 1 + 1;
+```
+
+```txt
 2
+```
+
+Then run `\quit` to exit the REPL.
+
+```sh terminal icon="terminal"
 edgedb> \quit
 ```
 
@@ -77,7 +88,7 @@ edgedb> \quit
 
 With the project initialized, we can define a schema. The `edgedb project init` command already created a `dbschema/default.esdl` file to contain our schema.
 
-```txt
+```txt File Tree icon="folder-tree"
 dbschema
 ├── default.esdl
 └── migrations
@@ -87,7 +98,7 @@ dbschema
 
 Open that file and paste the following contents.
 
-```txt
+```ts default.esdl icon="file-code"
 module default {
   type Movie {
     required title: str;
@@ -100,10 +111,19 @@ module default {
 
 Then generate and apply an initial migration.
 
-```sh
-$ edgedb migration create
+```sh terminal icon="terminal"
+edgedb migration create
+```
+
+```txt
 Created /Users/colinmcd94/Documents/bun/fun/examples/my-edgedb-app/dbschema/migrations/00001.edgeql, id: m1uwekrn4ni4qs7ul7hfar4xemm5kkxlpswolcoyqj3xdhweomwjrq
-$ edgedb migrate
+```
+
+```sh terminal icon="terminal"
+edgedb migrate
+```
+
+```txt
 Applied m1uwekrn4ni4qs7ul7hfar4xemm5kkxlpswolcoyqj3xdhweomwjrq (00001.edgeql)
 ```
 
@@ -111,10 +131,10 @@ Applied m1uwekrn4ni4qs7ul7hfar4xemm5kkxlpswolcoyqj3xdhweomwjrq (00001.edgeql)
 
 With our schema applied, let's execute some queries using EdgeDB's JavaScript client library. We'll install the client library and EdgeDB's codegen CLI, and create a `seed.ts`.file.
 
-```sh
-$ bun add edgedb
-$ bun add -D @edgedb/generate
-$ touch seed.ts
+```sh terminal icon="terminal"
+bun add edgedb
+bun add -D @edgedb/generate
+touch seed.ts
 ```
 
 ---
@@ -123,7 +143,7 @@ Paste the following code into `seed.ts`.
 
 The client auto-connects to the database. We insert a couple movies using the `.execute()` method. We will use EdgeQL's `for` expression to turn this bulk insert into a single optimized query.
 
-```ts
+```ts seed.ts icon="/icons/typescript.svg"
 import { createClient } from "edgedb";
 
 const client = createClient();
@@ -154,8 +174,11 @@ process.exit();
 
 Then run this file with Bun.
 
-```sh
-$ bun run seed.ts
+```sh terminal icon="terminal"
+bun run seed.ts
+```
+
+```txt
 Seeding complete.
 ```
 
@@ -163,8 +186,11 @@ Seeding complete.
 
 EdgeDB implements a number of code generation tools for TypeScript. To query our newly seeded database in a typesafe way, we'll use `@edgedb/generate` to code-generate the EdgeQL query builder.
 
-```sh
-$ bunx @edgedb/generate edgeql-js
+```sh terminal icon="terminal"
+bunx @edgedb/generate edgeql-js
+```
+
+```txt
 Generating query builder...
 Detected tsconfig.json, generating TypeScript files.
    To override this, use the --target flag.
@@ -186,7 +212,7 @@ the query builder directory? The following line will be added:
 
 In `index.ts`, we can import the generated query builder from `./dbschema/edgeql-js` and write a simple select query.
 
-```ts
+```ts index.ts icon="/icons/typescript.svg"
 import { createClient } from "edgedb";
 import e from "./dbschema/edgeql-js";
 
@@ -207,8 +233,11 @@ results; // { title: string, releaseYear: number | null }[]
 
 Running the file with Bun, we can see the list of movies we inserted.
 
-```sh
-$ bun run index.ts
+```sh terminal icon="terminal"
+bun run index.ts
+```
+
+```txt
 [
   {
     title: "The Matrix",

package/docs/guides/ecosystem/{elysia.md → elysia.mdx}

@@ -1,27 +1,27 @@
 ---
-name: Build an HTTP server using Elysia and Bun
+title: Build an HTTP server using Elysia and Bun
+sidebarTitle: Elysia with Bun
+mode: center
 ---
 
 [Elysia](https://elysiajs.com) is a Bun-first performance focused web framework that takes full advantage of Bun's HTTP, file system, and hot reloading APIs. Get started with `bun create`.
 
-```bash
-$ bun create elysia myapp
-$ cd myapp
-$ bun run dev
+```bash terminal icon="terminal"
+bun create elysia myapp
+cd myapp
+bun run dev
 ```
 
 ---
 
 To define a simple HTTP route and start a server with Elysia:
 
-```ts#server.ts
-import { Elysia } from 'elysia'
+```ts server.ts icon="/icons/typescript.svg"
+import { Elysia } from "elysia";
 
-const app = new Elysia()
-	.get('/', () => 'Hello Elysia')
-	.listen(8080)
+const app = new Elysia().get("/", () => "Hello Elysia").listen(8080);
 
-console.log(`🦊 Elysia is running at on port ${app.server?.port}...`)
+console.log(`🦊 Elysia is running at on port ${app.server?.port}...`);
 ```
 
 ---

package/docs/guides/ecosystem/{express.md → express.mdx}

@@ -1,22 +1,25 @@
 ---
-name: Build an HTTP server using Express and Bun
+title: Build an HTTP server using Express and Bun
+sidebarTitle: Express with Bun
+mode: center
 ---
 
 Express and other major Node.js HTTP libraries should work out of the box. Bun implements the [`node:http`](https://nodejs.org/api/http.html) and [`node:https`](https://nodejs.org/api/https.html) modules that these libraries rely on.
 
-{% callout %}
-Refer to the [Runtime > Node.js APIs](https://bun.com/docs/runtime/nodejs-apis#node-http) page for more detailed compatibility information.
-{% /callout %}
+<Note>
+  Refer to the [Runtime > Node.js APIs](https://bun.com/docs/runtime/nodejs-apis#node-http) page for more detailed
+  compatibility information.
+</Note>
 
-```sh
-$ bun add express
+```sh terminal icon="terminal"
+bun add express
 ```
 
 ---
 
 To define a simple HTTP route and start a server with Express:
 
-```ts#server.ts
+```ts server.ts icon="/icons/typescript.svg"
 import express from "express";
 
 const app = express();
@@ -35,6 +38,6 @@ app.listen(port, () => {
 
 To start the server on `localhost`:
 
-```sh
-$ bun server.ts
+```sh terminal icon="terminal"
+bun server.ts
 ```

package/docs/guides/ecosystem/{hono.md → hono.mdx}

@@ -1,10 +1,12 @@
 ---
-name: Build an HTTP server using Hono and Bun
+title: Build an HTTP server using Hono and Bun
+sidebarTitle: Hono with Bun
+mode: center
 ---
 
 [Hono](https://github.com/honojs/hono) is a lightweight ultrafast web framework designed for the edge.
 
-```ts
+```ts server.ts icon="/icons/typescript.svg"
 import { Hono } from "hono";
 const app = new Hono();
 
@@ -17,21 +19,27 @@ export default app;
 
 Use `create-hono` to get started with one of Hono's project templates. Select `bun` when prompted for a template.
 
-```sh
-$ bun create hono myapp
+```sh terminal icon="terminal"
+bun create hono myapp
+```
+
+```txt
 ✔ Which template do you want to use? › bun
 cloned honojs/starter#main to /path/to/myapp
 ✔ Copied project files
-$ cd myapp
-$ bun install
+```
+
+```sh terminal icon="terminal"
+cd myapp
+bun install
 ```
 
 ---
 
 Then start the dev server and visit [localhost:3000](http://localhost:3000).
 
-```sh
-$ bun run dev
+```sh terminal icon="terminal"
+bun run dev
 ```
 
 ---

package/docs/guides/ecosystem/{mongoose.md → mongoose.mdx}

@@ -1,5 +1,7 @@
 ---
-name: Read and write data to MongoDB using Mongoose and Bun
+title: Read and write data to MongoDB using Mongoose and Bun
+sidebarTitle: Mongoose with Bun
+mode: center
 ---
 
 MongoDB and Mongoose work out of the box with Bun. This guide assumes you've already installed MongoDB and are running it as background process/service on your development machine. Follow [this guide](https://www.mongodb.com/docs/manual/installation/) for details.
@@ -8,31 +10,31 @@ MongoDB and Mongoose work out of the box with Bun. This guide assumes you've alr
 
 Once MongoDB is running, create a directory and initialize it with `bun init`.
 
-```sh
-$ mkdir mongoose-app
-$ cd mongoose-app
-$ bun init
+```sh terminal icon="terminal"
+mkdir mongoose-app
+cd mongoose-app
+bun init
 ```
 
 ---
 
 Then add Mongoose as a dependency.
 
-```sh
-$ bun add mongoose
+```sh terminal icon="terminal"
+bun add mongoose
 ```
 
 ---
 
 In `schema.ts` we'll declare and export a simple `Animal` model.
 
-```ts#schema.ts
-import * as mongoose from 'mongoose';
+```ts schema.ts icon="/icons/typescript.svg"
+import * as mongoose from "mongoose";
 
 const animalSchema = new mongoose.Schema(
   {
-    name: {type: String, required: true},
-    sound: {type: String, required: true},
+    title: { type: String, required: true },
+    sound: { type: String, required: true },
   },
   {
     methods: {
@@ -40,28 +42,28 @@ const animalSchema = new mongoose.Schema(
         console.log(`${this.sound}!`);
       },
     },
-  }
+  },
 );
 
 export type Animal = mongoose.InferSchemaType<typeof animalSchema>;
-export const Animal = mongoose.model('Animal', animalSchema);
+export const Animal = mongoose.model("Animal", animalSchema);
 ```
 
 ---
 
 Now from `index.ts` we can import `Animal`, connect to MongoDB, and add some data to our database.
 
-```ts#index.ts
-import * as mongoose from 'mongoose';
-import {Animal} from './schema';
+```ts index.ts icon="/icons/typescript.svg"
+import * as mongoose from "mongoose";
+import { Animal } from "./schema";
 
 // connect to database
-await mongoose.connect('mongodb://127.0.0.1:27017/mongoose-app');
+await mongoose.connect("mongodb://127.0.0.1:27017/mongoose-app");
 
 // create new Animal
 const cow = new Animal({
-  name: 'Cow',
-  sound: 'Moo',
+  title: "Cow",
+  sound: "Moo",
 });
 await cow.save(); // saves to the database
 
@@ -77,8 +79,11 @@ await mongoose.disconnect();
 
 Let's run this with `bun run`.
 
-```bash
-$ bun run index.ts
+```bash terminal icon="terminal"
+bun run index.ts
+```
+
+```txt
 Moo!
 ```