bun-types 1.3.2-canary.20251105T140650 → 1.3.2

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

@@ -1,34 +1,36 @@
 ---
-name: Use Neon Postgres through Drizzle ORM
+title: Use Neon Postgres through Drizzle ORM
+sidebarTitle: Neon Drizzle with Bun
+mode: center
 ---
 
 [Neon](https://neon.tech/) is a fully managed serverless Postgres, separating compute and storage to offer features like autoscaling, branching and bottomless storage. Neon can be used from Bun directly using the `@neondatabase/serverless` driver or through an ORM like `Drizzle`.
 
 Drizzle ORM supports both a SQL-like "query builder" API and an ORM-like [Queries API](https://orm.drizzle.team/docs/rqb). Get started by creating a project directory, initializing the directory using `bun init`, and installing Drizzle and the [Neon serverless driver](https://github.com/neondatabase/serverless/).
 
-```sh
-$ mkdir bun-drizzle-neon
-$ cd bun-drizzle-neon
-$ bun init -y
-$ bun add drizzle-orm @neondatabase/serverless
-$ bun add -D drizzle-kit
+```sh terminal icon="terminal"
+mkdir bun-drizzle-neon
+cd bun-drizzle-neon
+bun init -y
+bun add drizzle-orm @neondatabase/serverless
+bun add -D drizzle-kit
 ```
 
 ---
 
 Create a `.env.local` file and add your [Neon Postgres connection string](https://neon.tech/docs/connect/connect-from-any-app) to it.
 
-```sh
-DATABASE_URL=postgresql://username:password@ep-adj-noun-guid.us-east-1.aws.neon.tech/neondb?sslmode=require
+```txt .env.local icon="settings"
+DATABASE_URL=postgresql://usertitle:password@ep-adj-noun-guid.us-east-1.aws.neon.tech/neondb?sslmode=require
 ```
 
 ---
 
 We will connect to the Neon database using the Neon serverless driver, wrapped in a Drizzle database instance.
 
-```ts#db.ts
-import { neon } from '@neondatabase/serverless';
-import { drizzle } from 'drizzle-orm/neon-http';
+```ts db.ts icon="/icons/typescript.svg"
+import { neon } from "@neondatabase/serverless";
+import { drizzle } from "drizzle-orm/neon-http";
 
 // Bun automatically loads the DATABASE_URL from .env.local
 // Refer to: https://bun.com/docs/runtime/env for more information
@@ -41,7 +43,7 @@ export const db = drizzle(sql);
 
 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";
 
@@ -54,8 +56,11 @@ console.log(result.rows);
 
 Then run `index.ts` with Bun.
 
-```sh
-$ bun run index.ts
+```sh terminal icon="terminal"
+bun run index.ts
+```
+
+```txt
 [
   {
     text: "hello world",
@@ -67,12 +72,12 @@ $ bun run index.ts
 
 We can define a schema for our database using Drizzle ORM primitives. Create a `schema.ts` file and add this code.
 
-```ts#schema.ts
+```ts schema.ts icon="/icons/typescript.svg"
 import { pgTable, integer, serial, text, timestamp } from "drizzle-orm/pg-core";
 
 export const authors = pgTable("authors", {
   id: serial("id").primaryKey(),
-  name: text("name").notNull(),
+  title: text("name").notNull(),
   bio: text("bio"),
   createdAt: timestamp("created_at").notNull().defaultNow(),
 });
@@ -83,14 +88,14 @@ export const authors = pgTable("authors", {
 We then use the `drizzle-kit` CLI to generate an initial SQL migration.
 
 ```sh
-$ bunx drizzle-kit generate --dialect postgresql --schema ./schema.ts --out ./drizzle
+bunx drizzle-kit generate --dialect postgresql --schema ./schema.ts --out ./drizzle
 ```
 
 ---
 
 This creates a new `drizzle` directory containing a `.sql` migration file and `meta` directory.
 
-```txt
+```txt File Tree icon="folder-tree"
 drizzle
 ├── 0000_aspiring_post.sql
 └── meta
@@ -102,8 +107,8 @@ drizzle
 
 We can execute these migrations with a simple `migrate.ts` script. This script creates a new connection to the Neon database and executes all unexecuted migrations in the `drizzle` directory.
 
-```ts#migrate.ts
-import { db } from './db';
+```ts migrate.ts
+import { db } from "./db";
 import { migrate } from "drizzle-orm/neon-http/migrator";
 
 const main = async () => {
@@ -123,8 +128,11 @@ main();
 
 We can run this script with `bun` to execute the migration.
 
-```sh
-$ bun run migrate.ts
+```sh terminal icon="terminal"
+bun run migrate.ts
+```
+
+```txt
 Migration completed
 ```
 
@@ -132,22 +140,22 @@ Migration completed
 
 We can now add some data to our database. 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";
 
 async function seed() {
   await db.insert(schema.authors).values([
     {
-      name: "J.R.R. Tolkien",
+      title: "J.R.R. Tolkien",
       bio: "The creator of Middle-earth and author of The Lord of the Rings.",
     },
     {
-      name: "George R.R. Martin",
+      title: "George R.R. Martin",
       bio: "The author of the epic fantasy series A Song of Ice and Fire.",
     },
     {
-      name: "J.K. Rowling",
+      title: "J.K. Rowling",
       bio: "The creator of the Harry Potter series.",
     },
   ]);
@@ -170,8 +178,11 @@ main();
 
 Then run this file.
 
-```sh
-$ bun run seed.ts
+```sh terminal icon="terminal"
+bun run seed.ts
+```
+
+```txt
 Seeding completed
 ```
 
@@ -179,7 +190,7 @@ Seeding completed
 
 We now have a database with a schema and sample data. We can 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";
 
@@ -191,22 +202,25 @@ console.log(result);
 
 Then run the file. You should see the three authors we inserted.
 
-```sh
-$ bun run index.ts
+```sh terminal icon="terminal"
+bun run index.ts
+```
+
+```txt
 [
   {
     id: 1,
-    name: "J.R.R. Tolkien",
+    title: "J.R.R. Tolkien",
     bio: "The creator of Middle-earth and author of The Lord of the Rings.",
     createdAt: 2024-05-11T10:28:46.029Z,
   }, {
     id: 2,
-    name: "George R.R. Martin",
+    title: "George R.R. Martin",
     bio: "The author of the epic fantasy series A Song of Ice and Fire.",
     createdAt: 2024-05-11T10:28:46.029Z,
   }, {
     id: 3,
-    name: "J.K. Rowling",
+    title: "J.K. Rowling",
     bio: "The creator of the Harry Potter series.",
     createdAt: 2024-05-11T10:28:46.029Z,
   }

package/docs/guides/ecosystem/{neon-serverless-postgres.md → neon-serverless-postgres.mdx}

@@ -1,5 +1,7 @@
 ---
-name: Use Neon's Serverless Postgres with Bun
+title: Use Neon's Serverless Postgres with Bun
+sidebarTitle: Neon Serverless Postgres with Bun
+mode: center
 ---
 
 [Neon](https://neon.tech/) is a fully managed serverless Postgres. Neon separates compute and storage to offer modern developer features such as autoscaling, branching, bottomless storage, and more.
@@ -8,26 +10,26 @@ name: Use Neon's Serverless Postgres with Bun
 
 Get started by creating a project directory, initializing the directory using `bun init`, and adding the [Neon serverless driver](https://github.com/neondatabase/serverless/) as a project dependency.
 
-```sh
-$ mkdir bun-neon-postgres
-$ cd bun-neon-postgres
-$ bun init -y
-$ bun add @neondatabase/serverless
+```sh terminal icon="terminal"
+mkdir bun-neon-postgres
+cd bun-neon-postgres
+bun init -y
+bun add @neondatabase/serverless
 ```
 
 ---
 
 Create a `.env.local` file and add your [Neon Postgres connection string](https://neon.tech/docs/connect/connect-from-any-app) to it.
 
-```sh
-DATABASE_URL=postgresql://username:password@ep-adj-noun-guid.us-east-1.aws.neon.tech/neondb?sslmode=require
+```sh .env.local icon="settings"
+DATABASE_URL=postgresql://usertitle:password@ep-adj-noun-guid.us-east-1.aws.neon.tech/neondb?sslmode=require
 ```
 
 ---
 
 Paste the following code into your project's `index.ts` file.
 
-```ts
+```ts index.ts icon="/icons/typescript.svg"
 import { neon } from "@neondatabase/serverless";
 
 // Bun automatically loads the DATABASE_URL from .env.local
@@ -43,8 +45,11 @@ console.log(rows[0].version);
 
 Start the program using `bun ./index.ts`. The Postgres version should be printed to the console.
 
-```sh
-$ bun ./index.ts
+```sh terminal icon="terminal"
+bun ./index.ts
+```
+
+```txt
 PostgreSQL 16.2 on x86_64-pc-linux-gnu, compiled by gcc (Debian 10.2.1-6) 10.2.1 20210110, 64-bit
 ```
 

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

@@ -1,11 +1,16 @@
 ---
-name: Build an app with Next.js and Bun
+title: Build an app with Next.js and Bun
+sidebarTitle: Next.js with Bun
+mode: center
 ---
 
 Initialize a Next.js app with `create-next-app`. This will scaffold a new Next.js project and automatically install dependencies.
 
-```sh
-$ bun create next-app
+```sh terminal icon="terminal"
+bun create next-app
+```
+
+```txt
 ✔ What is your project named? … my-app
 ✔ Would you like to use TypeScript with this project? … No / Yes
 ✔ Would you like to use ESLint with this project? … No / Yes
@@ -21,7 +26,10 @@ Creating a new Next.js app in /path/to/my-app.
 You can specify a starter template using the `--example` flag.
 
 ```sh
-$ bun create next-app --example with-supabase
+bun create next-app --example with-supabase
+```
+
+```txt
 ✔ What is your project named? … my-app
 ...
 ```
@@ -30,18 +38,18 @@ $ bun create next-app --example with-supabase
 
 To start the dev server with Bun, run `bun --bun run dev` from the project root.
 
-```sh
-$ cd my-app
-$ bun --bun run dev
+```sh terminal icon="terminal"
+cd my-app
+bun --bun run dev
 ```
 
 ---
 
 To run the dev server with Node.js instead, omit `--bun`.
 
-```sh
-$ cd my-app
-$ bun run dev
+```sh terminal icon="terminal"
+cd my-app
+bun run dev
 ```
 
 ---

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

@@ -1,15 +1,20 @@
 ---
-name: Build an app with Nuxt and Bun
+title: Build an app with Nuxt and Bun
+sidebarTitle: Nuxt with Bun
+mode: center
 ---
 
 Bun supports [Nuxt](https://nuxt.com) out of the box. Initialize a Nuxt app with official `nuxi` CLI.
 
-```sh
-$ bunx nuxi init my-nuxt-app
+```sh terminal icon="terminal"
+bunx nuxi init my-nuxt-app
+```
+
+```txt
 ✔ Which package manager would you like to use?
 bun
 ◐ Installing dependencies...
-bun install v1.3.2-canary.20251105T140650 (16b4bf34)
+bun install v1.3.1 (16b4bf34)
  + @nuxt/devtools@0.8.2
  + nuxt@3.7.0
  785 packages installed [2.67s]
@@ -24,14 +29,17 @@ bun install v1.3.2-canary.20251105T140650 (16b4bf34)
 
 To start the dev server, run `bun --bun run dev` from the project root. This will execute the `nuxt dev` command (as defined in the `"dev"` script in `package.json`).
 
-{% callout %}
-The `nuxt` CLI uses Node.js by default; passing the `--bun` flag forces the dev server to use the Bun runtime instead.
-{% /callout %}
+<Note>
+  The `nuxt` CLI uses Node.js by default; passing the `--bun` flag forces the dev server to use the Bun runtime instead.
+</Note>
 
+```sh terminal icon="terminal"
+cd my-nuxt-app
+bun --bun run dev
 ```
-$ cd my-nuxt-app
-$ bun --bun run dev
- $ nuxt dev
+
+```txt
+nuxt dev
 Nuxi 3.6.5
 Nuxt 3.6.5 with Nitro 2.5.2
   > Local:    http://localhost:3000/
@@ -49,7 +57,33 @@ Once the dev server spins up, open [http://localhost:3000](http://localhost:3000
 
 To start developing your app, replace `<NuxtWelcome />` in `app.vue` with your own UI.
 
-{% image src="https://github.com/oven-sh/bun/assets/3084745/2c683ecc-3298-4bb0-b8c0-cf4cfaea1daa" caption="Demo Nuxt app running on localhost" /%}
+<Frame>
+  ![Demo Nuxt app running on
+  localhost](https://github.com/oven-sh/bun/assets/3084745/2c683ecc-3298-4bb0-b8c0-cf4cfaea1daa)
+</Frame>
+
+---
+
+For production build, while the default preset is already compatible with Bun, you can also use [Bun preset](https://nitro.build/deploy/runtimes/bun) to generate better optimized builds.
+
+```ts nuxt.config.ts icon="/icons/typescript.svg"
+export default defineNuxtConfig({
+  nitro: {
+    preset: "bun", // [!code ++]
+  },
+});
+```
+
+<Note>
+  Some packages provide Bun-specific exports that Nitro will not bundle correctly using the default preset. In this
+  case, you need to use Bun preset so that the packages will work correctly in production builds.
+</Note>
+
+After building with bun, run:
+
+```sh terminal icon="terminal"
+bun run ./.output/server/index.mjs
+```
 
 ---
 

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

@@ -1,5 +1,7 @@
 ---
-name: Run Bun as a daemon with PM2
+title: Run Bun as a daemon with PM2
+sidebarTitle: PM2 with Bun
+mode: center
 ---
 
 [PM2](https://pm2.keymetrics.io/) is a popular process manager that manages and runs your applications as daemons (background processes).
@@ -17,11 +19,9 @@ You can use PM2 with Bun in two ways: as a CLI option or in a configuration file
 
 ### With `--interpreter`
 
----
-
 To start your application with PM2 and Bun as the interpreter, open your terminal and run the following command:
 
-```bash
+```bash terminal icon="terminal"
 pm2 start --interpreter ~/.bun/bin/bun index.ts
 ```
 
@@ -29,13 +29,11 @@ pm2 start --interpreter ~/.bun/bin/bun index.ts
 
 ### With a configuration file
 
----
-
 Alternatively, you can create a PM2 configuration file. Create a file named `pm2.config.js` in your project directory and add the following content.
 
-```javascript
+```js pm2.config.js icon="file-code"
 module.exports = {
-  name: "app", // Name of your application
+  title: "app", // Name of your application
   script: "index.ts", // Entry point of your application
   interpreter: "bun", // Bun interpreter
   env: {
@@ -48,7 +46,7 @@ module.exports = {
 
 After saving the file, you can start your application with PM2
 
-```bash
+```bash terminal icon="terminal"
 pm2 start pm2.config.js
 ```
 

package/docs/guides/ecosystem/prisma-postgres.mdx

@@ -0,0 +1,169 @@
+---
+title: Use Prisma Postgres with Bun
+sidebarTitle: Prisma Postgres with Bun
+mode: center
+---
+
+<Note>
+  **Note** — At the moment Prisma needs Node.js to be installed to run certain generation code. Make sure Node.js is
+  installed in the environment where you're running `bunx prisma` commands.
+</Note>
+
+<Steps>
+	<Step title="Create a new project">
+		First, create a directory and initialize it with `bun init`.
+
+    	```bash terminal icon="terminal"
+    	mkdir prisma-postgres-app
+    	cd prisma-postgres-app
+    	bun init
+    	```
+    </Step>
+
+    <Step title="Install Prisma dependencies">
+    	Then install the Prisma CLI (`prisma`), Prisma Client (`@prisma/client`), and the accelerate extension as dependencies.
+
+    	```bash terminal icon="terminal"
+    	bun add -d prisma
+    	bun add @prisma/client @prisma/extension-accelerate
+    	```
+    </Step>
+
+    <Step title="Initialize Prisma with PostgreSQL">
+    	We'll use the Prisma CLI with `bunx` to initialize our schema and migration directory. We'll be using PostgreSQL as our database.
+
+    	```bash terminal icon="terminal"
+    	bunx --bun prisma init --db
+    	```
+
+    	This creates a basic schema. We need to update it to use the new Rust-free client with Bun optimization. Open `prisma/schema.prisma` and modify the generator block, then add a simple `User` model.
+
+    	```prisma prisma/schema.prisma icon="/icons/ecosystem/prisma.svg"
+    	generator client {
+    		provider = "prisma-client"
+    		output = "./generated" // [!code ++]
+    		engineType = "client" // [!code ++]
+    		runtime = "bun" // [!code ++]
+    	}
+
+    	datasource db {
+    		provider = "postgresql"
+    		url      = env("DATABASE_URL")
+    	}
+
+    	model User { // [!code ++]
+    		id    Int     @id @default(autoincrement()) // [!code ++]
+    		email String  @unique // [!code ++]
+    		name  String? // [!code ++]
+    	} // [!code ++]
+    	```
+    </Step>
+
+    <Step title="Configure database connection">
+    	Set up your Postgres database URL in the `.env` file.
+
+    	```env .env icon="settings"
+    	DATABASE_URL="postgresql://username:password@localhost:5432/mydb?schema=public"
+    	```
+    </Step>
+
+    <Step title="Create and run database migration">
+    	Then generate and run initial migration.
+
+    	This will generate a `.sql` migration file in `prisma/migrations`, and execute the migration against your Postgres database.
+
+    	```bash terminal icon="terminal"
+    	bunx --bun prisma migrate dev --name init
+    	```
+
+    	```txt
+    	Environment variables loaded from .env
+    	Prisma schema loaded from prisma/schema.prisma
+    	Datasource "db": PostgreSQL database "mydb", schema "public" at "localhost:5432"
+
+    	Applying migration `20250114141233_init`
+
+    	The following migration(s) have been created and applied from new schema changes:
+
+    	prisma/migrations/
+    	  └─ 20250114141233_init/
+    	    └─ migration.sql
+
+    	Your database is now in sync with your schema.
+
+    	✔ Generated Prisma Client (6.17.1) to ./generated in 18ms
+    	```
+    </Step>
+
+    <Step title="Generate Prisma Client">
+    	As indicated in the output, Prisma re-generates our _Prisma client_ whenever we execute a new migration. The client provides a fully typed API for reading and writing from our database. You can manually re-generate the client with the Prisma CLI.
+
+    	```sh terminal icon="terminal"
+    	bunx --bun prisma generate
+    	```
+    </Step>
+
+    <Step title="Initialize Prisma Client with Accelerate">
+    	Now we need to create a Prisma client instance. Create a new file `prisma/db.ts` to initialize the PrismaClient with the Postgres adapter.
+
+    	```ts prisma/db.ts icon="/icons/typescript.svg"
+    	import { PrismaClient } from "./generated/client";
+    	import { withAccelerate } from '@prisma/extension-accelerate'
+
+    	export const prisma = new PrismaClient().$extends(withAccelerate())
+    	```
+    </Step>
+
+    <Step title="Create a test script">
+    	Let's write a simple script to create a new user, then count the number of users in the database.
+
+    	```ts index.ts icon="/icons/typescript.svg"
+    	import { prisma } from "./prisma/db";
+
+    	// create a new user
+    	await prisma.user.create({
+    	  data: {
+    	    name: "John Dough",
+    	    email: `john-${Math.random()}@example.com`,
+    	  },
+    	});
+
+    	// count the number of users
+    	const count = await prisma.user.count();
+    	console.log(`There are ${count} users in the database.`);
+    	```
+    </Step>
+
+    <Step title="Run and test the application">
+    	Let's run this script with `bun run`. Each time we run it, a new user is created.
+
+    	```bash terminal icon="terminal"
+    	bun run index.ts
+    	```
+
+    	```txt
+    	There are 1 users in the database.
+    	```
+
+    	```bash terminal icon="terminal"
+    	bun run index.ts
+    	```
+
+    	```txt
+    	There are 2 users in the database.
+    	```
+
+    	```bash terminal icon="terminal"
+    	bun run index.ts
+    	```
+
+    	```txt
+    	There are 3 users in the database.
+    	```
+    </Step>
+
+</Steps>
+
+---
+
+That's it! Now that you've set up Prisma Postgres using Bun, we recommend referring to the [official Prisma Postgres docs](https://www.prisma.io/docs/postgres) as you continue to develop your application.