@hasna/connectors 1.3.0 → 1.3.2

package/connectors/connect-yousign/node_modules/bun-types/docs/guides/ecosystem/hono.mdx

@@ -0,0 +1,47 @@
+---
+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 server.ts icon="/icons/typescript.svg"
+import { Hono } from "hono";
+const app = new Hono();
+
+app.get("/", c => c.text("Hono!"));
+
+export default app;
+```
+
+---
+
+Use `create-hono` to get started with one of Hono's project templates. Select `bun` when prompted for a template.
+
+```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
+```
+
+```sh terminal icon="terminal"
+cd myapp
+bun install
+```
+
+---
+
+Then start the dev server and visit [localhost:3000](http://localhost:3000).
+
+```sh terminal icon="terminal"
+bun run dev
+```
+
+---
+
+Refer to Hono's guide on [getting started with Bun](https://hono.dev/getting-started/bun) for more information.

package/connectors/connect-yousign/node_modules/bun-types/docs/guides/ecosystem/mongoose.mdx

@@ -0,0 +1,92 @@
+---
+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.
+
+---
+
+Once MongoDB is running, create a directory and initialize it with `bun init`.
+
+```sh terminal icon="terminal"
+mkdir mongoose-app
+cd mongoose-app
+bun init
+```
+
+---
+
+Then add Mongoose as a dependency.
+
+```sh terminal icon="terminal"
+bun add mongoose
+```
+
+---
+
+In `schema.ts` we'll declare and export a simple `Animal` model.
+
+```ts schema.ts icon="/icons/typescript.svg"
+import * as mongoose from "mongoose";
+
+const animalSchema = new mongoose.Schema(
+  {
+    title: { type: String, required: true },
+    sound: { type: String, required: true },
+  },
+  {
+    methods: {
+      speak() {
+        console.log(`${this.sound}!`);
+      },
+    },
+  },
+);
+
+export type Animal = mongoose.InferSchemaType<typeof 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 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");
+
+// create new Animal
+const cow = new Animal({
+  title: "Cow",
+  sound: "Moo",
+});
+await cow.save(); // saves to the database
+
+// read all Animals
+const animals = await Animal.find();
+animals[0].speak(); // logs "Moo!"
+
+// disconnect
+await mongoose.disconnect();
+```
+
+---
+
+Let's run this with `bun run`.
+
+```bash terminal icon="terminal"
+bun run index.ts
+```
+
+```txt
+Moo!
+```
+
+---
+
+This is a simple introduction to using Mongoose with TypeScript and Bun. As you build your application, refer to the official [MongoDB](https://www.mongodb.com/docs) and [Mongoose](https://mongoosejs.com/docs/) sites for complete documentation.

package/connectors/connect-yousign/node_modules/bun-types/docs/guides/ecosystem/neon-drizzle.mdx

@@ -0,0 +1,234 @@
+---
+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 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.
+
+```ini .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 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/environment-variables for more information
+const sql = neon(process.env.DATABASE_URL!);
+
+export const db = drizzle(sql);
+```
+
+---
+
+To see the database in action, add these lines to `index.ts`.
+
+```ts index.ts icon="/icons/typescript.svg"
+import { db } from "./db";
+import { sql } from "drizzle-orm";
+
+const query = sql`select 'hello world' as text`;
+const result = await db.execute(query);
+console.log(result.rows);
+```
+
+---
+
+Then run `index.ts` with Bun.
+
+```sh terminal icon="terminal"
+bun run index.ts
+```
+
+```txt
+[
+  {
+    text: "hello world",
+  }
+]
+```
+
+---
+
+We can define a schema for our database using Drizzle ORM primitives. Create a `schema.ts` file and add this code.
+
+```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(),
+  title: text("name").notNull(),
+  bio: text("bio"),
+  createdAt: timestamp("created_at").notNull().defaultNow(),
+});
+```
+
+---
+
+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
+```
+
+---
+
+This creates a new `drizzle` directory containing a `.sql` migration file and `meta` directory.
+
+```txt File Tree icon="folder-tree"
+drizzle
+├── 0000_aspiring_post.sql
+└── meta
+    ├── 0000_snapshot.json
+    └── _journal.json
+```
+
+---
+
+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";
+import { migrate } from "drizzle-orm/neon-http/migrator";
+
+const main = async () => {
+  try {
+    await migrate(db, { migrationsFolder: "drizzle" });
+    console.log("Migration completed");
+  } catch (error) {
+    console.error("Error during migration:", error);
+    process.exit(1);
+  }
+};
+
+main();
+```
+
+---
+
+We can run this script with `bun` to execute the migration.
+
+```sh terminal icon="terminal"
+bun run migrate.ts
+```
+
+```txt
+Migration completed
+```
+
+---
+
+We can now add some data to our database. Create a `seed.ts` file with the following contents.
+
+```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([
+    {
+      title: "J.R.R. Tolkien",
+      bio: "The creator of Middle-earth and author of The Lord of the Rings.",
+    },
+    {
+      title: "George R.R. Martin",
+      bio: "The author of the epic fantasy series A Song of Ice and Fire.",
+    },
+    {
+      title: "J.K. Rowling",
+      bio: "The creator of the Harry Potter series.",
+    },
+  ]);
+}
+
+async function main() {
+  try {
+    await seed();
+    console.log("Seeding completed");
+  } catch (error) {
+    console.error("Error during seeding:", error);
+    process.exit(1);
+  }
+}
+
+main();
+```
+
+---
+
+Then run this file.
+
+```sh terminal icon="terminal"
+bun run seed.ts
+```
+
+```txt
+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 icon="/icons/typescript.svg"
+import * as schema from "./schema";
+import { db } from "./db";
+
+const result = await db.select().from(schema.authors);
+console.log(result);
+```
+
+---
+
+Then run the file. You should see the three authors we inserted.
+
+```sh terminal icon="terminal"
+bun run index.ts
+```
+
+```txt
+[
+  {
+    id: 1,
+    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,
+    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,
+    title: "J.K. Rowling",
+    bio: "The creator of the Harry Potter series.",
+    createdAt: 2024-05-11T10:28:46.029Z,
+  }
+]
+```
+
+---
+
+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.
+
+Refer to the [Drizzle website](https://orm.drizzle.team/docs/overview) for more documentation on using the Drizzle ORM.

package/connectors/connect-yousign/node_modules/bun-types/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.
+
+```ini .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/environment-variables 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/connectors/connect-yousign/node_modules/bun-types/docs/guides/ecosystem/nextjs.mdx

@@ -0,0 +1,103 @@
+---
+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/connectors/connect-yousign/node_modules/bun-types/docs/guides/ecosystem/nuxt.mdx

@@ -0,0 +1,96 @@
+---
+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/connectors/connect-yousign/node_modules/bun-types/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 = {
+  name: "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.