prjct-cli 0.35.2 → 0.35.3

package/packages/shared/node_modules/@types/bun/node_modules/bun-types/docs/guides/ecosystem/nextjs.mdx

@@ -1,103 +0,0 @@
----
-title: Build an app with Next.js and Bun
-sidebarTitle: Next.js with Bun
-mode: center
----
-
-[Next.js](https://nextjs.org/) is a React framework for building full-stack web applications. It supports server-side rendering, static site generation, API routes, and more. Bun provides fast package installation and can run Next.js development and production servers.
-
----
-
-<Steps>
-  <Step title="Create a new Next.js app">
-    Use the interactive CLI to create a new Next.js app. This will scaffold a new Next.js project and automatically install dependencies.
-
-    ```sh terminal icon="terminal"
-    bun create next-app@latest my-bun-app
-    ```
-
-  </Step>
-  <Step title="Start the dev server">
-    Change to the project directory and run the dev server with Bun.
-
-    ```sh terminal icon="terminal"
-    cd my-bun-app
-    bun --bun run dev
-    ```
-
-    This starts the Next.js dev server with Bun's runtime.
-
-    Open [`http://localhost:3000`](http://localhost:3000) with your browser to see the result. Any changes you make to `app/page.tsx` will be hot-reloaded in the browser.
-
-  </Step>
-  <Step title="Update scripts in package.json">
-    Modify the scripts field in your `package.json` by prefixing the Next.js CLI commands with `bun --bun`. This ensures that Bun executes the Next.js CLI for common tasks like `dev`, `build`, and `start`.
-
-    ```json package.json icon="file-json"
-    {
-      "scripts": {
-        "dev": "bun --bun next dev", // [!code ++]
-        "build": "bun --bun next build", // [!code ++]
-        "start": "bun --bun next start", // [!code ++]
-      }
-    }
-    ```
-
-  </Step>
-</Steps>
-
----
-
-## Hosting
-
-Next.js applications on Bun can be deployed to various platforms.
-
-<Columns cols={3}>
-  <Card title="Vercel" href="/guides/deployment/vercel" icon="/icons/ecosystem/vercel.svg">
-    Deploy on Vercel
-  </Card>
-  <Card title="Railway" href="/guides/deployment/railway" icon="/icons/ecosystem/railway.svg">
-    Deploy on Railway
-  </Card>
-  <Card title="DigitalOcean" href="/guides/deployment/digital-ocean" icon="/icons/ecosystem/digitalocean.svg">
-    Deploy on DigitalOcean
-  </Card>
-  <Card title="AWS Lambda" href="/guides/deployment/aws-lambda" icon="/icons/ecosystem/aws.svg">
-    Deploy on AWS Lambda
-  </Card>
-  <Card title="Google Cloud Run" href="/guides/deployment/google-cloud-run" icon="/icons/ecosystem/gcp.svg">
-    Deploy on Google Cloud Run
-  </Card>
-  <Card title="Render" href="/guides/deployment/render" icon="/icons/ecosystem/render.svg">
-    Deploy on Render
-  </Card>
-</Columns>
-
----
-
-## Templates
-
-<Columns cols={2}>
-  <Card
-    title="Bun + Next.js Basic Starter"
-    img="/images/templates/bun-nextjs-basic.png"
-    href="https://github.com/bun-templates/bun-nextjs-basic"
-    arrow="true"
-    cta="Go to template"
-  >
-    A simple App Router starter with Bun, Next.js, and Tailwind CSS.
-  </Card>
-  <Card
-    title="Todo App with Next.js + Bun"
-    img="/images/templates/bun-nextjs-todo.png"
-    href="https://github.com/bun-templates/bun-nextjs-todo"
-    arrow="true"
-    cta="Go to template"
-  >
-    A full-stack todo application built with Bun, Next.js, and PostgreSQL.
-  </Card>
-</Columns>
-
----
-
-[→ See Next.js's official documentation](https://nextjs.org/docs) for more information on building and deploying Next.js applications.

package/packages/shared/node_modules/@types/bun/node_modules/bun-types/docs/guides/ecosystem/nuxt.mdx

@@ -1,96 +0,0 @@
----
-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.3 (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 ++]
-  },
-});
-```
-
-Alternatively, you can set the preset via environment variable:
-
-```sh terminal icon="terminal"
-NITRO_PRESET=bun bun run build
-```
-
-<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/packages/shared/node_modules/@types/bun/node_modules/bun-types/docs/guides/ecosystem/pm2.mdx

@@ -1,55 +0,0 @@
----
-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/packages/shared/node_modules/@types/bun/node_modules/bun-types/docs/guides/ecosystem/prisma-postgres.mdx

@@ -1,169 +0,0 @@
----
-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.
-
-    	```ini .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/packages/shared/node_modules/@types/bun/node_modules/bun-types/docs/guides/ecosystem/prisma.mdx

@@ -1,164 +0,0 @@
----
-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/orm/prisma-client) as you continue to develop your application.