Type: T | U

The result of the chain execution, which matches the type of the chain's functions (T or U).

See Types section for further informations about.

Error if no function is found at the specified index.

import type { ChainLink, LastChainLink, ChainFactory } from '@alessiofrittoli/chain-functions/types'
import { Chain } from '@alessiofrittoli/chain-functions'

type ChainFunction = () => string

const function1: ChainLink<ChainFunction> = next => () => `1-${next()}`
const function2: ChainLink<ChainFunction> = next => () => `2-${next()}`
const function3: LastChainLink<ChainFunction> = () => () => 'end'

const chain: ChainFactory<ChainFunction> = [function1, function2, function3]
const result = Chain.functions(chain)()

console.log(result) // Output: '1-2-end'

Type: boolean

Returns true if the given function is the last function in the chain, false otherwise.

Type: T

A function that can be invoked as part of the chain.

Type: T

A function that can be invoked as the final step in the chain.

// define the chain link function type
type ChainFunction = () => string

// declare chain link functions
const function1: ChainLink<ChainFunction> = next => () => `1-${next()}`
const function2: ChainLink<ChainFunction> = next => () => `2-${next()}`
// declare the last chain function
const function3: LastChainLink<ChainFunction> = () => () => 'end'

// declare the chain array
const chain: ChainFactory<ChainFunction> = [function1, function2, function3]
// execute the chain array
const result = Chain.functions(chain)()

console.log(result) // Output: '1-2-end'

type ChainFunctionProps = {
  someProperty: string
  firstFunction?: boolean
  secondFunction?: boolean
  thirdFunction?: boolean
}
// define the chain link function type
type ChainFunction = (props: ChainFunctionProps) => ChainFunctionProps

// declare chain link functions
const function1: ChainLink<ChainFunction> = next => props => {
  // edit properties
  props.someProperty = 'Edited by 1st function'
  props.firstFunction = true
  // call the next function in the chain
  return next(props)
}

const function2: ChainLink<ChainFunction> = next => props => {
  props.secondFunction = true

  if (props.someProperty === 'Edited by 1st function') {
    // stop chain execution if some condition is met.
    return props
  }

  // call the next function in the chain
  return next(props)
}

// declare the last chain function
const function3: LastChainLink<ChainFunction> = () => props => {
  props.thirdFunction = true
  return props
}

// declare the chain array
const chain: ChainFactory<ChainFunction> = [function1, function2, function3]
// declare the initial state
const initialState: ChainFunctionProps = {
  someProperty: 'Initial value',
  firstFunction: false,
  secondFunction: false,
  thirdFunction: false,
}
// execute the chain array with initial state
const result = Chain.functions(chain)(initialState)

console.log(result)
// Output: {
//  someProperty    : 'Edited by 1st function',
//  firstFunction   : true,
//  secondFunction  : true,
//  thirdFunction   : false,
// }

type ChainFunction = () => string
type LastChainFunction = () => boolean

const function1: ChainLink<ChainFunction> = next => () => `1-${next()}`
const function2: ChainLink<ChainFunction> = next => () => `2-${next()}`
const function3: LastChainLink<LastChainFunction> = () => () => true

const chain: ChainFactory<ChainFunction, LastChainFunction> = [function1, function2, function3]
const result = Chain.functions(chain)()

console.log(result) // Outputs: '1-2-true'

type ChainFunction = () => string | Promise<string>

const function1: ChainLink<ChainFunction> = next => async () => {
  // simulate a long task running
  await new Promise<void>(resolve => setTimeout(resolve, 5000))
  return `1-${next()}`
}
// this function is executed once `function1` Promise get resolved.
const function2: ChainLink<ChainFunction> = next => () => `2-${next()}`
const function3: LastChainLink<ChainFunction> = () => () => 'end'

const chain: ChainFactory<ChainFunction> = [function1, function2, function3]
const result = Chain.functions(chain)() // `result` is now a promise

console.log(await result) // Outputs: '1-2-end'

// src/middleware.ts

import type { ChainFactory, ChainLink, LastChainLink } from '@alessiofrittoli/chain-functions/types'
import { NextMiddleware, NextResponse } from 'next/server'
import { Chain } from '@alessiofrittoli/chain-functions'

type Middleware = ChainLink<NextMiddleware>
type LastMiddleware = () => NextResponse<unknown>
type MiddlewareFactory = ChainFactory<NextMiddleware, LastMiddleware>

const middleware1: Middleware = next => async (request, event) => {
  const { nextUrl } = request

  if (nextUrl === '...') {
    const rewriteUrl = '...'
    return NextResponse.rewrite(rewriteUrl)
  }

  return next(request, event)
}

const middleware2: Middleware = next => async (request, event) => {
  const response = await next(request, event)

  // do something with `response` returned by the next middleware.
  // ...

  return response
}

// ensures `NextResponse.next()` is called if no one stops the chain.
const lastMiddleware: LastChainLink<LastMiddleware> = () => () => NextResponse.next()

const middlewares: MiddlewareFactory = [middleware1, middleware2, lastMiddleware]

export const config = {
  matcher: [
    /**
     * Match all request paths except for the ones starting with:
     * - api (API routes)
     * - _next/static (static files)
     * - _next/image (image optimization files)
     * - favicon.ico (favicon file)
     */
    '/((?!api/|_next|.*\\..*).*)',
  ],
}

// note that we do not execute the chain like in the previous examples since Next.js is responsible for the execution, providing `request` and `event` parameters to the `middleware` functions.
export default Chain.functions(middlewares)