@hasna/connectors 1.3.9 → 1.3.11

package/connectors/connect-yousign/node_modules/bun-types/docs/guides/deployment/google-cloud-run.mdx

@@ -1,194 +0,0 @@
----
-title: Deploy a Bun application on Google Cloud Run
-sidebarTitle: Deploy on Google Cloud Run
-mode: center
----
-
-[Google Cloud Run](https://cloud.google.com/run) is a managed platform for deploying and scaling serverless applications. Google handles the infrastructure for you.
-
-In this guide, we will deploy a Bun HTTP server to Google Cloud Run using a `Dockerfile`.
-
-<Note>
-	Before continuing, make sure you have:
-
-    - A Bun application ready for deployment
-    - A [Google Cloud account](https://cloud.google.com/) with billing enabled
-    - [Google Cloud CLI](https://cloud.google.com/sdk/docs/install) installed and configured
-
-</Note>
-
----
-
-<Steps> 
-<Step title={<span>Initialize <code>gcloud</code> by select/creating a project</span>}>
-
-Make sure that you've initialized the Google Cloud CLI. This command logs you in, and prompts you to either select an existing project or create a new one.
-
-For more help with the Google Cloud CLI, see the [official documentation](https://docs.cloud.google.com/sdk/gcloud/reference/init).
-
-```bash terminal icon="terminal"
-gcloud init
-```
-
-```txt
-Welcome! This command will take you through the configuration of gcloud.
-
-You must sign in to continue. Would you like to sign in (Y/n)? Y
-You are signed in as [email@example.com].
-
-Pick cloud project to use:
- [1] existing-bun-app-1234
- [2] Enter a project ID
- [3] Create a new project
-Please enter numeric choice or text value (must exactly match list item): 3
-
-Enter a Project ID. my-bun-app
-Your current project has been set to: [my-bun-app]
-
-The Google Cloud CLI is configured and ready to use!
-```
-
-</Step>
-<Step title="(Optional) Store your project info in environment variables">
-Set variables for your project ID and number so they're easier to reuse in the following steps.
-
-```bash terminal icon="terminal"
-PROJECT_ID=$(gcloud projects list --format='value(projectId)' --filter='name="my bun app"')
-PROJECT_NUMBER=$(gcloud projects list --format='value(projectNumber)' --filter='name="my bun app"')
-
-echo $PROJECT_ID $PROJECT_NUMBER
-```
-
-```txt
-my-bun-app-... [PROJECT_NUMBER]
-```
-
-</Step> 
-<Step title="Link a billing account">
-List your available billing accounts and link one to your project:
-
-```bash terminal icon="terminal"
-gcloud billing accounts list
-```
-
-```txt
-ACCOUNT_ID            NAME                OPEN  MASTER_ACCOUNT_ID
-[BILLING_ACCOUNT_ID]  My Billing Account  True
-```
-
-Link your billing account to your project. Replace `[BILLING_ACCOUNT_ID]` with the ID of your billing account.
-
-```bash terminal icon="terminal"
-gcloud billing projects link $PROJECT_ID --billing-account=[BILLING_ACCOUNT_ID]
-```
-
-```txt
-billingAccountName: billingAccounts/[BILLING_ACCOUNT_ID]
-billingEnabled: true
-name: projects/my-bun-app-.../billingInfo
-projectId: my-bun-app-...
-```
-
-</Step> 
-<Step title="Enable APIs and configure IAM roles"> 
-Activate the necessary services and grant Cloud Build permissions:
-
-```bash terminal icon="terminal"
-gcloud services enable run.googleapis.com cloudbuild.googleapis.com
-gcloud projects add-iam-policy-binding $PROJECT_ID \
-  --member=serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com \
-  --role=roles/run.builder
-```
-
-<Note>  
-These commands enable Cloud Run (`run.googleapis.com`) and Cloud Build (`cloudbuild.googleapis.com`), which are required for deploying from source. Cloud Run runs your containerized app, while Cloud Build handles building and packaging it.
-
-The IAM binding grants the Compute Engine service account (`$PROJECT_NUMBER-compute@developer.gserviceaccount.com`) permission to build and deploy images on your behalf.
-
-</Note>
-
-</Step>
-<Step title="Add a Dockerfile">
-Create a new `Dockerfile` in the root of your project. This file contains the instructions to initialize the container, copy your local project files into it, install dependencies, and start the application.
-
-```docker Dockerfile icon="docker"
-# Use the official Bun image to run the application
-FROM oven/bun:latest
-
-# Copy the package.json and bun.lock into the container
-COPY package.json bun.lock ./
-
-# Install the dependencies
-# Install the dependencies
-RUN bun install --production --frozen-lockfile
-
-# Copy the rest of the application into the container
-COPY . .
-
-# Run the application
-CMD ["bun", "index.ts"]
-```
-
-<Note>
-  Make sure that the start command corresponds to your application's entry point. This can also be `CMD ["bun", "run", "start"]` if you have a start script in your `package.json`.
-
-This image installs dependencies and runs your app with Bun inside a container. If your app doesn't have dependencies, you can omit the `RUN bun install --production --frozen-lockfile` line.
-
-</Note>
-
-Create a new `.dockerignore` file in the root of your project. This file contains the files and directories that should be _excluded_ from the container image, such as `node_modules`. This makes your builds faster and smaller:
-
-```docker .dockerignore icon="Docker"
-node_modules
-Dockerfile*
-.dockerignore
-.git
-.gitignore
-README.md
-LICENSE
-.vscode
-.env
-# Any other files or directories you want to exclude
-```
-
-</Step>
-<Step title="Deploy your service"> 
-Make sure you're in the directory containing your `Dockerfile`, then deploy directly from your local source:
-
-<Note>
-  Update the `--region` flag to your preferred region. You can also omit this flag to get an interactive prompt to
-  select a region.
-</Note>
-
-```bash terminal icon="terminal"
-gcloud run deploy my-bun-app --source . --region=us-west1 --allow-unauthenticated
-```
-
-```txt
-Deploying from source requires an Artifact Registry Docker repository to store built containers. A repository named
-[cloud-run-source-deploy] in region [us-west1] will be created.
-
-Do you want to continue (Y/n)? Y
-
-Building using Dockerfile and deploying container to Cloud Run service [my-bun-app] in project [my-bun-app-...] region [us-west1]
-✓ Building and deploying... Done.
-  ✓ Validating Service...
-  ✓ Uploading sources...
-  ✓ Building Container... Logs are available at [https://console.cloud.google.com/cloud-build/builds...].
-  ✓ Creating Revision...
-  ✓ Routing traffic...
-  ✓ Setting IAM Policy...
-Done.
-Service [my-bun-app] revision [my-bun-app-...] has been deployed and is serving 100 percent of traffic.
-Service URL: https://my-bun-app-....us-west1.run.app
-```
-
-</Step>
-<Step title="Visit your live application">
-
-🎉 Your Bun application is now live!
-
-Visit the Service URL (`https://my-bun-app-....us-west1.run.app`) to confirm everything works as expected.
-
-</Step>
-</Steps>

package/connectors/connect-yousign/node_modules/bun-types/docs/guides/deployment/railway.mdx

@@ -1,145 +0,0 @@
----
-title: Deploy a Bun application on Railway
-description: Deploy Bun applications to Railway with this step-by-step guide covering CLI and dashboard methods, optional PostgreSQL setup, and automatic SSL configuration.
-sidebarTitle: Deploy on Railway
-mode: center
----
-
-Railway is an infrastructure platform where you can provision infrastructure, develop with that infrastructure locally, and then deploy to the cloud. It enables instant deployments from GitHub with zero configuration, automatic SSL, and built-in database provisioning.
-
-This guide walks through deploying a Bun application with a PostgreSQL database (optional), which is exactly what the template below provides.
-
-You can either follow this guide step-by-step or simply deploy the pre-configured template with one click:
-
-<a
-  href="https://railway.com/deploy/bun-react-postgres?referralCode=Bun&utm_medium=integration&utm_source=template&utm_campaign=bun"
-  target="_blank"
->
-  <img src="https://railway.com/button.svg" alt="Deploy on Railway" />
-</a>
-
----
-
-**Prerequisites**:
-
-- A Bun application ready for deployment
-- A [Railway account](https://railway.app/)
-- Railway CLI (for CLI deployment method)
-- A GitHub account (for Dashboard deployment method)
-
----
-
-## Method 1: Deploy via CLI
-
-<Steps>
-<Step title="Step 1">
-Ensure sure you have the Railway CLI installed.
-
-```bash terminal icon="terminal"
-bun install -g @railway/cli
-```
-
-</Step>
-<Step title="Step 2">
-Log into your Railway account.
-
-```bash terminal icon="terminal"
-railway login
-```
-
-</Step>
-<Step title="Step 3">
-After successfully authenticating, initialize a new project.
-
-```bash terminal icon="terminal"
-railway init
-```
-
-</Step>
-<Step title="Step 4">
-After initializing the project, add a new database and service.
-
-<Note>Step 4 is only necessary if your application uses a database. If you don't need PostgreSQL, skip to Step 5.</Note>
-
-```bash terminal icon="terminal"
-# Add PostgreSQL database. Make sure to add this first!
-railway add --database postgres
-
-# Add your application service.
-railway add --service bun-react-db --variables DATABASE_URL=\${{Postgres.DATABASE_URL}}
-```
-
-</Step>
-<Step title="Step 5">
-After the services have been created and connected, deploy the application to Railway. By default, services are only accessible within Railway's private network. To make your app publicly accessible, you need to generate a public domain.
-
-```bash terminal icon="terminal"
-# Deploy your application
-railway up
-
-# Generate public domain
-railway domain
-```
-
-</Step>
-</Steps>
-
-Your app is now live! Railway auto-deploys on every GitHub push.
-
----
-
-## Method 2: Deploy via Dashboard
-
-<Steps>
-<Step title="Step 1">
-Create a new project
-
-1. Go to [Railway Dashboard](http://railway.com/dashboard?utm_medium=integration&utm_source=docs&utm_campaign=bun)
-2. Click **"+ New"** → **"GitHub repo"**
-3. Choose your repository
-
-</Step>
-<Step title="Step 2">
-Add a PostgreSQL database, and connect this database to the service
-
-<Note>Step 2 is only necessary if your application uses a database. If you don't need PostgreSQL, skip to Step 3.</Note>
-
-1. Click **"+ New"** → **"Database"** → **"Add PostgreSQL"**
-2. After the database has been created, select your service (not the database)
-3. Go to **"Variables"** tab
-4. Click **"+ New Variable"** → **"Add Reference"**
-5. Select `DATABASE_URL` from postgres
-
-</Step>
-<Step title="Step 3">
-Generate a public domain
-
-1. Select your service
-2. Go to **"Settings"** tab
-3. Under **"Networking"**, click **"Generate Domain"**
-
-</Step>
-</Steps>
-
-Your app is now live! Railway auto-deploys on every GitHub push.
-
----
-
-## Configuration (Optional)
-
-By default, Railway uses [Nixpacks](https://docs.railway.com/guides/build-configuration#nixpacks-options) to automatically detect and build your Bun application with zero configuration.
-
-However, using the [Railpack](https://docs.railway.com/guides/build-configuration#railpack) application builder provides better Bun support, and will always support the latest version of Bun. The pre-configured templates use Railpack by default.
-
-To enable Railpack in a custom project, add the following to your `railway.json`:
-
-```json railway.json icon="file-json"
-{
-  "$schema": "https://railway.com/railway.schema.json",
-  "build": {
-    "builder": "RAILPACK"
-  }
-}
-```
-
-For more build configuration settings, check out the [Railway documentation](https://docs.railway.com/guides/build-configuration).

package/connectors/connect-yousign/node_modules/bun-types/docs/guides/deployment/render.mdx

@@ -1,82 +0,0 @@
----
-title: Deploy a Bun application on Render
-sidebarTitle: Deploy on Render
-mode: center
----
-
-[Render](https://render.com/) is a cloud platform that lets you flexibly build, deploy, and scale your apps.
-
-It offers features like auto deploys from GitHub, a global CDN, private networks, automatic HTTPS setup, and managed PostgreSQL and Redis.
-
-Render supports Bun natively. You can deploy Bun apps as web services, background workers, cron jobs, and more.
-
----
-
-As an example, let's deploy a simple Express HTTP server to Render.
-
-<Steps>
-	<Step title="Step 1">
-		Create a new GitHub repo named `myapp`. Git clone it locally.
-
-    	```sh
-    	git clone git@github.com:my-github-username/myapp.git
-    	cd myapp
-    	```
-    	</Step>
-    	<Step title="Step 2">
-    	Add the Express library.
-
-    	```sh
-    	bun add express
-    	```
-
-    </Step>
-
-    <Step title="Step 3">
-    	Define a simple server with Express:
-
-    	```ts app.ts icon="/icons/typescript.svg"
-    	import express from "express";
-
-    	const app = express();
-    	const port = process.env.PORT || 3001;
-
-    	app.get("/", (req, res) => {
-    		res.send("Hello World!");
-    	});
-
-    	app.listen(port, () => {
-    		console.log(`Listening on port ${port}...`);
-    	});
-    	```
-    </Step>
-    <Step title="Step 4">
-
-    	Commit your changes and push to GitHub.
-
-    	```sh terminal icon="terminal"
-    	git add app.ts bun.lock package.json
-    	git commit -m "Create simple Express app"
-    	git push origin main
-    	```
-    </Step>
-    <Step title="Step 5">
-    	In your [Render Dashboard](https://dashboard.render.com/), click `New` > `Web Service` and connect your `myapp` repo.
-
-    </Step>
-    <Step title="Step 6">
-    	In the Render UI, provide the following values during web service creation:
-
-    	|                   |               |
-    	| ----------------- | ------------- |
-    	| **Runtime**       | `Node`        |
-    	| **Build Command** | `bun install` |
-    	| **Start Command** | `bun app.ts`  |
-
-    </Step>
-
-</Steps>
-
-That's it! Your web service will be live at its assigned `onrender.com` URL as soon as the build finishes.
-
-You can view the [deploy logs](https://docs.render.com/logging#logs-for-an-individual-deploy-or-job) for details. Refer to [Render's documentation](https://docs.render.com/deploys) for a complete overview of deploying on Render.

package/connectors/connect-yousign/node_modules/bun-types/docs/guides/deployment/vercel.mdx

@@ -1,97 +0,0 @@
----
-title: Deploy a Bun application on Vercel
-sidebarTitle: Deploy on Vercel
-mode: center
----
-
-[Vercel](https://vercel.com/) is a cloud platform that lets you build, deploy, and scale your apps.
-
-<Warning>
-  The Bun runtime is in Beta; certain features (e.g., automatic source maps, byte-code caching, metrics on
-  `node:http/https`) are not yet supported.
-</Warning>
-
-<Note>
-  `Bun.serve` is currently not supported on Vercel Functions. Use Bun with frameworks supported by Vercel, like Next.js,
-  Express, Hono, or Nitro.
-</Note>
-
----
-
-<Steps>
-	<Step title="Configure Bun in vercel.json">
-		To enable the Bun runtime for your Functions, add a `bunVersion` field in your `vercel.json` file:
-
-    	```json vercel.json icon="file-json"
-    	{
-    		"bunVersion": "1.x" // [!code ++]
-    	}
-    	```
-
-    	Vercel automatically detects this configuration and runs your application on Bun. The value has to be `"1.x"`, Vercel handles the minor version internally.
-
-    	For best results, match your local Bun version with the version used by Vercel.
-    </Step>
-
-    <Step title="Next.js configuration">
-    	If you’re deploying a **Next.js** project (including ISR), update your `package.json` scripts to use the Bun runtime:
-
-    	```json package.json icon="file-json"
-    	{
-    		"scripts": {
-    			"dev": "bun --bun next dev", // [!code ++]
-    			"build": "bun --bun next build" // [!code ++]
-    		}
-    	}
-    	```
-
-    	<Note>
-    		The `--bun` flag runs the Next.js CLI under Bun. Bundling (via Turbopack or Webpack) remains unchanged, but all commands execute within the Bun runtime.
-    	</Note>
-
-    	This ensures both local development and builds use Bun.
-    </Step>
-
-    <Step title="Deploy your app">
-    	Connect your repository to Vercel, or deploy from the CLI:
-
-    	```bash terminal icon="terminal"
-    	# Using bunx (no global install)
-    	bunx vercel login
-    	bunx vercel deploy
-    	```
-
-    	Or install the Vercel CLI globally:
-
-    	```bash terminal icon="terminal"
-    	bun i -g vercel
-    	vercel login
-    	vercel deploy
-    	```
-
-    	[Learn more in the Vercel Deploy CLI documentation →](https://vercel.com/docs/cli/deploy)
-    </Step>
-
-    <Step title="Verify the runtime">
-    	To confirm your deployment uses Bun, log the Bun version:
-
-    	```ts index.ts icon="/icons/typescript.svg"
-    	console.log("runtime", process.versions.bun);
-    	```
-    	```txt
-    	runtime 1.3.3
-    	```
-
-    	[See the Vercel Bun Runtime documentation for feature support →](https://vercel.com/docs/functions/runtimes/bun#feature-support)
-    </Step>
-
-</Steps>
-
----
-
-- [Fluid compute](https://vercel.com/docs/fluid-compute): Both Bun and Node.js runtimes run on Fluid compute and support the same core Vercel Functions features.
-- [Middleware](https://vercel.com/docs/routing-middleware): To run Routing Middleware with Bun, set the runtime to `nodejs`:
-
-```ts middleware.ts icon="/icons/typescript.svg"
-export const config = { runtime: "nodejs" }; // [!code ++]
-```

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

@@ -1,82 +0,0 @@
----
-title: Build an app with Astro and Bun
-sidebarTitle: "Astro with Bun"
-mode: center
----
-
-Initialize a fresh Astro app with `bun create astro`. The `create-astro` package detects when you are using `bunx` and will automatically install dependencies using `bun`.
-
-```sh terminal icon="terminal"
-bun create astro
-```
-
-```txt
-╭─────╮  Houston:
-│ ◠ ◡ ◠  We're glad to have you on board.
-╰─────╯
-
- astro   v3.1.4 Launch sequence initiated.
-
-   dir   Where should we create your new project?
-         ./fumbling-field
-
-  tmpl   How would you like to start your new project?
-         Use blog template
-      ✔  Template copied
-
-  deps   Install dependencies?
-         Yes
-      ✔  Dependencies installed
-
-    ts   Do you plan to write TypeScript?
-         Yes
-
-   use   How strict should TypeScript be?
-         Strict
-      ✔  TypeScript customized
-
-   git   Initialize a new git repository?
-         Yes
-      ✔  Git initialized
-
-  next   Liftoff confirmed. Explore your project!
-
-         Enter your project directory using cd ./fumbling-field
-         Run `bun run dev` to start the dev server. CTRL+C to stop.
-         Add frameworks like react or tailwind using astro add.
-
-         Stuck? Join us at https://astro.build/chat
-
-╭─────╮  Houston:
-│ ◠ ◡ ◠  Good luck out there, astronaut! 🚀
-╰─────╯
-```
-
----
-
-Start the dev server with `bunx`.
-
-By default, Bun will run the dev server with Node.js. To use the Bun runtime instead, use the `--bun` flag.
-
-```sh terminal icon="terminal"
-bunx --bun astro dev
-```
-
-```txt
-  🚀  astro  v3.1.4 started in 200ms
-
-  ┃ Local    http://localhost:4321/
-  ┃ Network  use --host to expose
-```
-
----
-
-Open [http://localhost:4321](http://localhost:4321) with your browser to see the result. Astro will hot-reload your app as you edit your source files.
-
-<Frame>
-  <img src="https://i.imgur.com/Dswiu6w.png" caption="An Astro v3 starter app running on Bun" />
-</Frame>
-
----
-
-Refer to the [Astro docs](https://docs.astro.build/en/getting-started/) for complete documentation.

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

@@ -1,80 +0,0 @@
----
-title: Create a Discord bot
-sidebarTitle: "Discord.js with Bun"
-mode: center
----
-
-Discord.js works out of the box with Bun. Let's write a simple bot. First create a directory and initialize it with `bun init`.
-
-```sh terminal icon="terminal"
-mkdir my-bot
-cd my-bot
-bun init
-```
-
----
-
-Now install Discord.js.
-
-```sh terminal icon="terminal"
-bun add discord.js
-```
-
----
-
-Before we go further, we need to go to the [Discord developer portal](https://discord.com/developers/applications), login/signup, create a new _Application_, then create a new _Bot_ within that application. Follow the [official guide](https://discordjs.guide/legacy/preparations/app-setup#creating-your-bot) for step-by-step instructions.
-
----
-
-Once complete, you'll be presented with your bot's _private key_. Let's add this to a file called `.env.local`. Bun automatically reads this file and loads it into `process.env`.
-
-<Note>This is an example token that has already been invalidated.</Note>
-
-```ini .env.local icon="settings"
-DISCORD_TOKEN=NzkyNzE1NDU0MTk2MDg4ODQy.X-hvzA.Ovy4MCQywSkoMRRclStW4xAYK7I
-```
-
----
-
-Be sure to add `.env.local` to your `.gitignore`! It is dangerous to check your bot's private key into version control.
-
-```txt .gitignore icon="file-code"
-node_modules
-.env.local
-```
-
----
-
-Now let's actually write our bot in a new file called `bot.ts`.
-
-```ts bot.ts icon="/icons/typescript.svg"
-// import discord.js
-import { Client, Events, GatewayIntentBits } from "discord.js";
-
-// create a new Client instance
-const client = new Client({ intents: [GatewayIntentBits.Guilds] });
-
-// listen for the client to be ready
-client.once(Events.ClientReady, c => {
-  console.log(`Ready! Logged in as ${c.user.tag}`);
-});
-
-// login with the token from .env.local
-client.login(process.env.DISCORD_TOKEN);
-```
-
----
-
-Now we can run our bot with `bun run`. It may take a several seconds for the client to initialize the first time you run the file.
-
-```sh terminal icon="terminal"
-bun run bot.ts
-```
-
-```txt
-Ready! Logged in as my-bot#1234
-```
-
----
-
-You're up and running with a bare-bones Discord.js bot! This is a basic guide to setting up your bot with Bun; we recommend the [official discord.js docs](https://discordjs.guide/) for complete information on the `discord.js` API.