Macro

Reusable route options.

Imagine we have an authentication check like this:

import { Elysia, t } from 'elysia'

new Elysia()
  .post('/user', {
    cookie: t.Object({
      session: t.String()
    }),
    beforeHandle({ cookie: { session } }) {
      if(!session.value) throw 'Unauthorized'
    }
  }, ({ body }) => body)
  .listen(3000)

If we have multiple routes that require authentication, we have to repeat the same options over and over again.

Instead, we can use a macro to reuse route options:

import { Elysia, t } from 'elysia'

new Elysia()
  .macro({ auth: {
    cookie: t.Object({
      session: t.String()
    }),
    // psuedo auth check
    beforeHandle({ cookie: { session }, status }) {
      if(!session.value) return status(401)
    }
  } })
  .post('/user', {
    auth: true
  }, ({ body }) => body)
  .listen(3000)

auth will then inline both cookie, and beforeHandle to the route.

Simply put, Macro is a reusable route option, similar to function but as a route option with type soundness.

Assignment

Let’s define a macro to check if a body is a Fibonacci number:

function isFibonacci(n: number) {
  let a = 0, b = 1
  while(b < n) [a, b] = [b, a + b]
  return b === n || n === 0
}

Assignments

0 of 2 assignments passed

Enforce body schema
Not passed yet
Let's enforce a schema as body for POST `/` endpoint that accept a number.
Check if body is in the Fibonacci sequence
Not passed yet
We can use `isFibonacci` function to check if the number is in Fibonacci sequence. If it is not, return 418 status

To enforce type, we can define a body property in the macro.
To short-circuit the request, we can use status function to return early.

import { Elysia, t } from 'elysia'

function isPerfectSquare(x: number) {
    const s = Math.floor(Math.sqrt(x))
    return s * s === x
}

function isFibonacci(n: number) {
    if (n < 0) return false

    return isPerfectSquare(5 * n * n + 4) || isPerfectSquare(5 * n * n - 4)
}

new Elysia()
    .macro({ isFibonacci: {
    body: t.Number(),
        beforeHandle({ body, status }) {
            if(!isFibonacci(body)) return status(418)
        }
    } })
  .post('/', {
    isFibonacci: true
  }, ({ body }) => body)
    .listen(3000)

One sec, warming things up…

Enforce body schema

Check if body is in the Fibonacci sequence