Function handler reference

Reference documentation for the shape of the function wrapper.

Every Function must export a handler. Handlers contain the logic that the Function infrastructure runs when your function is invoked.

Create a function handler with the sanity functions add command. Every handler receives an object containing context and event parameters. The function does not require a return value.

{
  clientOptions: {
    apiHost: 'https://api.sanity.io',
    projectId: 'abc123',
    dataset: 'production',
    token: '***************'
  }
}

context.resources gives your function access to the other resources declared in its Blueprint, so you can reference them by name instead of hardcoding IDs that can change between deployments or environments.

It's a callable object rather than a plain record, and supports a few different ways of looking things up:

const resource = context.resources('my-cors-origin')

Searches across all resource types and returns the first resource with a matching name, or undefined if none exists.

const ds = context.resources.dataset('my-dataset')
const fn = context.resources.function('my-other-function')
const cors = context.resources.cors('my-cors-origin')
const project = context.resources.project('my-project')
const role = context.resources.role('my-role')
const webhook = context.resources.webhook('my-webhook')

Each of these narrows the lookup to a single resource type and returns undefined if no resource of that type has that name.

const all = context.resources.all()

Returns a flat array of every resource in the Blueprint, regardless of type.

for (const resource of context.resources) {
  console.log(resource.name, resource.type)
}

context.resources is iterable, so you can loop over every resource directly without calling .all() first.

Every lookup, whether by name, by type, or through .all() / iteration, returns objects (or undefined) with this shape:

interface BlueprintResource<TType extends string = string> {
  id: string
  name: string
  type: TType
}

import { documentEventHandler } from '@sanity/functions'

export const handler = documentEventHandler(async ({ context }) => {
  const notificationsDataset = context.resources.dataset('notifications')

  if (!notificationsDataset) {
    console.log('No "notifications" dataset resource found in this Blueprint')
    return
  }

  console.log('Found dataset resource:', notificationsDataset.id)
})

Contains the shape of the event, which depends on the event:

• In the case of document and media-library Function events, like publish, the event shape is the document. This will vary based on your schema.
• In the case of sync-tag-invalidate Function events, the sync tags will be present under event.data.syncTags.

{
  data: { 
    _id: '1234',
    _type: 'article',
    title: 'Functions quick start',
    _createdAt: '2025-04-24T16:26:58.901Z',
    _publishedAt: '2025-04-24T16:26:58.901Z',
  }
}

{
  data: { 
    syncTags: ['s1:1023', 's3:3021']
  }
}

import { documentEventHandler } from '@sanity/functions'

export const handler = documentEventHandler(async ({ context, event }) => {
  console.log("Context: ", context)
  console.log("Event: ", event)
})

export async function handler({context, event}) {
  console.log("Context: ", context)
  console.log("Event: ", event)
}

When you create a new TypeScript function with sanity functions add, you'll be prompted to add types.

If you did not add types as part of the init process, they are available in the @sanity/functions package:

npm install @sanity/functions

pnpm add @sanity/functions

yarn add @sanity/functions

bun add @sanity/functions

You can then import and use the documentEventHandler helper to provide type support. See the "Example handler" section for implementation details.

Import documentEventHandler.

import {documentEventHandler} from '@sanity/functions'

export const handler = documentEventHandler(async ({context, event}) => {
  // Your function implementation
  console.log('Document updated:', event.data)
})

If you need to type event.data, and you know the shape of your incoming data, you can provide it to documentEventHandler.

import {documentEventHandler} from '@sanity/functions'

interface NotificationData {
  documentId: string
  text: string
}

export const handler = documentEventHandler<NotificationData>(async ({event}) => {
  console.log(event.data.text) // Typed as `string`
  console.log(event.data.notSet) // Will yield type error
})

Import the DocumentEventHandler type.

import {type DocumentEventHandler} from '@sanity/functions'

export const handler: DocumentEventHandler = async ({context, event}) => {
  // …
}

// …you can also define the data type:
export const handler: DocumentEventHandler<{text: string}> = async ({event}) => {
  console.log(event.data.text)
}

Use the @type comment syntax.

/** @type {import('@sanity/functions').DocumentEventHandler} */
export const handler = async ({context, event}) => {
  console.log(event.data.text)
}

// …you can also define the data type:
/** @type {import('@sanity/functions').DocumentEventHandler<{text: string}>} */
export const handler = async ({event}) => {
  console.log(event.data.text)
}