### Run Example Project

Source: https://github.com/felixmosh/bull-board/blob/master/CONTRIBUTING.md

Install and start a standalone example project, such as the Express integration. Redis must be running.

```sh
cd examples/with-express
npm install
npm start
```

--------------------------------

### Running the Express + Passport Example

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/recipes/basic-auth.md

Instructions to clone the repository, install dependencies, and start the example application. Includes the URL and credentials for accessing the authenticated dashboard.

```bash
git clone https://github.com/felixmosh/bull-board
cd bull-board/examples/with-express-auth
npm install && npm start
# http://localhost:3000/ui (login: bull / board)
```

--------------------------------

### Local Development Setup

Source: https://github.com/felixmosh/bull-board/blob/master/README.md

Clone the repository, install dependencies, start Docker, build the project, and run the development server.

```sh
git clone git@github.com:felixmosh/bull-board.git
cd bull-board
yarn && yarn dev:docker && yarn build && yarn dev
```

--------------------------------

### Install and Run Bull-Board in Next.js

Source: https://github.com/felixmosh/bull-board/blob/master/examples/with-nextjs-pages/README.md

Commands to set up Redis, install dependencies, start the development server, and run the worker process for the Next.js Bull-Board example.

```bash
docker compose up -d        # Redis on localhost:6379
yarn install
yarn dev                    # http://localhost:3000
yarn worker                 # second terminal, processes jobs
```

--------------------------------

### Clone and Setup Bull-Board Project

Source: https://github.com/felixmosh/bull-board/blob/master/CONTRIBUTING.md

Commands to clone the repository, install dependencies, start Redis, build packages, and run development servers.

```sh
git clone git@github.com:felixmosh/bull-board.git
cd bull-board
yarn                # install dependencies
yarn dev:docker     # start Redis (docker-compose.redis.yml)
yarn build          # build all publishable packages
yarn dev            # run the UI + API dev servers
```

--------------------------------

### Fastify Server Setup with Bull Board

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/server-adapters/fastify.md

Configure and start a Fastify server with the Bull Board UI. Ensure top-level await is handled if not using modules.

```ts
import { createBullBoard } from '@bull-board/api';
import { BullMQAdapter } from '@bull-board/api/bullMQAdapter';
import { FastifyAdapter } from '@bull-board/fastify';
import { Queue } from 'bullmq';
import Fastify from 'fastify';

const queue = new Queue('my-queue', {
  connection: { host: 'localhost', port: 6379 },
});

const app = Fastify();

const serverAdapter = new FastifyAdapter();

createBullBoard({
  queues: [new BullMQAdapter(queue)],
  serverAdapter,
});

serverAdapter.setBasePath('/ui');
await app.register(serverAdapter.registerPlugin(), { prefix: '/ui' });

await app.listen({ host: '0.0.0.0', port: 3000 });
```

--------------------------------

### Install Project Dependencies

Source: https://github.com/felixmosh/bull-board/blob/master/examples/with-nestjs/README.md

Run this command in your terminal to install all necessary project dependencies.

```bash
$ npm install
```

--------------------------------

### Install Project Dependencies

Source: https://github.com/felixmosh/bull-board/blob/master/examples/with-nestjs-fastify-auth/README.md

Installs all necessary project dependencies using pnpm. Ensure pnpm is installed globally.

```bash
pnpm install
```

--------------------------------

### Install Fastify Adapter Dependencies

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/server-adapters/fastify.md

Install the core API and the Fastify adapter packages using npm.

```sh
npm install @bull-board/api @bull-board/fastify
```

--------------------------------

### Install Project Dependencies

Source: https://github.com/felixmosh/bull-board/blob/master/examples/with-nestjs-module/README.md

Use this command to install all necessary project dependencies via Yarn.

```bash
yarn install
```

--------------------------------

### Install Bull Board Hapi Adapter

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/server-adapters/hapi.md

Install the necessary packages for Bull Board API and the Hapi adapter.

```sh
npm install @bull-board/api @bull-board/hapi
```

--------------------------------

### Install Bun Dependencies

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/server-adapters/bun.md

Install the necessary Bull Board API and Bun adapter packages using Bun's package manager.

```sh
bun add @bull-board/api @bull-board/bun
```

--------------------------------

### Install Bull Board Packages

Source: https://github.com/felixmosh/bull-board/blob/master/README.md

Install the core API and the Express adapter for Bull Board. Other framework adapters are also available.

```sh
npm install @bull-board/api @bull-board/express
# or @bull-board/fastify, @bull-board/koa,
# @bull-board/hapi, @bull-board/nestjs, @bull-board/hono,
# @bull-board/h3, @bull-board/elysia, @bull-board/bun
```

--------------------------------

### Elysia Integration Example

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/server-adapters/elysia.md

Set up Bull Board with Elysia.js, configuring queues, adapters, and the server.

```ts
import { createBullBoard } from '@bull-board/api';
import { BullMQAdapter } from '@bull-board/api/bullMQAdapter';
import { ElysiaAdapter } from '@bull-board/elysia';
import { Queue } from 'bullmq';
import Elysia from 'elysia';

const queue = new Queue('my-queue', {
  connection: { host: 'localhost', port: 6379 },
});

const serverAdapter = new ElysiaAdapter({
  prefix: '/ui',
  basePath: '/api/ui',
});

createBullBoard({
  queues: [new BullMQAdapter(queue)],
  serverAdapter,
  options: {
    // Works around a Bun build issue caused by eval in the default UI bundle.
    uiBasePath: 'node_modules/@bull-board/ui',
  },
});

const app = new Elysia({ prefix: '/api' })
  .use(await serverAdapter.registerPlugin())
  .listen(3000);
```

--------------------------------

### Install Koa Adapter Dependencies

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/server-adapters/koa.md

Install the necessary API and Koa adapter packages for Bull Board.

```sh
npm install @bull-board/api @bull-board/koa
```

--------------------------------

### Basic Hono Setup with Bull Board

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/server-adapters/hono.md

Set up a Hono application with Bull Board, configuring a BullMQ queue and the Hono server adapter. The adapter requires a runtime-specific `serveStatic` helper.

```ts
import { createBullBoard } from '@bull-board/api';
import { BullMQAdapter } from '@bull-board/api/bullMQAdapter';
import { HonoAdapter } from '@bull-board/hono';
import { Queue } from 'bullmq';
import { Hono } from 'hono';
import { serve } from '@hono/node-server';
import { serveStatic } from '@hono/node-server/serve-static';

const queue = new Queue('my-queue', {
  connection: { host: 'localhost', port: 6379 },
});

const app = new Hono();

const serverAdapter = new HonoAdapter(serveStatic);

createBullBoard({
  queues: [new BullMQAdapter(queue)],
  serverAdapter,
});

const basePath = '/ui';
serverAdapter.setBasePath(basePath);
app.route(basePath, serverAdapter.registerPlugin());

serve({ fetch: app.fetch, port: 3000 });

```

--------------------------------

### Run Nest.js Application

Source: https://github.com/felixmosh/bull-board/blob/master/examples/with-nestjs/README.md

Commands to start the Nest.js application in different modes. Use 'start:dev' for development with watch mode and 'start:prod' for production.

```bash
# development
$ npm run start

# watch mode
$ npm run start:dev

# production mode
$ npm run start:prod
```

--------------------------------

### Install H3 Adapter Dependencies

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/server-adapters/h3.md

Install the necessary packages for the Bull Board API and the H3 adapter.

```sh
npm install @bull-board/api @bull-board/h3
```

--------------------------------

### Install Bull Board Elysia Adapter

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/server-adapters/elysia.md

Install the necessary packages for Bull Board API and the Elysia adapter.

```sh
npm install @bull-board/api @bull-board/elysia
```

--------------------------------

### Install Bull Board Hono Adapter

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/server-adapters/hono.md

Install the necessary packages for Bull Board with Hono. `@hono/node-server` is specific to Node.js environments.

```sh
npm install @bull-board/api @bull-board/hono @hono/node-server
```

--------------------------------

### Minimal Express Example

Source: https://github.com/felixmosh/bull-board/blob/master/README.md

Integrate Bull Board with an Express server to provide a dashboard for monitoring BullMQ queues. Ensure Redis is running.

```js
const express = require('express');
const { Queue } = require('bullmq');
const { createBullBoard } = require('@bull-board/api');
const { BullMQAdapter } = require('@bull-board/api/bullMQAdapter');
const { ExpressAdapter } = require('@bull-board/express');

const queue = new Queue('emails', { connection: { host: 'localhost', port: 6379 } });

const serverAdapter = new ExpressAdapter();
serverAdapter.setBasePath('/admin/queues');

const { addQueue, removeQueue, setQueues, replaceQueues } = createBullBoard({
  queues: [new BullAdapter(someQueue), new BullAdapter(someOtherQueue), new BullMQAdapter(queueMQ)],
  serverAdapter: serverAdapter,
});

const app = express();

app.use('/admin/queues', serverAdapter.getRouter());

// other configurations of your server

app.listen(3000, () => {
  console.log('Running on 3000...');
  console.log('For the UI, open http://localhost:3000/admin/queues');
  console.log('Make sure Redis is running on port 6379 by default');
});
```

--------------------------------

### Bun Server Setup with Bull Board

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/server-adapters/bun.md

Integrate Bull Board into a Bun HTTP server by creating queues, setting up the Bun adapter, and merging Bull Board routes with custom routes.

```ts
import {
  createBullBoard
} from '@bull-board/api';
import { BullMQAdapter } from '@bull-board/api/bullMQAdapter';
import { BunAdapter } from '@bull-board/bun';
import { Queue } from 'bullmq';

const queue = new Queue('my-queue', {
  connection: { host: 'localhost', port: 6379 },
});

const serverAdapter = new BunAdapter();
serverAdapter.setBasePath('/ui');

createBullBoard({
  queues: [new BullMQAdapter(queue)],
  serverAdapter,
});

const bullBoardRoutes = serverAdapter.getRoutes();

Bun.serve({
  port: 3000,
  routes: {
    '/health': { GET: () => Response.json({ status: 'ok' }) },
    ...bullBoardRoutes,
  },
});
```

--------------------------------

### Install Express or Fastify Adapter

Source: https://github.com/felixmosh/bull-board/blob/master/packages/nestjs/README.md

Install the appropriate adapter for your NestJS application's HTTP framework. The default is Express.

```bash
$ npm install --save @bull-board/express
```

```bash
$ npm install --save @bull-board/fastify
```

--------------------------------

### Caller-Injected Framework Example

Source: https://github.com/felixmosh/bull-board/blob/master/CLAUDE.md

Illustrative example of using describe.each to test adapters with caller-injected framework instances. This pattern involves looping over npm-aliased majors.

```javascript
describe.each([
  ['fastify@4', require('fastify-v4').default],
  ['fastify@5', require('fastify-v5').default],
])('%s', (_label, Fastify) => {
  runServerAdapterContract('Fastify', async ({ basePath, queue }) => {
    const app = Fastify();
    // ...
  });
});
```

--------------------------------

### Koa Integration Example

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/server-adapters/koa.md

Set up Bull Board with a Koa application, configuring the queue, adapter, and base path for the UI. The `registerPlugin()` method returns Koa middleware that should be mounted after setting the base path.

```ts
import {
  createBullBoard,
} from '@bull-board/api';
import { BullMQAdapter } from '@bull-board/api/bullMQAdapter';
import { KoaAdapter } from '@bull-board/koa';
import { Queue } from 'bullmq';
import Koa from 'koa';

const queue = new Queue('my-queue', {
  connection: { host: 'localhost', port: 6379 },
});

const app = new Koa();

const serverAdapter = new KoaAdapter();

createBullBoard({
  queues: [new BullMQAdapter(queue)],
  serverAdapter,
});

serverAdapter.setBasePath('/ui');
app.use(serverAdapter.registerPlugin());

app.listen(3000);
```

--------------------------------

### Install Bull Board Dependencies

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/queue-adapters/bullmq-pro.md

Install the necessary Bull Board packages for API and Express integration.

```sh
npm install @bull-board/api @bull-board/express
```

--------------------------------

### Start Redis with Docker Compose

Source: https://github.com/felixmosh/bull-board/blob/master/CLAUDE.md

Starts a Redis instance using Docker Compose. Ensure Redis is running locally before executing tests or the dev server.

```bash
docker compose -f docker-compose.redis.yml up -d
```

--------------------------------

### Run Redis Dependency with Docker

Source: https://github.com/felixmosh/bull-board/blob/master/examples/with-nestjs-module/README.md

This command starts the Redis dependency in detached mode using Docker Compose. Ensure Docker is installed and configured.

```bash
docker compose up -d
```

--------------------------------

### Start Nest.js App in Production Mode

Source: https://github.com/felixmosh/bull-board/blob/master/examples/with-nestjs-module/README.md

Builds and starts the Nest.js application for production deployment. This command typically uses npm.

```bash
npm run start:prod
```

--------------------------------

### Install @bull-board/nestjs and @bull-board/api

Source: https://github.com/felixmosh/bull-board/blob/master/packages/nestjs/README.md

Install the core NestJS integration package and the API package. These are required for using Bull Board with NestJS.

```bash
$ npm install --save @bull-board/nestjs @bull-board/api
```

--------------------------------

### Basic Express Setup with Bull Board

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/server-adapters/express.md

Set up Bull Board within an Express application. Ensure the base path in `setBasePath()` matches the mount point in `app.use()`.

```ts
import {
  createBullBoard,
} from '@bull-board/api';
import { BullMQAdapter } from '@bull-board/api/bullMQAdapter';
import { ExpressAdapter } from '@bull-board/express';
import { Queue } from 'bullmq';
import express from 'express';

const queue = new Queue('my-queue', {
  connection: { host: 'localhost', port: 6379 },
});

const serverAdapter = new ExpressAdapter();
serverAdapter.setBasePath('/admin/queues');

createBullBoard({
  queues: [new BullMQAdapter(queue)],
  serverAdapter,
});

const app = express();
app.use('/admin/queues', serverAdapter.getRouter());
app.listen(3000);
```

--------------------------------

### Register Visibility Guards for Queues

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/recipes/visibility-guard.md

This example demonstrates how to set up visibility guards for different queues using BullMQAdapter and ExpressAdapter. It shows how to decode user information from headers and apply role-based or authentication-based visibility rules.

```typescript
import {
  createBullBoard
} from '@bull-board/api';
import { BullMQAdapter } from '@bull-board/api/bullMQAdapter';
import { ExpressAdapter } from '@bull-board/express';

const serverAdapter = new ExpressAdapter();
serverAdapter.setBasePath('/admin/queues');

const billingAdapter = new BullMQAdapter(billingQueue);
billingAdapter.setVisibilityGuard((request) => {
  const user = decodeUserFromHeaders(request.headers);
  return user?.roles.includes('billing') ?? false;
});

const notificationsAdapter = new BullMQAdapter(notificationsQueue);
notificationsAdapter.setVisibilityGuard((request) => {
  const user = decodeUserFromHeaders(request.headers);
  return !!user; // visible to any authenticated user
});

createBullBoard({
  queues: [billingAdapter, notificationsAdapter],
  serverAdapter,
});
```

--------------------------------

### Install Bull-Board Packages

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/server-adapters/nestjs.md

Install the core API and NestJS module, along with the appropriate HTTP server adapter for your NestJS application (Express or Fastify).

```sh
npm install @bull-board/api @bull-board/nestjs
```

```sh
npm install @bull-board/express
# or, for Fastify:
npm install @bull-board/fastify
```

--------------------------------

### Hapi Server Setup with Bull Board

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/server-adapters/hapi.md

Configure and register the Bull Board Hapi adapter with your Hapi server. Ensure the `routes.prefix` matches the base path set on the adapter.

```ts
import { createBullBoard } from '@bull-board/api';
import { BullMQAdapter } from '@bull-board/api/bullMQAdapter';
import { HapiAdapter } from '@bull-board/hapi';
import { Queue } from 'bullmq';
import Hapi from '@hapi/hapi';

const queue = new Queue('my-queue', {
  connection: { host: 'localhost', port: 6379 },
});

const app = Hapi.server({
  port: 3000,
  host: 'localhost',
});

const serverAdapter = new HapiAdapter();

createBullBoard({
  queues: [new BullMQAdapter(queue)],
  serverAdapter,
});

serverAdapter.setBasePath('/ui');
await app.register(serverAdapter.registerPlugin(), {
  routes: { prefix: '/ui' },
});

await app.start();
```

--------------------------------

### Deploy NestJS Application with Mau

Source: https://github.com/felixmosh/bull-board/blob/master/examples/with-nestjs-fastify-auth/README.md

Installs the Mau CLI globally and deploys the NestJS application to AWS. Ensure you have Mau installed and configured.

```bash
pnpm install -g mau

```

```bash
mau deploy
```

--------------------------------

### Compile and Run NestJS Application

Source: https://github.com/felixmosh/bull-board/blob/master/examples/with-nestjs-fastify-auth/README.md

Commands to compile and run the NestJS application. Use 'start:dev' for development with watch mode and 'start:prod' for production.

```bash
pnpm run start

```

```bash
# watch mode
pnpm run start:dev

```

```bash
# production mode
pnpm run start:prod
```

--------------------------------

### Adapter-Internal Framework Example (Jest moduleNameMapper)

Source: https://github.com/felixmosh/bull-board/blob/master/CLAUDE.md

Example of using Jest moduleNameMapper for adapters that construct the framework internally. This aggregates per-version configs to remap imports.

```javascript
module.exports = { projects: ['<rootDir>/jest.config.v4.js', '<rootDir>/jest.config.v5.js'] };
```

```javascript
const base = require('./jest.base.js');
module.exports = { ...base, displayName: 'express@4', moduleNameMapper: { '^express$': 'express-v4' } };
```

--------------------------------

### NestJS Plain Adapter Setup

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/server-adapters/nestjs.md

Manually wire the server adapter in a module's `configure()` method for custom middleware and existing Nest conventions. Ensure BullModule is imported and queues are registered.

```typescript
import {
  DynamicModule,
  MiddlewareConsumer,
  Module,
  NestModule,
} from '@nestjs/common';
import { BullModule } from '@nestjs/bullmq';
import { createBullBoard } from '@bull-board/api';
import { BullMQAdapter } from '@bull-board/api/bullMQAdapter';
import { ExpressAdapter } from '@bull-board/express';
import { Queue } from 'bullmq';

@Module({})
export class QueuesModule implements NestModule {
  static register(): DynamicModule {
    return {
      module: QueuesModule,
      imports: [
        BullModule.forRoot({
          connection: { host: 'localhost', port: 6379 },
        }),
        BullModule.registerQueue({ name: 'test' }),
      ],
    };
  }

  constructor(private readonly testQueue: Queue) {}

  configure(consumer: MiddlewareConsumer) {
    const serverAdapter = new ExpressAdapter();
    serverAdapter.setBasePath('/queues');

    createBullBoard({
      queues: [new BullMQAdapter(this.testQueue)],
      serverAdapter,
    });

    consumer.apply(serverAdapter.getRouter()).forRoutes('/queues');
  }
}
```

--------------------------------

### H3 Application Setup with Bull Board

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/server-adapters/h3.md

Configure and mount the Bull Board H3 adapter within an H3 application. The adapter handles its own sub-paths under the specified base path.

```ts
import { createApp, createRouter } from 'h3';
import { createBullBoard } from '@bull-board/api';
import { BullMQAdapter } from '@bull-board/api/bullMQAdapter';
import { H3Adapter } from '@bull-board/h3';
import { Queue } from 'bullmq';

const queue = new Queue('my-queue', {
  connection: { host: 'localhost', port: 6379 },
});

const serverAdapter = new H3Adapter();
serverAdapter.setBasePath('/ui');

createBullBoard({
  queues: [new BullMQAdapter(queue)],
  serverAdapter,
});

export const app = createApp();
const router = createRouter();

app.use(router);
app.use(serverAdapter.registerHandlers());

```

--------------------------------

### Auto-Login Endpoint for Token-Based Frontend

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/recipes/basic-auth.md

This example shows how to create an admin-only endpoint that establishes a session cookie for a token-based frontend. The frontend then uses this cookie to access the Bull Board UI seamlessly.

```javascript
// Guarded by your normal bearer-token middleware, admin only.
app.get('/api/queue-monitor', requireAdmin, (req, res) => {
  req.login(req.user, (err) => {          // sets the session cookie
    if (err) return res.status(500).end();
    res.json({ url: `${req.protocol}://${req.get('host')}/ui` });
  });
});

```

--------------------------------

### App Router API Route (Hono)

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/recipes/nextjs.md

Set up a catch-all Route Handler for the App Router to integrate bull-board. This example uses the Hono adapter and is suitable for Vercel deployments.

```typescript
import { createBullBoard } from '@bull-board/api';
import { BullMQAdapter } from '@bull-board/api/bullMQAdapter';
import { HonoAdapter } from '@bull-board/hono';
import { serveStatic } from '@hono/node-server/serve-static';
import { Hono } from 'hono';
import { handle } from 'hono/vercel';
import { queue } from '@/lib/queue';

export const runtime = 'nodejs';
export const dynamic = 'force-dynamic';

const basePath = '/api/queues';
const serverAdapter = new HonoAdapter(serveStatic);
serverAdapter.setBasePath(basePath);

createBullBoard({ queues: [new BullMQAdapter(queue)], serverAdapter });

const app = new Hono();
app.route(basePath, serverAdapter.registerPlugin());

export const GET = handle(app);
export const POST = handle(app);
export const PUT = handle(app);
export const PATCH = handle(app);
export const DELETE = handle(app);
```

--------------------------------

### Express + Passport Basic Authentication Setup

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/recipes/basic-auth.md

Configure Express and Passport for basic authentication. This snippet sets up a local strategy for username/password verification and integrates session management.

```javascript
const passport = require('passport');
const LocalStrategy = require('passport-local').Strategy;
const { ensureLoggedIn } = require('connect-ensure-login');
const session = require('express-session');

passport.use(new LocalStrategy((username, password, cb) => {
  if (username === 'bull' && password === 'board') {
    return cb(null, { user: 'bull-board' });
  }
  return cb(null, false);
}));

passport.serializeUser((user, cb) => cb(null, user));
passport.deserializeUser((user, cb) => cb(null, user));

app.use(session({ secret: 'keyboard cat', resave: true, saveUninitialized: true }));
app.use(passport.initialize());
app.use(passport.session());

app.post('/ui/login', passport.authenticate('local', { failureRedirect: '/ui/login?invalid=true' }),
  (req, res) => res.redirect('/ui'));

app.use('/ui', ensureLoggedIn({ redirectTo: '/ui/login' }), serverAdapter.getRouter());
```

--------------------------------

### Configure Express Authentication

Source: https://github.com/felixmosh/bull-board/blob/master/packages/nestjs/README.md

Add basic authentication to the Bull Board UI for Express applications by installing `express-basic-auth` and providing user credentials.

```bash
$ npm install --save express-basic-auth
```

```typescript
import basicAuth from "express-basic-auth";

BullBoardModule.forRoot({
  route: "/queues",
  adapter: ExpressAdapter,
  middleware: basicAuth({
    challenge: true,
    users: { admin: "passwordhere" },
  }),
}),
```

--------------------------------

### Start Nest.js App in Development Mode

Source: https://github.com/felixmosh/bull-board/blob/master/examples/with-nestjs-module/README.md

Launches the Nest.js application in watch mode, automatically recompiling and restarting on file changes. This is ideal for development.

```bash
yarn start:dev
```

--------------------------------

### Initialize BullMQ Pro with Bull Board

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/queue-adapters/bullmq-pro.md

Set up a BullMQ Pro queue and integrate it with Bull Board using the BullMQProAdapter. All BullMQAdapter options are compatible.

```js
const { QueuePro } = require('@taskforcesh/bullmq-pro');
const { createBullBoard } = require('@bull-board/api');
const { BullMQProAdapter } = require('@bull-board/api/bullMQProAdapter');
const { ExpressAdapter } = require('@bull-board/express');

const queuePro = new QueuePro('queueProName');
const serverAdapter = new ExpressAdapter();
serverAdapter.setBasePath('/admin/queues');

createBullBoard({
  queues: [new BullMQProAdapter(queuePro)],
  serverAdapter,
});
```

--------------------------------

### Initialize Bull Board with BullAdapter

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/queue-adapters/bull.md

Set up Bull Board with a Bull queue and an Express server adapter. Ensure Redis is running and accessible.

```typescript
import { createBullBoard } from '@bull-board/api';
import { BullAdapter } from '@bull-board/api/bullAdapter';
import { ExpressAdapter } from '@bull-board/express';
import Queue from 'bull';

const myQueue = new Queue('my-queue', {
  redis: { host: 'localhost', port: 6379 },
});

const serverAdapter = new ExpressAdapter();
serverAdapter.setBasePath('/admin/queues');

createBullBoard({
  queues: [new BullAdapter(myQueue)],
  serverAdapter,
});
```

--------------------------------

### Mix Bull, BullMQ, and BullMQ Pro Adapters

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/queue-adapters/index.md

Illustrates how to create a Bull Board instance with multiple queue types, including Bull, BullMQ, and BullMQ Pro adapters. This allows for a unified dashboard for different queueing systems.

```typescript
createBullBoard({
  queues: [
    new BullAdapter(bullQueue),
    new BullMQAdapter(bullmqQueue),
    new BullMQProAdapter(bullmqProQueue),
  ],
  serverAdapter,
});
```

--------------------------------

### Run Core Unit/Integration Tests

Source: https://github.com/felixmosh/bull-board/blob/master/CONTRIBUTING.md

Navigate to the 'packages/api' directory and run tests. Ensure Redis is running.

```sh
cd packages/api
yarn test
```

--------------------------------

### CSRF Protection Setup with Express and csrf-csrf

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/recipes/csrf-protection.md

This snippet demonstrates the server-side setup for CSRF protection in an Express application using the `csrf-csrf` library. It includes middleware for cookie parsing, CSRF token generation and validation, and applying the protection to specific routes.

```javascript
const { doubleCsrf } = require('csrf-csrf');
const cookieParser = require('cookie-parser');

const { doubleCsrfProtection, generateToken } = doubleCsrf({
  getSecret: () => 'Secret',
  ignoredMethods: ['GET', 'HEAD', 'OPTIONS'],
  getTokenFromRequest: (req) => req.headers['x-xsrf-token'] || '',
  cookieName: 'x-csrf-token',
  cookieOptions: { secure: process.env.NODE_ENV === 'production' },
});

app.use(cookieParser());

app.get('/ui/*', (req, res, next) => {
  if (['api', 'static'].every((part) => !req.path.includes(`/${part}/`))) {
    const token = generateToken(req, res, true);
    res.cookie('XSRF-TOKEN', token, {
      sameSite: 'lax',
      path: '/ui/',
      secure: process.env.NODE_ENV === 'production',
    });
  }
  next();
});

app.use('/ui', doubleCsrfProtection, serverAdapter.getRouter());
```

--------------------------------

### Add a Job to the Queue

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/guide/your-first-dashboard.md

Adds a new job to the previously defined `emailQueue`. This example adds a 'welcome' job with a payload.

```typescript
await emailQueue.add('welcome', { to: 'you@example.com' });
```

--------------------------------

### Alternative UI Path Configuration

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/recipes/nextjs.md

Configure the `uiBasePath` option in `createBullBoard` to specify the UI's location directly, bypassing the default `eval(require.resolve(...))` mechanism. Note that `outputFileTracingIncludes` is still required for deployment.

```typescript
createBullBoard({
  queues,
  serverAdapter,
  options: { uiBasePath: 'node_modules/@bull-board/ui' },
});
```

--------------------------------

### Configure UI Settings with createBullBoard

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/configuration/ui-config.md

Pass UI configuration options directly to `createBullBoard` to customize the dashboard's appearance and behavior. This includes setting the board title, logo, and miscellaneous links.

```typescript
import {
  createBullBoard,
} from '@bull-board/api';
import { BullMQAdapter } from '@bull-board/api/bullMQAdapter';
import { ExpressAdapter } from '@bull-board/express';

const serverAdapter = new ExpressAdapter();
serverAdapter.setBasePath('/admin/queues');

createBullBoard({
  queues: [new BullMQAdapter(emailQueue)],
  serverAdapter,
  options: {
    uiConfig: {
      boardTitle: 'My Queues',
      boardLogo: {
        path: 'https://cdn.example.com/logo.png',
        width: '120px',
        height: 32,
      },
      miscLinks: [{ text: 'Logout', url: '/logout' }],
      hideRedisDetails: true,
      showMetrics: true,
      hideDocsLink: false,
    },
  },
});

```

--------------------------------

### Register a Data Formatter

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/recipes/formatters.md

Example of registering a formatter for the 'data' field to mask an 'apiKey'. Formatters are set per queue adapter and only transform the specified fields.

```typescript
import {
  createBullBoard
} from '@bull-board/api';
import { BullMQAdapter } from '@bull-board/api/bullMQAdapter';

const adapter = new BullMQAdapter(emailQueue);

adapter.setFormatter('data', (data) => ({
  ...data,
  apiKey: data.apiKey ? '***' : undefined,
}));

createBullBoard({ queues: [adapter], serverAdapter });

```

--------------------------------

### Run Adapter Contract Tests

Source: https://github.com/felixmosh/bull-board/blob/master/CONTRIBUTING.md

Execute contract tests for specific adapter workspaces. Redis must be running.

```sh
yarn workspace @bull-board/express test
yarn workspace @bull-board/koa test
```

--------------------------------

### Create Multiple Bull Board Dashboards

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/recipes/multiple-dashboards.md

Initialize separate ExpressAdapters and BullMQAdapters to create distinct dashboards. Set unique base paths for each dashboard and mount their routers to the Express app. This allows for independent configuration and routing of each dashboard instance.

```javascript
const serverAdapter1 = new ExpressAdapter();
const serverAdapter2 = new ExpressAdapter();

createBullBoard({
  queues: [new BullMQAdapter(queueA)],
  serverAdapter: serverAdapter1,
});

createBullBoard({
  queues: [new BullMQAdapter(queueB)],
  serverAdapter: serverAdapter2,
});

serverAdapter1.setBasePath('/instance1');
serverAdapter2.setBasePath('/instance2');

app.use('/instance1', serverAdapter1.getRouter());
app.use('/instance2', serverAdapter2.getRouter());
```

--------------------------------

### Mount Bull-Board Dashboard with Express

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/guide/your-first-dashboard.md

Sets up an Express server, mounts the Bull-Board dashboard using ExpressAdapter, and configures the base path. The `setBasePath` and `app.use` mount path must match.

```typescript
import express from 'express';
import { createBullBoard } from '@bull-board/api';
import { BullMQAdapter } from '@bull-board/api/bullMQAdapter';
import { ExpressAdapter } from '@bull-board/express';
import { emailQueue } from './queues';

const app = express();

const serverAdapter = new ExpressAdapter();
serverAdapter.setBasePath('/admin/queues');

createBullBoard({
  queues: [new BullMQAdapter(emailQueue)],
  serverAdapter,
});

app.use('/admin/queues', serverAdapter.getRouter());

app.listen(3000, () => {
  console.log('Dashboard: http://localhost:3000/admin/queues');
});
```

--------------------------------

### Control Queue Visibility with Visibility Guard

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/queue-adapters/bull.md

Implement a visibility guard to conditionally show or hide queues based on request headers. This example hides queues unless the 'x-tenant-id' header is 'acme'.

```typescript
adapter.setVisibilityGuard((request) => {
  // return true to show this queue, false to hide it
  return request.headers['x-tenant-id'] === 'acme';
});
```

--------------------------------

### Root Module Configuration (NestJS)

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/server-adapters/nestjs.md

Register BullBoardModule globally in your root AppModule using `forRoot()`. This sets up the base route and the server adapter for the dashboard.

```typescript
// app.module.ts
import {
  Module,
} from '@nestjs/common';
import {
  BullModule,
} from '@nestjs/bullmq';
import {
  BullBoardModule,
} from '@bull-board/nestjs';
import {
  ExpressAdapter,
} from '@bull-board/express';
import {
  FeatureModule,
} from './feature/feature.module';

@Module({
  imports: [
    BullModule.forRoot({
      connection: { host: 'localhost', port: 6379 },
    }),
    BullBoardModule.forRoot({
      route: '/queues',
      adapter: ExpressAdapter, // or FastifyAdapter from '@bull-board/fastify'
    }),
    FeatureModule,
  ],
})
export class AppModule {}

```

--------------------------------

### Express Visibility Guard with Tenant ID Header

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/recipes/per-tenant-visibility.md

Configure visibility guards for individual queues in Express by checking a custom header like 'x-tenant-id'. This example demonstrates setting guards for 'tenant-a', 'tenant-b', and a shared queue, ensuring each tenant only sees their designated queues.

```typescript
import { BullMQAdapter } from '@bull-board/api/bullMQAdapter';

const tenantAQueue = new BullMQAdapter(queueA);
tenantAQueue.setVisibilityGuard((req) => req.headers['x-tenant-id'] === 'tenant-a');

const tenantBQueue = new BullMQAdapter(queueB);
tenantBQueue.setVisibilityGuard((req) => req.headers['x-tenant-id'] === 'tenant-b');

const sharedQueue = new BullMQAdapter(common);
sharedQueue.setVisibilityGuard(() => true);

createBullBoard({
  queues: [tenantAQueue, tenantBQueue, sharedQueue],
  serverAdapter,
});
```

--------------------------------

### Run Koa Adapter Tests

Source: https://github.com/felixmosh/bull-board/blob/master/CLAUDE.md

Executes tests for the Koa server adapter. All adapter tests require a running Redis instance.

```bash
yarn workspace @bull-board/koa test
```

--------------------------------

### Enabling Flow Tree Visualization

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/queue-adapters/bullmq.md

Enable the flow tree tab for job details by providing a FlowProducer instance to createBullBoard.

```typescript
import { FlowProducer } from 'bullmq';
import { createBullBoard } from '@bull-board/api';

createBullBoard({
  queues: [new BullMQAdapter(myQueue)],
  serverAdapter,
  options: {
    uiConfig: { /* ... */ },
  },
  flowProducer: new FlowProducer({ connection: { host: 'localhost', port: 6379 } }),
});
```

--------------------------------

### Build Bull-Board Packages

Source: https://github.com/felixmosh/bull-board/blob/master/CONTRIBUTING.md

Build all publishable packages within the monorepo. This command generates the 'dist/' output.

```sh
yarn build
```

--------------------------------

### Hapi Basic Auth Strategy

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/recipes/basic-auth.md

Configure a basic authentication strategy with Hapi and apply it to the Bull-Board UI routes. This method allows for flexible authentication configurations.

```javascript
await app.register(require('@hapi/basic'));
app.auth.strategy('simple', 'basic', {
  validate: async (_req, username, password) => ({
    isValid: username === 'bull' && password === 'board',
    credentials: { username },
  }),
});

const serverAdapter = new HapiAdapter();
createBullBoard({ queues: [new BullMQAdapter(queue)], serverAdapter });
serverAdapter.setBasePath('/ui');

await app.register(
  { plugin: serverAdapter.registerPlugin(), options: { auth: 'simple' } },
  { routes: { prefix: '/ui' } }
);
```

--------------------------------

### Run Express Adapter Tests

Source: https://github.com/felixmosh/bull-board/blob/master/CLAUDE.md

Executes tests for the Express server adapter. All adapter tests require a running Redis instance.

```bash
yarn workspace @bull-board/express test
```

--------------------------------

### Register BullBoardModule in AppModule

Source: https://github.com/felixmosh/bull-board/blob/master/packages/nestjs/README.md

Import and configure the BullBoardModule in your root AppModule. This sets up the Bull Board UI route and specifies the adapter.

```typescript
import { Module } from '@nestjs/common';
import { BullBoardModule } from "@bull-board/nestjs";
import { ExpressAdapter } from "@bull-board/express";

@Module({
  imports: [
    BullModule.forRoot({
      // your bull module config here.
    }),

    BullBoardModule.forRoot({
      route: '/queues',
      adapter: ExpressAdapter // Or FastifyAdapter from `@bull-board/fastify`
    }),
  ],
})
export class AppModule {
}
```

--------------------------------

### Import BullMQAdapter

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/queue-adapters/bullmq.md

Import the BullMQAdapter for use in your project. Supports both ES Module and CommonJS syntax.

```typescript
import { BullMQAdapter } from '@bull-board/api/bullMQAdapter';
```

```javascript
const { BullMQAdapter } = require('@bull-board/api/bullMQAdapter');
```

--------------------------------

### Fastify Basic Auth Integration

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/recipes/basic-auth.md

Register the @fastify/basic-auth plugin to protect your Bull-Board UI. The `onRequest` hook ensures authentication is checked for all subsequent routes.

```javascript
await app.register(require('@fastify/basic-auth'), {
  validate: (username, password, req, reply, done) => {
    if (username === 'bull' && password === 'board') return done();
    done(new Error('Unauthorized'));
  },
  authenticate: { realm: 'Bull-Board' },
});

app.after(() => {
  const serverAdapter = new FastifyAdapter();
  createBullBoard({ queues: [new BullMQAdapter(queue)], serverAdapter });
  serverAdapter.setBasePath('/ui');
  app.register(serverAdapter.registerPlugin(), { prefix: '/ui' });

  app.addHook('onRequest', (req, reply, next) => {
    app.basicAuth(req, reply, (err) => err ? reply.code(401).send({ error: err.name }) : next());
  });
});
```

--------------------------------

### Register Multiple Queues

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/server-adapters/nestjs.md

Configure multiple queues for the dashboard within a single feature module by passing multiple configuration objects to `BullBoardModule.forFeature()`.

```typescript
BullBoardModule.forFeature(
  { name: 'emails', adapter: BullMQAdapter },
  { name: 'billing', adapter: BullMQAdapter },
);

```

--------------------------------

### Create a BullMQ Queue

Source: https://github.com/felixmosh/bull-board/blob/master/website/docs/guide/your-first-dashboard.md

Defines and exports a BullMQ queue instance. Ensure your Redis connection details are correct.

```typescript
import { Queue } from 'bullmq';

export const emailQueue = new Queue('emails', {
  connection: { host: 'localhost', port: 6379 },
});
```