メインコンテンツへスキップ
バージョン: 最新版 (v5.0.x)

返信

返信​

はじめに​

ハンドラ関数の第2パラメータはReplyです。Replyは、次の関数とプロパティを公開するFastifyのコアオブジェクトです。

  • .code(statusCode) - ステータスコードを設定します。
  • .status(statusCode) - .code(statusCode)のエイリアスです。
  • .statusCode - HTTPステータスコードの読み取りと設定を行います。
  • .elapsedTime - リクエストがFastifyによって受信されてから経過した時間を返します。
  • .server - fastifyインスタンスオブジェクトへの参照です。
  • .header(name, value) - レスポンスヘッダーを設定します。
  • .headers(object) - オブジェクトのすべてのキーをレスポンスヘッダーとして設定します。
  • .getHeader(name) - すでに設定されているヘッダーの値を取得します。
  • .getHeaders() - 現在のすべてのレスポンスヘッダーの浅いコピーを取得します。
  • .removeHeader(key) - 前に設定されたヘッダーの値を削除します。
  • .hasHeader(name) - ヘッダーが設定されているかどうかを判定します。
  • .writeEarlyHints(hints, callback) - レスポンスの準備中にユーザーに早期ヒントを送信します。
  • .trailer(key, function) - レスポントレーラーを設定します。
  • .hasTrailer(key) - トレーラーが設定されているかどうかを判定します。
  • .removeTrailer(key) - 前に設定されたトレーラーの値を削除します。
  • .type(value) - Content-Typeヘッダーを設定します。
  • .redirect(dest, [code,]) - 指定されたURLにリダイレクトします。ステータスコードはオプションです（デフォルトは302）。
  • .callNotFound() - カスタムのnot foundハンドラを呼び出します。
  • .serialize(payload) - 指定されたペイロードをデフォルトのJSONシリアライザまたはカスタムシリアライザ（設定されている場合）を使用してシリアライズし、シリアライズされたペイロードを返します。
  • .getSerializationFunction(schema | httpStatus, [contentType]) - 指定されたスキーマまたはHTTPステータス（いずれかが設定されている場合）のシリアライゼーション関数を返します。
  • .compileSerializationSchema(schema, [httpStatus], [contentType]) - 指定されたスキーマをコンパイルし、デフォルト（またはカスタマイズされた）SerializerCompilerを使用してシリアライゼーション関数を返します。オプションのhttpStatusは、提供された場合、SerializerCompilerに転送されます。デフォルトはundefinedです。
  • .serializeInput(data, schema, [,httpStatus], [contentType]) - 指定されたスキーマを使用して指定されたデータをシリアライズし、シリアライズされたペイロードを返します。オプションのhttpStatusとcontentTypeが提供された場合、この関数は、その特定のコンテンツタイプとHTTPステータスコードに対して指定されたシリアライザ関数を使用します。デフォルトはundefinedです。
  • .serializer(function) - ペイロードのカスタムシリアライザを設定します。
  • .send(payload) - ペイロードをユーザーに送信します。プレーンテキスト、バッファ、JSON、ストリーム、またはErrorオブジェクトです。
  • .sent - sendがすでに呼び出されたかどうかを知る必要がある場合に使用できるブール値です。
  • .hijack() - 通常のリクエストライフサイクルを中断します。
  • .raw - Nodeコアからのhttp.ServerResponseです。
  • .log - 受信リクエストのロガーインスタンスです。
  • .request - 受信リクエストです。
fastify.get('/', options, function (request, reply) {
  // Your code
  reply
    .code(200)
    .header('Content-Type', 'application/json; charset=utf-8')
    .send({ hello: 'world' })
})

.code(statusCode)​

reply.codeで設定されていない場合、結果のstatusCodeは200になります。

.elapsedTime​

カスタムレスポンスタイムゲッターを呼び出して、リクエストがFastifyによって受信されてから経過した時間を計算します。

この関数がonResponseフックで呼び出されない限り、常に0を返します。

const milliseconds = reply.elapsedTime

.statusCode​

このプロパティはHTTPステータスコードを読み書きします。セッターとして使用する場合、reply.code()のエイリアスです。

if (reply.statusCode >= 299) {
  reply.statusCode = 500
}

.server​

現在のカプセル化コンテキストにスコープされたFastifyサーバーインスタンスです。

fastify.decorate('util', function util () {
  return 'foo'
})

fastify.get('/', async function (req, rep) {
  return rep.server.util() // foo
})

.header(key, value)​

レスポンスヘッダーを設定します。値が省略されているか未定義の場合、''に変換されます。

注：ヘッダーの値は、encodeURIやencodeurlなどのモジュールを使用して適切にエンコードする必要があります。無効な文字は、500 TypeErrorレスポンスになります。

詳細については、http.ServerResponse#setHeaderを参照してください。

    • キーとしてset-cookieを使用して異なる値をCookieとして送信する場合、各値は前の値を置き換えるのではなく、Cookieとして送信されます。

      reply.header('set-cookie', 'foo');
      reply.header('set-cookie', 'bar');

    • ブラウザは、set-cookieヘッダーの最新の参照のみを考慮します。これは、返信に追加されたときにset-cookieヘッダーの解析を回避し、返信のシリアライゼーションを高速化するために行われます。

    • set-cookieヘッダーをリセットするには、reply.removeHeader('set-cookie')を明示的に呼び出す必要があります。.removeHeader(key)の詳細についてはこちらをご覧ください。

.headers(object)​

オブジェクトのすべてのキーをレスポンスヘッダーとして設定します。.headerが内部的に呼び出されます。

reply.headers({
  'x-foo': 'foo',
  'x-bar': 'bar'
})

.getHeader(key)​

以前に設定されたヘッダーの値を取得します。

reply.header('x-foo', 'foo') // setHeader: key, value
reply.getHeader('x-foo') // 'foo'

.getHeaders()​

生のhttp.ServerResponseを介して設定されたものも含め、現在のすべてのレスポンスヘッダーの浅いコピーを取得します。Fastifyを介して設定されたヘッダーは、http.ServerResponseを介して設定されたヘッダーよりも優先されます。

reply.header('x-foo', 'foo')
reply.header('x-bar', 'bar')
reply.raw.setHeader('x-foo', 'foo2')
reply.getHeaders() // { 'x-foo': 'foo', 'x-bar': 'bar' }

.removeHeader(key)​

以前に設定されたヘッダーの値を削除します。

reply.header('x-foo', 'foo')
reply.removeHeader('x-foo')
reply.getHeader('x-foo') // undefined

.hasHeader(key)​

指定されたヘッダーが設定されているかどうかを示すブール値を返します。

.writeEarlyHints(hints, callback)​

クライアントに早期ヒントを送信します。早期ヒントにより、クライアントは最終的なレスポンスが送信される前にリソースの処理を開始できます。これにより、サーバーがレスポンスを生成している間にクライアントがリソースをプリロードまたはプリコネクトできるため、パフォーマンスが向上します。

hintsパラメータは、早期ヒントのキーと値のペアを含むオブジェクトです。

例

reply.writeEarlyHints({ 
  Link: '</styles.css>; rel=preload; as=style'
});

オプションのcallbackパラメータは、ヒントが送信された後、またはエラーが発生した場合に呼び出される関数です。

.trailer(key, function)​

レスポンストレーラーを設定します。トレーラーは通常、大量のリソースを必要とするヘッダーをdataの後で送信する必要がある場合（例：Server-TimingとEtag）に使用されます。これにより、クライアントがレスポンスデータをできるだけ早く受信できます。

注：トレーラーを使用すると、ヘッダーTransfer-Encoding: chunkedが追加されます。これは、Node.jsでトレーラーを使用するための必須要件です。

注：doneコールバックに渡されたエラーは無視されます。エラーに関心がある場合は、デバッグレベルのログを有効にできます。

reply.trailer('server-timing', function() {
  return 'db;dur=53, app;dur=47.2'
})

const { createHash } = require('node:crypto')
// trailer function also receive two argument
// @param {object} reply fastify reply
// @param {string|Buffer|null} payload payload that already sent, note that it will be null when stream is sent
// @param {function} done callback to set trailer value
reply.trailer('content-md5', function(reply, payload, done) {
  const hash = createHash('md5')
  hash.update(payload)
  done(null, hash.disgest('hex'))
})

// when you prefer async-await
reply.trailer('content-md5', async function(reply, payload) {
  const hash = createHash('md5')
  hash.update(payload)
  return hash.disgest('hex')
})

.hasTrailer(key)​

指定されたトレーラーが設定されているかどうかを示すブール値を返します。

.removeTrailer(key)​

以前に設定されたトレーラーの値を削除します。

reply.trailer('server-timing', function() {
  return 'db;dur=53, app;dur=47.2'
})
reply.removeTrailer('server-timing')
reply.getTrailer('server-timing') // undefined

.redirect(dest,[code ,])​

指定されたURLにリクエストをリダイレクトします。ステータスコードはオプションで、codeを呼び出してステータスコードが設定されていない場合は、デフォルトで302になります。

注: 入力URLは、encodeURIまたはencodeurlなどのモジュールを使用して適切にエンコードする必要があります。無効なURLは、500 TypeErrorレスポンスになります。

例（reply.code()呼び出しなし）：ステータスコードを302に設定し、/homeにリダイレクトします。

reply.redirect('/home')

例（reply.code()呼び出しなし）：ステータスコードを303に設定し、/homeにリダイレクトします。

reply.redirect('/home', 303)

例（reply.code()呼び出しあり）：ステータスコードを303に設定し、/homeにリダイレクトします。

reply.code(303).redirect('/home')

例（reply.code()呼び出しあり）：ステータスコードを302に設定し、/homeにリダイレクトします。

reply.code(303).redirect('/home', 302)

.callNotFound()​

カスタムの404ハンドラーを呼び出します。setNotFoundHandlerで指定されたpreHandlerフックのみが呼び出されます。

reply.callNotFound()

.type(contentType)​

レスポンスのコンテンツタイプを設定します。これはreply.header('Content-Type', 'the/type')のショートカットです。

reply.type('text/html')

Content-TypeにJSONサブタイプがあり、charsetパラメーターが設定されていない場合、デフォルトでutf-8がcharsetとして使用されます。

.getSerializationFunction(schema | httpStatus,[contentType])​

この関数を、提供されたschemaまたはhttpStatus、およびオプションのcontentTypeを使用して呼び出すと、多様な入力をシリアライズするために使用できるシリアライゼーション関数が返されます。提供された入力のいずれも使用してシリアライゼーション関数が検出されない場合は、undefinedを返します。

これは、ルートにアタッチされたschema#responses、またはcompileSerializationSchemaを使用してコンパイルされたシリアライゼーション関数に大きく依存します。

const serialize = reply
                  .getSerializationFunction({
                    type: 'object', 
                    properties: { 
                      foo: { 
                        type: 'string' 
                      } 
                    } 
                  })
serialize({ foo: 'bar' }) // '{"foo":"bar"}'

// or

const serialize = reply
                  .getSerializationFunction(200)
serialize({ foo: 'bar' }) // '{"foo":"bar"}'

// or

const serialize = reply
                  .getSerializationFunction(200, 'application/json')
serialize({ foo: 'bar' }) // '{"foo":"bar"}'

シリアライゼーションスキーマのコンパイル方法の詳細については、.compileSerializationSchema(schema, [httpStatus], [contentType])を参照してください。

.compileSerializationSchema(schema,[httpStatus], [contentType])​

この関数は、シリアライゼーションスキーマをコンパイルし、データのシリアライズに使用できる関数を返します。返される関数（別名*シリアライゼーション関数*）は、提供されたSerializerCompilerを使用してコンパイルされます。また、コンパイル呼び出しを削減するためにWeakMapを使用してキャッシュされます。

オプションのパラメーターhttpStatusとcontentTypeは、提供された場合、SerializerCompilerに直接転送されるため、カスタムSerializerCompilerを使用する場合にシリアライゼーション関数をコンパイルするために使用できます。

これは、ルートにアタッチされたschema#responses、またはcompileSerializationSchemaを使用してコンパイルされたシリアライゼーション関数に大きく依存します。

const serialize = reply
                  .compileSerializationSchema({
                    type: 'object', 
                    properties: { 
                      foo: { 
                        type: 'string' 
                      } 
                    } 
                  })
serialize({ foo: 'bar' }) // '{"foo":"bar"}'

// or

const serialize = reply
                  .compileSerializationSchema({
                    type: 'object', 
                    properties: { 
                      foo: { 
                        type: 'string' 
                      } 
                    } 
                  }, 200)
serialize({ foo: 'bar' }) // '{"foo":"bar"}'

// or

const serialize = reply
                  .compileSerializationSchema({
                        '3xx': {
                          content: {
                            'application/json': {
                              schema: {
                                name: { type: 'string' },
                                phone: { type: 'number' }
                              }
                            }
                          }
                        }
                  }, '3xx', 'application/json')
serialize({ name: 'Jone', phone: 201090909090 }) // '{"name":"Jone", "phone":201090909090}'

この関数を使用する際には注意が必要です。提供されたスキーマに基づいてコンパイルされたシリアライゼーション関数をキャッシュするためです。提供されたスキーマが変更または変更された場合、シリアライゼーション関数はスキーマが変更されたことを検出しません。たとえば、以前に提供されたスキーマの参照に基づいて、以前にコンパイルされたシリアライゼーション関数を再利用します。

スキーマのプロパティを変更する必要がある場合は、常にまったく新しいオブジェクトを作成してください。そうしないと、実装はキャッシュメカニズムの利点を享受できません。

次のスキーマを例として使用します

const schema1 = {
  type: 'object',
  properties: {
    foo: {
      type: 'string'
    }
  }
}

非推奨

const serialize = reply.compileSerializationSchema(schema1)

// Later on...
schema1.properties.foo.type. = 'integer'
const newSerialize = reply.compileSerializationSchema(schema1)

console.log(newSerialize === serialize) // true

推奨

const serialize = reply.compileSerializationSchema(schema1)

// Later on...
const newSchema = Object.assign({}, schema1)
newSchema.properties.foo.type = 'integer'

const newSerialize = reply.compileSerializationSchema(newSchema)

console.log(newSerialize === serialize) // false

.serializeInput(data,[schema | httpStatus], [httpStatus], [contentType])​

この関数は、提供されたスキーマまたはHTTPステータスコードに基づいて入力データをシリアライズします。両方が提供されている場合、httpStatusが優先されます。

特定のschemaにシリアライゼーション関数がない場合、新しいシリアライゼーション関数がコンパイルされ、httpStatusとcontentTypeが提供されている場合は転送されます。

reply
  .serializeInput({ foo: 'bar'}, {  
    type: 'object', 
    properties: { 
      foo: { 
        type: 'string' 
      } 
    } 
  }) // '{"foo":"bar"}'

// or

reply
  .serializeInput({ foo: 'bar'}, {
    type: 'object', 
    properties: { 
      foo: { 
        type: 'string' 
      } 
    } 
  }, 200) // '{"foo":"bar"}'

// or

reply
  .serializeInput({ foo: 'bar'}, 200) // '{"foo":"bar"}'

// or

reply
  .serializeInput({ name: 'Jone', age: 18 }, '200', 'application/vnd.v1+json') // '{"name": "Jone", "age": 18}'

シリアライゼーションスキーマのコンパイル方法の詳細については、.compileSerializationSchema(schema, [httpStatus], [contentType])を参照してください。

.serializer(func)​

デフォルトでは、.send()は、Buffer、stream、string、undefined、またはErrorのいずれでもない値をJSONシリアライズします。特定のリクエストに対してデフォルトのシリアライザーをカスタムシリアライザーに置き換える必要がある場合は、.serializer()ユーティリティを使用できます。カスタムシリアライザーを使用する場合は、カスタムの'Content-Type'ヘッダーを設定する必要があることに注意してください。

reply
  .header('Content-Type', 'application/x-protobuf')
  .serializer(protoBuf.serialize)

バッファー、ストリーム、文字列（シリアライザーが設定されていない場合）は既にシリアライズされていると見なされるため、ハンドラー内でこのユーティリティを使用する必要はありません。

reply
  .header('Content-Type', 'application/x-protobuf')
  .send(protoBuf.serialize(data))

さまざまなタイプの値の送信の詳細については、.send()を参照してください。

.raw​

これは、Nodeコアからのhttp.ServerResponseです。Fastify Replyオブジェクトを使用している間は、HTTPレスポンスの処理に関するすべてのFastifyロジックをスキップするため、Reply.raw関数の使用は自己責任で行ってください。例：

app.get('/cookie-2', (req, reply) => {
  reply.setCookie('session', 'value', { secure: false }) // this will not be used

  // in this case we are using only the nodejs http server response object
  reply.raw.writeHead(200, { 'Content-Type': 'text/plain' })
  reply.raw.write('ok')
  reply.raw.end()
})

Reply.rawの誤用の別の例は、Replyで説明されています。

.sent​

名前が示すように、.sentは、reply.send()を介してレスポンスが送信されたかどうかを示すプロパティです。reply.hijack()が使用された場合もtrueになります。

ルートハンドラーが非同期関数として定義されている場合、またはプロミスを返す場合、reply.hijack()を呼び出して、ハンドラーのプロミスが解決された後にreply.send()が自動的に呼び出されるのをスキップすることを示すことができます。reply.hijack()を呼び出すことで、アプリケーションは低レベルのリクエストとレスポンスの完全な責任を主張します。さらに、フックは呼び出されません。

.sentプロパティを直接変更することは非推奨です。同じ効果を得るには、前述の.hijack()メソッドを使用してください。

.hijack()​

通常の要求ライフサイクルの実行を停止し、レスポンスの手動送信を処理する必要がある場合があります。

これを実現するために、Fastifyはreply.hijack()メソッドを提供します。これはリクエストライフサイクル中に呼び出すことができ（reply.send()が呼び出される前の任意の時点で）、Fastifyがレスポンスを送信したり、残りのフック（およびレスポンスがハイジャックされる前にハイジャックされた場合のユーザーハンドラー）を実行したりするのを防ぎます。

app.get('/', (req, reply) => {
  reply.hijack()
  reply.raw.end('hello world')

  return Promise.resolve('this will be skipped')
})

reply.rawを使用してユーザーにレスポンスを送信する場合でも、onResponseフックは実行されます。

.send(data)​

名前が示すように、.send()はペイロードをエンドユーザーに送信する関数です。

オブジェクト​

前述のように、JSONオブジェクトを送信する場合、出力スキーマを設定すると、sendはfast-json-stringifyを使用してオブジェクトをシリアライズし、それ以外の場合はJSON.stringify()が使用されます。

fastify.get('/json', options, function (request, reply) {
  reply.send({ hello: 'world' })
})

文字列​

Content-Typeなしで文字列をsendに渡すと、text/plain; charset=utf-8として送信されます。Content-Typeヘッダーを設定して文字列をsendに渡すと、カスタムシリアライザーが設定されている場合はそれを使用してシリアライズされ、それ以外の場合は変更されずに送信されます（Content-Typeヘッダーがapplication/json; charset=utf-8に設定されている場合を除き、その場合はオブジェクトのようにJSONシリアライズされます—上記のセクションを参照）。

fastify.get('/json', options, function (request, reply) {
  reply.send('plain string')
})

ストリーム​

ストリームを送信していて'Content-Type'ヘッダーを設定していない場合、sendはそれを'application/octet-stream'に設定します。

前述のように、ストリームはプリシリアライズされていると見なされるため、レスポンス検証なしで変更されずに送信されます。

const fs = require('node:fs')

fastify.get('/streams', function (request, reply) {
  const stream = fs.createReadStream('some-file', 'utf8')
  reply.header('Content-Type', 'application/octet-stream')
  reply.send(stream)
})

async-awaitを使用する場合は、replyオブジェクトを返すか、awaitする必要があります。

const fs = require('node:fs')

fastify.get('/streams', async function (request, reply) {
  const stream = fs.createReadStream('some-file', 'utf8')
  reply.header('Content-Type', 'application/octet-stream')
  return reply.send(stream)
})

バッファー​

バッファーを送信していて'Content-Type'ヘッダーを設定していない場合、sendはそれを'application/octet-stream'に設定します。

前述のように、バッファーはプリシリアライズされていると見なされるため、レスポンス検証なしで変更されずに送信されます。

const fs = require('node:fs')

fastify.get('/streams', function (request, reply) {
  fs.readFile('some-file', (err, fileBuffer) => {
    reply.send(err || fileBuffer)
  })
})

async-awaitを使用する場合は、replyオブジェクトを返すか、awaitする必要があります。

const fs = require('node:fs')

fastify.get('/streams', async function (request, reply) {
  fs.readFile('some-file', (err, fileBuffer) => {
    reply.send(err || fileBuffer)
  })
  return reply
})

TypedArray​

sendはTypedArrayをバッファーとして管理し、'Content-Type'ヘッダーがまだ設定されていない場合は'application/octet-stream'に設定します。

前述のように、TypedArray/バッファーはプリシリアライズされていると見なされるため、レスポンス検証なしで変更されずに送信されます。

const fs = require('node:fs')

fastify.get('/streams', function (request, reply) {
  const typedArray = new Uint16Array(10)
  reply.send(typedArray)
})

ReadableStream​

ReadableStreamは上記で説明したノードストリームとして扱われ、コンテンツはプリシリアライズされていると見なされるため、レスポンス検証なしで変更されずに送信されます。

const fs = require('node:fs')
const { ReadableStream } = require('node:stream/web')

fastify.get('/streams', function (request, reply) {
  const stream = fs.createReadStream('some-file')
  reply.header('Content-Type', 'application/octet-stream')
  reply.send(ReadableStream.from(stream))
})

レスポンス​

Responseを使用すると、レスポンスペイロード、ステータスコード、ヘッダーを1か所で管理できます。Response内で提供されるペイロードはプリシリアライズされていると見なされるため、レスポンス検証なしで変更されずに送信されます。

Responseを使用する際には注意してください。ステータスコードとヘッダーは、reply.statusCodeとreply.getHeaders()に直接反映されません。このような動作は、Responseが読み取り専用のステータスコードとヘッダーのみを許可することに基づいています。データは双方向編集が許可されておらず、onSendフックでpayloadをチェックするときに混乱する可能性があります。

const fs = require('node:fs')
const { ReadableStream } = require('node:stream/web')

fastify.get('/streams', function (request, reply) {
  const stream = fs.createReadStream('some-file')
  const readableStream = ReadableStream.from(stream)
  const response = new Response(readableStream, {
    status: 200,
    headers: { 'content-type': 'application/octet-stream' }
  })
  reply.send(response)
})

エラー​

sendにErrorのインスタンスであるオブジェクトを渡すと、Fastifyは自動的に次のように構造化されたエラーを作成します。

{
  error: String        // the HTTP error message
  code: String         // the Fastify error code
  message: String      // the user error message
  statusCode: Number   // the HTTP status code
}

HTTPレスポンスを強化するために使用されるheadersなどのカスタムプロパティをErrorオブジェクトに追加できます。

注: エラーをsendに渡していて、statusCodeが400未満の場合、Fastifyは自動的に500に設定します。

ヒント: http-errorsモジュールまたは@fastify/sensibleプラグインを使用してエラーを生成することにより、エラーを簡素化できます。

fastify.get('/', function (request, reply) {
  reply.send(httpErrors.Gone())
})

JSONエラー出力をカスタマイズするには、次の操作を行います。

  • 必要なステータスコードのレスポンスJSONスキーマを設定します。
  • Errorインスタンスに追加のプロパティを追加します。

返されたステータスコードがレスポンススキーマのリストにない場合、デフォルトの動作が適用されることに注意してください。

fastify.get('/', {
  schema: {
    response: {
      501: {
        type: 'object',
        properties: {
          statusCode: { type: 'number' },
          code: { type: 'string' },
          error: { type: 'string' },
          message: { type: 'string' },
          time: { type: 'string' }
        }
      }
    }
  }
}, function (request, reply) {
  const error = new Error('This endpoint has not been implemented')
  error.time = 'it will be implemented in two weeks'
  reply.code(501).send(error)
})

エラー処理をカスタマイズする場合は、setErrorHandler APIを参照してください。

注：エラーハンドラをカスタマイズする場合は、ログ記録はユーザーの責任です。

API

fastify.setErrorHandler(function (error, request, reply) {
  request.log.warn(error)
  var statusCode = error.statusCode >= 400 ? error.statusCode : 500
  reply
    .code(statusCode)
    .type('text/plain')
    .send(statusCode >= 500 ? 'Internal server error' : error.message)
})

カスタムエラーハンドラ内でreply.send(error)を呼び出すと、エラーがデフォルトのエラーハンドラに送信されることに注意してください。Reply Lifecycleで詳細を確認してください。

ルーターによって生成された404エラーは、setNotFoundHandler を使用します。

API

fastify.setNotFoundHandler(function (request, reply) {
  reply
    .code(404)
    .type('text/plain')
    .send('a custom not found')
})

最終ペイロードの型​

送信されたペイロードの型（シリアライズ後、および任意のonSendフックを通過した後）は、以下のいずれかの型でなければなりません。そうでない場合、エラーが発生します。

  • string
  • Buffer
  • stream
  • undefined
  • null

Async-AwaitとPromises​

FastifyはPromiseをネイティブに処理し、async-awaitをサポートしています。

以下の例では、reply.sendを使用していないことに注意してください。

const { promisify } = require('node:util')
const delay = promisify(setTimeout)

fastify.get('/promises', options, function (request, reply) {
 return delay(200).then(() => { return { hello: 'world' }})
})

fastify.get('/async-await', options, async function (request, reply) {
  await delay(200)
  return { hello: 'world' }
})

拒否されたPromiseは、デフォルトで500のHTTPステータスコードになります。statusCode（またはstatus）とmessageプロパティを持つオブジェクトを使用して、Promiseを拒否するか、async function内でthrowすることで、レスポンスを変更できます。

fastify.get('/teapot', async function (request, reply) {
  const err = new Error()
  err.statusCode = 418
  err.message = 'short and stout'
  throw err
})

fastify.get('/botnet', async function (request, reply) {
  throw { statusCode: 418, message: 'short and stout' }
  // will return to the client the same json
})

詳細については、Routes#async-awaitを参照してください。

.then(fulfilled, rejected)​

名前が示すように、Replyオブジェクトはawaitできます。つまり、await replyはレスポンスが送信されるまで待ちます。await構文はreply.then()を呼び出します。

reply.then(fulfilled, rejected)は2つのパラメータを受け取ります。

  • fulfilledはレスポンスが完全に送信されたときに呼び出されます。
  • rejectedは基盤となるストリームにエラーがあった場合（例：ソケットが破壊された場合）に呼び出されます。

詳細については、