@hasna/connectors 1.3.10 → 1.3.12

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

@@ -1,151 +0,0 @@
----
-title: Containerize a Bun application with Docker
-sidebarTitle: Docker with Bun
-mode: center
----
-
-<Note>
-  This guide assumes you already have [Docker Desktop](https://www.docker.com/products/docker-desktop/) installed.
-</Note>
-
-[Docker](https://www.docker.com) is a platform for packaging and running an application as a lightweight, portable _container_ that encapsulates all the necessary dependencies.
-
----
-
-To _containerize_ our application, we define a `Dockerfile`. This file contains a list of instructions to initialize the container, copy our local project files into it, install dependencies, and starts the application.
-
-```docker Dockerfile icon="docker"
-# use the official Bun image
-# see all versions at https://hub.docker.com/r/oven/bun/tags
-FROM oven/bun:1 AS base
-WORKDIR /usr/src/app
-
-# install dependencies into temp directory
-# this will cache them and speed up future builds
-FROM base AS install
-RUN mkdir -p /temp/dev
-COPY package.json bun.lock /temp/dev/
-RUN cd /temp/dev && bun install --frozen-lockfile
-
-# install with --production (exclude devDependencies)
-RUN mkdir -p /temp/prod
-COPY package.json bun.lock /temp/prod/
-RUN cd /temp/prod && bun install --frozen-lockfile --production
-
-# copy node_modules from temp directory
-# then copy all (non-ignored) project files into the image
-FROM base AS prerelease
-COPY --from=install /temp/dev/node_modules node_modules
-COPY . .
-
-# [optional] tests & build
-ENV NODE_ENV=production
-RUN bun test
-RUN bun run build
-
-# copy production dependencies and source code into final image
-FROM base AS release
-COPY --from=install /temp/prod/node_modules node_modules
-COPY --from=prerelease /usr/src/app/index.ts .
-COPY --from=prerelease /usr/src/app/package.json .
-
-# run the app
-USER bun
-EXPOSE 3000/tcp
-ENTRYPOINT [ "bun", "run", "index.ts" ]
-```
-
----
-
-Now that you have your docker image, let's look at `.dockerignore` which has the same syntax as `.gitignore`, here you need to specify the files/directories that must not go in any stage of the docker build. An example for a ignore file is
-
-```txt .dockerignore icon="docker"
-node_modules
-Dockerfile*
-docker-compose*
-.dockerignore
-.git
-.gitignore
-README.md
-LICENSE
-.vscode
-Makefile
-helm-charts
-.env
-.editorconfig
-.idea
-coverage*
-```
-
----
-
-We'll now use `docker build` to convert this `Dockerfile` into a _Docker image_, a self-contained template containing all the dependencies and configuration required to run the application.
-
-The `-t` flag lets us specify a name for the image, and `--pull` tells Docker to automatically download the latest version of the base image (`oven/bun`). The initial build will take longer, as Docker will download all the base images and dependencies.
-
-```bash terminal icon="terminal"
-docker build --pull -t bun-hello-world .
-```
-
-```txt
-[+] Building 0.9s (21/21) FINISHED
- => [internal] load build definition from Dockerfile                                                                                     0.0s
- => => transferring dockerfile: 37B                                                                                                      0.0s
- => [internal] load .dockerignore                                                                                                        0.0s
- => => transferring context: 35B                                                                                                         0.0s
- => [internal] load metadata for docker.io/oven/bun:1                                                                                    0.8s
- => [auth] oven/bun:pull token for registry-1.docker.io                                                                                  0.0s
- => [base 1/2] FROM docker.io/oven/bun:1@sha256:373265748d3cd3624cb3f3ee6004f45b1fc3edbd07a622aeeec17566d2756997                         0.0s
- => [internal] load build context                                                                                                        0.0s
- => => transferring context: 155B                                                                                                        0.0s
- # ...lots of commands...
- => exporting to image                                                                                                                   0.0s
- => => exporting layers                                                                                                                  0.0s
- => => writing image sha256:360663f7fdcd6f11e8e94761d5592e2e4dfc8d167f034f15cd5a863d5dc093c4                                             0.0s
- => => naming to docker.io/library/bun-hello-world                                                                                       0.0s
-```
-
----
-
-We've built a new _Docker image_. Now let's use that image to spin up an actual, running _container_.
-
-We'll use `docker run` to start a new container using the `bun-hello-world` image. It will be run in _detached_ mode (`-d`) and we'll map the container's port 3000 to our local machine's port 3000 (`-p 3000:3000`).
-
-The `run` command prints a string representing the _container ID_.
-
-```sh terminal icon="terminal"
-docker run -d -p 3000:3000 bun-hello-world
-```
-
-```txt
-7f03e212a15ede8644379bce11a13589f563d3909a9640446c5bbefce993678d
-```
-
----
-
-The container is now running in the background. Visit [localhost:3000](http://localhost:3000). You should see a `Hello, World!` message.
-
----
-
-To stop the container, we'll use `docker stop <container-id>`.
-
-```sh terminal icon="terminal"
-docker stop 7f03e212a15ede8644379bce11a13589f563d3909a9640446c5bbefce993678d
-```
-
----
-
-If you can't find the container ID, you can use `docker ps` to list all running containers.
-
-```sh terminal icon="terminal"
-docker ps
-```
-
-```txt
-CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                    NAMES
-7f03e212a15e        bun-hello-world     "bun run index.ts"       2 minutes ago       Up 2 minutes        0.0.0.0:3000->3000/tcp   flamboyant_cerf
-```
-
----
-
-That's it! Refer to the [Docker documentation](https://docs.docker.com/) for more advanced usage.

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

@@ -1,195 +0,0 @@
----
-title: Use Drizzle ORM with Bun
-sidebarTitle: Drizzle with Bun
-mode: center
----
-
-Drizzle is an ORM that supports both a SQL-like "query builder" API and an ORM-like [Queries API](https://orm.drizzle.team/docs/rqb). It supports the `bun:sqlite` built-in module.
-
----
-
-Let's get started by creating a fresh project with `bun init` and installing Drizzle.
-
-```sh terminal icon="terminal"
-bun init -y
-bun add drizzle-orm
-bun add -D drizzle-kit
-```
-
----
-
-Then we'll connect to a SQLite database using the `bun:sqlite` module and create the Drizzle database instance.
-
-```ts db.ts icon="/icons/typescript.svg"
-import { drizzle } from "drizzle-orm/bun-sqlite";
-import { Database } from "bun:sqlite";
-
-const sqlite = new Database("sqlite.db");
-export const db = drizzle(sqlite);
-```
-
----
-
-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 = db.get<{ text: string }>(query);
-console.log(result);
-```
-
----
-
-Then run `index.ts` with Bun. Bun will automatically create `sqlite.db` and execute the query.
-
-```sh terminal icon="terminal"
-bun run index.ts
-```
-
-```txt
-{
-  text: "hello world"
-}
-```
-
----
-
-Lets give our database a proper schema. Create a `schema.ts` file and define a `movies` table.
-
-```ts schema.ts icon="/icons/typescript.svg"
-import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
-
-export const movies = sqliteTable("movies", {
-  id: integer("id").primaryKey(),
-  title: text("name"),
-  releaseYear: integer("release_year"),
-});
-```
-
----
-
-We can use the `drizzle-kit` CLI to generate an initial SQL migration.
-
-```sh terminal icon="terminal"
-bunx drizzle-kit generate --dialect sqlite --schema ./schema.ts
-```
-
----
-
-This creates a new `drizzle` directory containing a `.sql` migration file and `meta` directory.
-
-```txt File Tree icon="folder-tree"
-drizzle
-├── 0000_ordinary_beyonder.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 a SQLite database that writes to `sqlite.db`, then executes all unexecuted migrations in the `drizzle` directory.
-
-```ts migrate.ts icon="/icons/typescript.svg"
-import { migrate } from "drizzle-orm/bun-sqlite/migrator";
-
-import { drizzle } from "drizzle-orm/bun-sqlite";
-import { Database } from "bun:sqlite";
-
-const sqlite = new Database("sqlite.db");
-const db = drizzle(sqlite);
-migrate(db, { migrationsFolder: "./drizzle" });
-```
-
----
-
-We can run this script with `bun` to execute the migration.
-
-```sh terminal icon="terminal"
-bun run migrate.ts
-```
-
----
-
-Now that we have a database, let's add some data to it. 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";
-
-await db.insert(schema.movies).values([
-  {
-    title: "The Matrix",
-    releaseYear: 1999,
-  },
-  {
-    title: "The Matrix Reloaded",
-    releaseYear: 2003,
-  },
-  {
-    title: "The Matrix Revolutions",
-    releaseYear: 2003,
-  },
-]);
-
-console.log(`Seeding complete.`);
-```
-
----
-
-Then run this file.
-
-```sh terminal icon="terminal"
-bun run seed.ts
-```
-
-```txt
-Seeding complete.
-```
-
----
-
-We finally have a database with a schema and some sample data. Let's 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.movies);
-console.log(result);
-```
-
----
-
-Then run the file. You should see the three movies we inserted.
-
-```sh terminal icon="terminal"
-bun run index.ts
-```
-
-```txt
-[
-  {
-    id: 1,
-    title: "The Matrix",
-    releaseYear: 1999
-  }, {
-    id: 2,
-    title: "The Matrix Reloaded",
-    releaseYear: 2003
-  }, {
-    id: 3,
-    title: "The Matrix Revolutions",
-    releaseYear: 2003
-  }
-]
-```
-
----
-
-Refer to the [Drizzle website](https://orm.drizzle.team/docs/overview) for complete documentation.

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

@@ -1,31 +0,0 @@
----
-title: Build an HTTP server using Elysia and Bun
-sidebarTitle: Elysia with Bun
-mode: center
----
-
-[Elysia](https://elysiajs.com) is a Bun-first performance focused web framework that takes full advantage of Bun's HTTP, file system, and hot reloading APIs. Get started with `bun create`.
-
-```bash terminal icon="terminal"
-bun create elysia myapp
-cd myapp
-bun run dev
-```
-
----
-
-To define a simple HTTP route and start a server with Elysia:
-
-```ts server.ts icon="/icons/typescript.svg"
-import { Elysia } from "elysia";
-
-const app = new Elysia().get("/", () => "Hello Elysia").listen(8080);
-
-console.log(`🦊 Elysia is running at on port ${app.server?.port}...`);
-```
-
----
-
-Elysia is a full-featured server framework with Express-like syntax, type inference, middleware, file uploads, and plugins for JWT authentication, tRPC, and more. It's also is one of the [fastest Bun web frameworks](https://github.com/SaltyAom/bun-http-framework-benchmark).
-
-Refer to the Elysia [documentation](https://elysiajs.com/quick-start.html) for more information.

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

@@ -1,43 +0,0 @@
----
-title: Build an HTTP server using Express and Bun
-sidebarTitle: Express with Bun
-mode: center
----
-
-Express and other major Node.js HTTP libraries should work out of the box. Bun implements the [`node:http`](https://nodejs.org/api/http.html) and [`node:https`](https://nodejs.org/api/https.html) modules that these libraries rely on.
-
-<Note>
-  Refer to the [Runtime > Node.js APIs](/docs/runtime/nodejs-compat#node-http) page for more detailed compatibility
-  information.
-</Note>
-
-```sh terminal icon="terminal"
-bun add express
-```
-
----
-
-To define a simple HTTP route and start a server with Express:
-
-```ts server.ts icon="/icons/typescript.svg"
-import express from "express";
-
-const app = express();
-const port = 8080;
-
-app.get("/", (req, res) => {
-  res.send("Hello World!");
-});
-
-app.listen(port, () => {
-  console.log(`Listening on port ${port}...`);
-});
-```
-
----
-
-To start the server on `localhost`:
-
-```sh terminal icon="terminal"
-bun server.ts
-```

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

@@ -1,261 +0,0 @@
----
-title: Use Gel with Bun
-sidebarTitle: Gel with Bun
-mode: center
----
-
-Gel (formerly EdgeDB) is a graph-relational database powered by Postgres under the hood. It provides a declarative schema language, migrations system, and object-oriented query language, in addition to supporting raw SQL queries. It solves the object-relational mapping problem at the database layer, eliminating the need for an ORM library in your application code.
-
----
-
-First, [install Gel](https://docs.geldata.com/learn/installation) if you haven't already.
-
-<CodeGroup>
-
-```sh Linux/macOS terminal icon="terminal"
-curl https://www.geldata.com/sh --proto "=https" -sSf1 | sh
-```
-
-```sh Windows terminal icon="windows"
-irm https://www.geldata.com/ps1 | iex
-```
-
-```sh Homebrew terminal icon="terminal"
-brew install geldata/tap/gel-cli
-```
-
-</CodeGroup>
-
----
-
-Use `bun init` to create a fresh project.
-
-```sh terminal icon="terminal"
-mkdir my-edgedb-app
-cd my-edgedb-app
-bun init -y
-```
-
----
-
-We'll use the Gel CLI to initialize a Gel instance for our project. This creates a `gel.toml` file in our project root.
-
-```sh terminal icon="terminal"
-gel project init
-```
-
-```txt
-No `gel.toml` found in `/Users/colinmcd94/Documents/bun/fun/examples/my-gel-app` or above
-Do you want to initialize a new project? [Y/n]
-> Y
-Specify the name of Gel instance to use with this project [default: my_gel_app]:
-> my_gel_app
-Checking Gel versions...
-Specify the version of Gel to use with this project [default: x.y]:
-> x.y
-┌─────────────────────┬──────────────────────────────────────────────────────────────────┐
-│ Project directory   │ /Users/colinmcd94/Documents/bun/fun/examples/my-gel-app         │
-│ Project config      │ /Users/colinmcd94/Documents/bun/fun/examples/my-gel-app/gel.toml│
-│ Schema dir (empty)  │ /Users/colinmcd94/Documents/bun/fun/examples/my-gel-app/dbschema│
-│ Installation method │ portable package                                                 │
-│ Version             │ x.y+6d5921b                                                      │
-│ Instance name       │ my_gel_app                                                       │
-└─────────────────────┴──────────────────────────────────────────────────────────────────┘
-Version x.y+6d5921b is already downloaded
-Initializing Gel instance...
-Applying migrations...
-Everything is up to date. Revision initial
-Project initialized.
-To connect to my_gel_app, run `gel`
-```
-
----
-
-To see if the database is running, let's open a REPL and run a simple query.
-
-```sh terminal icon="terminal"
-gel
-gel> select 1 + 1;
-```
-
-```txt
-2
-```
-
-Then run `\quit` to exit the REPL.
-
-```sh terminal icon="terminal"
-gel> \quit
-```
-
----
-
-With the project initialized, we can define a schema. The `gel project init` command already created a `dbschema/default.esdl` file to contain our schema.
-
-```txt File Tree icon="folder-tree"
-dbschema
-├── default.esdl
-└── migrations
-```
-
----
-
-Open that file and paste the following contents.
-
-```ts default.esdl icon="file-code"
-module default {
-  type Movie {
-    required title: str;
-    releaseYear: int64;
-  }
-};
-```
-
----
-
-Then generate and apply an initial migration.
-
-```sh terminal icon="terminal"
-gel migration create
-```
-
-```txt
-Created /Users/colinmcd94/Documents/bun/fun/examples/my-gel-app/dbschema/migrations/00001.edgeql, id: m1uwekrn4ni4qs7ul7hfar4xemm5kkxlpswolcoyqj3xdhweomwjrq
-```
-
-```sh terminal icon="terminal"
-gel migrate
-```
-
-```txt
-Applied m1uwekrn4ni4qs7ul7hfar4xemm5kkxlpswolcoyqj3xdhweomwjrq (00001.edgeql)
-```
-
----
-
-With our schema applied, let's execute some queries using Gel's JavaScript client library. We'll install the client library and Gel's codegen CLI, and create a `seed.ts`.file.
-
-```sh terminal icon="terminal"
-bun add gel
-bun add -D @gel/generate
-touch seed.ts
-```
-
----
-
-Paste the following code into `seed.ts`.
-
-The client auto-connects to the database. We insert a couple movies using the `.execute()` method. We will use EdgeQL's `for` expression to turn this bulk insert into a single optimized query.
-
-```ts seed.ts icon="/icons/typescript.svg"
-import { createClient } from "gel";
-
-const client = createClient();
-
-const INSERT_MOVIE = `
-  with movies := <array<tuple<title: str, year: int64>>>$movies
-  for movie in array_unpack(movies) union (
-    insert Movie {
-      title := movie.title,
-      releaseYear := movie.year,
-    }
-  )
-`;
-
-const movies = [
-  { title: "The Matrix", year: 1999 },
-  { title: "The Matrix Reloaded", year: 2003 },
-  { title: "The Matrix Revolutions", year: 2003 },
-];
-
-await client.execute(INSERT_MOVIE, { movies });
-
-console.log(`Seeding complete.`);
-process.exit();
-```
-
----
-
-Then run this file with Bun.
-
-```sh terminal icon="terminal"
-bun run seed.ts
-```
-
-```txt
-Seeding complete.
-```
-
----
-
-Gel implements a number of code generation tools for TypeScript. To query our newly seeded database in a typesafe way, we'll use `@gel/generate` to code-generate the EdgeQL query builder.
-
-```sh terminal icon="terminal"
-bunx @gel/generate edgeql-js
-```
-
-```txt
-Generating query builder...
-Detected tsconfig.json, generating TypeScript files.
-   To override this, use the --target flag.
-   Run `npx @edgedb/generate --help` for full options.
-Introspecting database schema...
-Writing files to ./dbschema/edgeql-js
-Generation complete! 🤘
-Checking the generated query builder into version control
-is not recommended. Would you like to update .gitignore to ignore
-the query builder directory? The following line will be added:
-
-   dbschema/edgeql-js
-
-[y/n] (leave blank for "y")
-> y
-```
-
----
-
-In `index.ts`, we can import the generated query builder from `./dbschema/edgeql-js` and write a simple select query.
-
-```ts index.ts icon="/icons/typescript.svg"
-import { createClient } from "gel";
-import e from "./dbschema/edgeql-js";
-
-const client = createClient();
-
-const query = e.select(e.Movie, () => ({
-  title: true,
-  releaseYear: true,
-}));
-
-const results = await query.run(client);
-console.log(results);
-
-results; // { title: string, releaseYear: number | null }[]
-```
-
----
-
-Running the file with Bun, we can see the list of movies we inserted.
-
-```sh terminal icon="terminal"
-bun run index.ts
-```
-
-```txt
-[
-  {
-    title: "The Matrix",
-    releaseYear: 1999
-  }, {
-    title: "The Matrix Reloaded",
-    releaseYear: 2003
-  }, {
-    title: "The Matrix Revolutions",
-    releaseYear: 2003
-  }
-]
-```
-
----
-
-For complete documentation, refer to the [Gel docs](https://docs.geldata.com/).