bun-types 1.3.2-canary.20251106T140813 → 1.3.2

package/docs/guides/ecosystem/neon-serverless-postgres.mdx

@@ -0,0 +1,60 @@
+---
+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.
+
+---
+
+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 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 .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 index.ts icon="/icons/typescript.svg"
+import { neon } from "@neondatabase/serverless";
+
+// Bun automatically loads the DATABASE_URL from .env.local
+// Refer to: https://bun.com/docs/runtime/env for more information
+const sql = neon(process.env.DATABASE_URL);
+
+const rows = await sql`SELECT version()`;
+
+console.log(rows[0].version);
+```
+
+---
+
+Start the program using `bun ./index.ts`. The Postgres version should be printed to the console.
+
+```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
+```
+
+---
+
+This example used the Neon serverless driver's SQL-over-HTTP functionality. Neon's serverless driver also exposes `Client` and `Pool` constructors to enable sessions, interactive transactions, and node-postgres compatibility.
+
+Refer to [Neon's documentation](https://neon.tech/docs/serverless/serverless-driver) for a complete overview of the serverless driver.

package/docs/guides/ecosystem/nextjs.mdx

@@ -0,0 +1,57 @@
+---
+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 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
+✔ Would you like to use Tailwind CSS? ... No / Yes
+✔ Would you like to use `src/` directory with this project? … No / Yes
+✔ Would you like to use App Router? (recommended) ... No / Yes
+✔ What import alias would you like configured? … @/*
+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
+```
+
+```txt
+✔ What is your project named? … my-app
+...
+```
+
+---
+
+To start the dev server with Bun, run `bun --bun run dev` from the project root.
+
+```sh terminal icon="terminal"
+cd my-app
+bun --bun run dev
+```
+
+---
+
+To run the dev server with Node.js instead, omit `--bun`.
+
+```sh terminal icon="terminal"
+cd my-app
+bun run dev
+```
+
+---
+
+Open [http://localhost:3000](http://localhost:3000) with your browser to see the result. Any changes you make to `(pages/app)/index.tsx` will be hot-reloaded in the browser.

package/docs/guides/ecosystem/nuxt.mdx

@@ -0,0 +1,90 @@
+---
+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 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.1 (16b4bf34)
+ + @nuxt/devtools@0.8.2
+ + nuxt@3.7.0
+ 785 packages installed [2.67s]
+✔ Installation completed.
+✔ Types generated in .nuxt
+✨ Nuxt project has been created with the v3 template. Next steps:
+ › cd my-nuxt-app
+ › Start development server with bun run dev
+```
+
+---
+
+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`).
+
+<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
+```
+
+```txt
+nuxt dev
+Nuxi 3.6.5
+Nuxt 3.6.5 with Nitro 2.5.2
+  > Local:    http://localhost:3000/
+  > Network:  http://192.168.0.21:3000/
+  > Network:  http://[fd8a:d31d:481c:4883:1c64:3d90:9f83:d8a2]:3000/
+
+✔ Nuxt DevTools is enabled v0.8.0 (experimental)
+ℹ Vite client warmed up in 547ms
+✔ Nitro built in 244 ms
+```
+
+---
+
+Once the dev server spins up, open [http://localhost:3000](http://localhost:3000) to see the app. The app will render Nuxt's built-in `NuxtWelcome` template component.
+
+To start developing your app, replace `<NuxtWelcome />` in `app.vue` with your own UI.
+
+<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
+```
+
+---
+
+Refer to the [Nuxt website](https://nuxt.com/docs) for complete documentation.

package/docs/guides/ecosystem/pm2.mdx

@@ -0,0 +1,55 @@
+---
+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).
+
+It offers features like process monitoring, automatic restarts, and easy scaling. Using a process manager is common when deploying a Bun application on a cloud-hosted virtual private server (VPS), as it:
+
+- Keeps your Node.js application running continuously.
+- Ensure high availability and reliability of your application.
+- Monitor and manage multiple processes with ease.
+- Simplify the deployment process.
+
+---
+
+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 terminal icon="terminal"
+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.
+
+```js pm2.config.js icon="file-code"
+module.exports = {
+  title: "app", // Name of your application
+  script: "index.ts", // Entry point of your application
+  interpreter: "bun", // Bun interpreter
+  env: {
+    PATH: `${process.env.HOME}/.bun/bin:${process.env.PATH}`, // Add "~/.bun/bin/bun" to PATH
+  },
+};
+```
+
+---
+
+After saving the file, you can start your application with PM2
+
+```bash terminal icon="terminal"
+pm2 start pm2.config.js
+```
+
+---
+
+That’s it! Your JavaScript/TypeScript web server is now running as a daemon with PM2 using Bun as the interpreter.

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.

package/docs/guides/ecosystem/prisma.mdx

@@ -0,0 +1,164 @@
+---
+title: Use Prisma with Bun
+sidebarTitle: Prisma ORM with Bun
+mode: center
+---
+
+<Note>
+  **Note** — Prisma's dynamic subcommand loading system currently requires npm to be installed alongside Bun. This
+  affects certain CLI commands like `prisma init`, `prisma migrate`, etc. Generated code works perfectly with Bun using
+  the new `prisma-client` generator.
+</Note>
+
+<Steps>
+	<Step title="Create a new project">
+		Prisma works out of the box with Bun. First, create a directory and initialize it with `bun init`.
+
+    	```bash terminal icon="terminal"
+    	mkdir prisma-app
+    	cd prisma-app
+    	bun init
+    	```
+    </Step>
+
+    <Step title="Install Prisma dependencies">
+    	Then install the Prisma CLI (`prisma`), Prisma Client (`@prisma/client`), and the LibSQL adapter as dependencies.
+
+    	```bash terminal icon="terminal"
+    	bun add -d prisma
+    	bun add @prisma/client @prisma/adapter-libsql
+    	```
+    </Step>
+
+    <Step title="Initialize Prisma with SQLite">
+    	We'll use the Prisma CLI with `bunx` to initialize our schema and migration directory. For simplicity we'll be using an in-memory SQLite database.
+
+    	```bash terminal icon="terminal"
+    	bunx --bun prisma init --datasource-provider sqlite
+    	```
+
+    	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" // [!code ++]
+    	    output = "./generated" // [!code ++]
+    	    engineType = "client" // [!code ++]
+    	    runtime = "bun" // [!code ++]
+    	  }
+
+    	  datasource db {
+    	    provider = "sqlite"
+    	    url      = env("DATABASE_URL")
+    	  }
+
+    	  model User { // [!code ++]
+    	    id    Int     @id @default(autoincrement()) // [!code ++]
+    	    email String  @unique // [!code ++]
+    	    name  String? // [!code ++]
+    	  } // [!code ++]
+    	```
+    </Step>
+
+    <Step title="Create and run database migration">
+    	Then generate and run initial migration.
+
+    	This will generate a `.sql` migration file in `prisma/migrations`, create a new SQLite instance, and execute the migration against the new instance.
+
+    	```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": SQLite database "dev.db" at "file:./dev.db"
+
+    	SQLite database dev.db created at file:./dev.db
+
+    	Applying migration `20251014141233_init`
+
+    	The following migration(s) have been created and applied from new schema changes:
+
+    	prisma/migrations/
+    	  └─ 20251014141233_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 LibSQL">
+    	Now we need to create a Prisma client instance. Create a new file `prisma/db.ts` to initialize the PrismaClient with the LibSQL adapter.
+
+    	```ts prisma/db.ts icon="/icons/typescript.svg"
+    	import { PrismaClient } from "./generated/client";
+    	import { PrismaLibSQL } from "@prisma/adapter-libsql";
+
+    	const adapter = new PrismaLibSQL({ url: process.env.DATABASE_URL || "" });
+    	export const prisma = new PrismaClient({ adapter });
+    	```
+    </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
+    	```
+    	```txg
+    	Created john-0.12802932895402364@example.com
+    	There are 1 users in the database.
+    	```
+
+    	```bash terminal icon="terminal"
+    	bun run index.ts
+    	```
+    	```txt
+    	Created john-0.8671308799782803@example.com
+    	There are 2 users in the database.
+    	```
+
+    	```bash terminal icon="terminal"
+    	bun run index.ts
+    	```
+    	```txt
+    	Created john-0.4465968383115295@example.com
+    	There are 3 users in the database.
+    	```
+    </Step>
+
+</Steps>
+
+---
+
+That's it! Now that you've set up Prisma using Bun, we recommend referring to the [official Prisma docs](https://www.prisma.io/docs/concepts/components/prisma-client) as you continue to develop your application.