Configuration

Middlewares

Type: MiddlewareConfig

Chain type: "main"

The middlewares object is a key-value pair where the key is the route path and the value is an array of middleware functions. Each middleware function is an async function that takes a single argument, request, which is an object containing the request details.

middleware.ts

import { type MiddlewareConfig } from "@rescale/nemo";
 
const middlewares = {
  "/:path*": async (request, event) => {
    console.log("There is NEMO", request.nextUrl.pathname);
  },
} satisfies MiddlewareConfig;

Global Middlewares

Type: GlobalMiddlewareConfig

Chain type: "before" | "after"

The globalMiddlewares object is a key-value pair where the key is the middleware type and the value is an async function. The middleware type can be either before or after. The before middleware function will be executed before any route middleware, and the after middleware function will be executed after any route middleware.

middleware.ts

import { type GlobalMiddlewareConfig } from "@rescale/nemo";
 
const globalMiddlewares = {
  before: async () => {
    console.log("Before all middlewares");
  },
  after: async () => {
    console.log("After all middlewares");
  },
} satisfies GlobalMiddlewareConfig;

Config object

Type: NemoConfig

The config object is a key-value pair where the key is the configuration option and the value is the configuration value. The available configuration options are:

Prop	Type	Default
`debug`	`boolean`	`false`
`silent`	`boolean`	`false`
`enableTiming`	`boolean`	`false`
`errorHandler`	`ErrorHandler`	`undefined`

middleware.ts

import { type NemoConfig } from "@rescale/nemo";
 
const config = {
  debug: true,
  silent: true,
  enableTiming: true,
  errorHandler: (error, metadata) => {
    console.error(error, metadata);
  },
} satisfies NemoConfig;

Example

Getting all of above informations together makes for us NEMO's full configuration representing all usable properites.

The createNEMO() constructor is the entry point for the NEMO package. It allows you to create a middleware helper that can be used to define middleware functions for your Next.js application.

middleware.ts

import {
  createNEMO,
  type MiddlewareConfig,
  type GlobalMiddlewareConfig,
  type NemoConfig,
} from "@rescale/nemo";
 
const middlewares = {
  "/:path*": async (request) => {
    // middleware functions for /api route
  },
} satisfies MiddlewareConfig;
 
const globalMiddlewares = {
  before: async () => {
    // global middleware function that will be executed before any route middleware
  },
  after: async () => {
    // global middleware function that will be executed after any route middleware
  },
} satisfies GlobalMiddlewareConfig;
 
const nemoConfig = {
  debug: true, // default is false
  silent: true, // default is false
  enableTiming: true, // default is false
  errorHandler: (error, metadata) => {
    // custom error handler
  },
} satisfies NemoConfig;
 
export const middleware = createNEMO(
  middlewares,
  globalMiddlewares,
  nemoConfig,
);
 
export const config = {
  matcher: ["/((?!_next/|_static|_vercel|[\\w-]+\\.\\w+).*)"],
};

Configuration

Middlewares

Global Middlewares

Config object

Example

On this page