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

サーバー

ファクトリー​

Fastifyモジュールは、新しい

Fastifyサーバーインスタンスを作成するために使用されるファクトリー関数をエクスポートします。このファクトリー関数は、結果のインスタンスをカスタマイズするために使用されるオプションオブジェクトを受け取ります。このドキュメントでは、そのオプションオブジェクトで使用可能なプロパティについて説明します。

http​

  • デフォルト: null

サーバーのリスニングソケットを構成するために使用されるオブジェクト。オプションは、Node.jsコアのcreateServerメソッドと同じです。

このオプションは、オプションhttp2またはhttpsが設定されている場合は無視されます。

http2​

  • デフォルト: false

trueの場合、Node.jsコアのHTTP/2モジュールがソケットのバインドに使用されます。

https​

  • デフォルト: null

TLS用のサーバーのリスニングソケットを構成するために使用されるオブジェクト。オプションは、Node.jsコアのcreateServerメソッドと同じです。このプロパティがnullの場合、ソケットはTLS用に構成されません。

このオプションは、http2オプションが設定されている場合にも適用されます。

connectionTimeout​

  • デフォルト: 0（タイムアウトなし）

サーバーのタイムアウトをミリ秒単位で定義します。このオプションの効果を理解するには、server.timeoutプロパティのドキュメントを参照してください。

serverFactoryオプションが指定されている場合、このオプションは無視されます。

keepAliveTimeout​

  • デフォルト: 72000 (72秒)

サーバーのキープアライブタイムアウトをミリ秒単位で定義します。このオプションの効果を理解するには、server.keepAliveTimeoutプロパティのドキュメントを参照してください。このオプションは、HTTP/1が使用されている場合にのみ適用されます。

serverFactoryオプションが指定されている場合、このオプションは無視されます。

forceCloseConnections​

  • デフォルト: HTTPサーバーが許可する場合は "idle"、それ以外の場合はfalse

trueに設定すると、close時に、サーバーは現在の永続的な接続を反復処理し、それらのソケットを破棄します。

警告接続は、リクエストが完了したかどうかを判断するために検査されません。

Fastifyは、HTTPサーバーのcloseAllConnectionsメソッドがサポートされている場合は優先し、それ以外の場合は内部接続追跡を使用します。

"idle"に設定すると、close時に、サーバーはリクエストを送信していないか、応答を待機していない現在の永続的な接続を反復処理し、それらのソケットを破棄します。この値は、HTTPサーバーがcloseIdleConnectionsメソッドをサポートしている場合にのみサポートされ、それ以外の場合に設定しようとすると例外がスローされます。

maxRequestsPerSocket​

  • デフォルト: 0（制限なし）

ソケットがキープアライブ接続を閉じる前に処理できる最大リクエスト数を定義します。このオプションの効果を理解するには、server.maxRequestsPerSocketプロパティを参照してください。このオプションは、HTTP/1.1が使用されている場合にのみ適用されます。また、serverFactoryオプションが指定されている場合、このオプションは無視されます。

注執筆時点では、node >= v16.10.0 のみがこのオプションをサポートしています。

requestTimeout​

  • デフォルト: 0（制限なし）

クライアントからリクエスト全体を受信するまでの最大ミリ秒数を定義します。このオプションの効果を理解するには、server.requestTimeoutプロパティを参照してください。

serverFactoryオプションが指定されている場合、このオプションは無視されます。サーバーがリバースプロキシなしでデプロイされている場合に、潜在的なサービス拒否攻撃から保護するには、ゼロ以外の値（たとえば120秒）に設定する必要があります。

注執筆時点では、node >= v14.11.0 のみがこのオプションをサポートしています

ignoreTrailingSlash​

  • デフォルト: false

Fastifyは、ルーティングの処理にfind-my-wayを使用します。デフォルトでは、Fastifyは末尾のスラッシュを考慮します。/fooや/foo/のようなパスは、異なるパスとして扱われます。これを変更したい場合は、このフラグをtrueに設定してください。これにより、/fooと/foo/の両方が同じルートを指すようになります。このオプションは、結果のサーバーインスタンスのすべてのルート登録に適用されます。

const fastify = require('fastify')({
  ignoreTrailingSlash: true
})

// registers both "/foo" and "/foo/"
fastify.get('/foo/', function (req, reply) {
  reply.send('foo')
})

// registers both "/bar" and "/bar/"
fastify.get('/bar', function (req, reply) {
  reply.send('bar')
})

ignoreDuplicateSlashes​

  • デフォルト: false

Fastifyは、ルーティングの処理にfind-my-wayを使用します。ignoreDuplicateSlashesオプションを使用して、パスから重複したスラッシュを削除できます。ルートパスとリクエストURLの重複したスラッシュを削除します。このオプションは、結果のサーバーインスタンスのすべてのルート登録に適用されます。

ignoreTrailingSlashとignoreDuplicateSlashesの両方がtrueに設定されている場合、Fastifyは重複したスラッシュを削除し、次に末尾のスラッシュを削除します。つまり、//a//b//c//は/a/b/cに変換されます。

const fastify = require('fastify')({
  ignoreDuplicateSlashes: true
})

// registers "/foo/bar/"
fastify.get('///foo//bar//', function (req, reply) {
  reply.send('foo')
})

maxParamLength​

  • デフォルト: 100

maxParamLengthオプションを使用することで、パラメトリック（標準、正規表現、およびマルチ）ルートのパラメーターのカスタム長を設定できます。デフォルト値は100文字です。最大長制限に達すると、「見つからない」ルートが呼び出されます。

これは、正規表現ベースのルートがある場合に特に役立ち、ReDoS攻撃から保護します。

bodyLimit​

  • デフォルト: 1048576 (1MiB)

サーバーが受け入れることを許可されている最大ペイロード（バイト単位）を定義します。デフォルトのボディリーダーは、ボディのサイズがこの制限を超えると、FST_ERR_CTP_BODY_TOO_LARGE応答を送信します。preParsingフックが指定されている場合、この制限はフックが返すストリームのサイズ（つまり、「デコードされた」ボディのサイズ）に適用されます。

onProtoPoisoning​

  • デフォルト: 'error'

__proto__を持つJSONオブジェクトを解析するときにフレームワークが実行する必要があるアクションを定義します。この機能は、secure-json-parseによって提供されます。プロトタイプ汚染攻撃の詳細については、プロトタイプ汚染を参照してください。

可能な値は、'error'、'remove'、または'ignore'です。

onConstructorPoisoning​

  • デフォルト: 'error'

constructorを持つJSONオブジェクトを解析するときにフレームワークが実行する必要があるアクションを定義します。この機能は、secure-json-parseによって提供されます。プロトタイプ汚染攻撃の詳細については、プロトタイプ汚染を参照してください。

可能な値は、'error'、'remove'、または'ignore'です。

logger​

Fastifyには、Pinoロガーを介した組み込みのロギングが含まれています。このプロパティは、内部ロガーインスタンスを構成するために使用されます。

このプロパティが持つ可能性のある値は次のとおりです。

  • デフォルト: false。ロガーは無効になっています。すべてのロギングメソッドは、nullロガーのabstract-loggingインスタンスを指します。

  • pinoInstance: 以前にインスタンス化されたPinoのインスタンス。内部ロガーはこのインスタンスを指します。

  • object: 標準的なPinoのオプションオブジェクトです。これはPinoコンストラクタに直接渡されます。オブジェクトに以下のプロパティが存在しない場合、それらは適切に追加されます。

    • level: 最小ログレベル。設定されていない場合は、'info'に設定されます。
    • serializers: シリアライズ関数のハッシュ。デフォルトでは、req（受信リクエストオブジェクト）、res（送信レスポンスオブジェクト）、およびerr（標準のErrorオブジェクト）に対してシリアライザーが追加されます。ログメソッドがこれらのプロパティのいずれかを持つオブジェクトを受け取ると、そのプロパティに対してそれぞれのシリアライザーが使用されます。例:
      fastify.get('/foo', function (req, res) {
        req.log.info({req}) // log the serialized request object
        res.send('foo')
      })
      ユーザーが提供するシリアライザーは、対応するプロパティのデフォルトのシリアライザーを上書きします。

  • loggerInstance: カスタムロガーインスタンス。ロガーは、info、error、debug、fatal、warn、trace、childの各メソッドを持つことでPinoインターフェースに準拠する必要があります。例:

    const pino = require('pino')();

    const customLogger = {
      info: function (o, ...n) {},
      warn: function (o, ...n) {},
      error: function (o, ...n) {},
      fatal: function (o, ...n) {},
      trace: function (o, ...n) {},
      debug: function (o, ...n) {},
      child: function() {
        const child = Object.create(this);
        child.pino = pino.child(...arguments);
        return child;
      },
    };

    const fastify = require('fastify')({logger: customLogger});

disableRequestLogging​

  • デフォルト: false

ログが有効になっている場合、Fastifyはリクエストを受信したときと、そのリクエストに対するレスポンスが送信されたときにinfoレベルのログメッセージを発行します。このオプションをtrueに設定すると、これらのログメッセージが無効になります。これにより、カスタムのonRequestおよびonResponseフックをアタッチすることにより、より柔軟なリクエスト開始と終了のロギングが可能になります。

無効になるその他のログエントリは次のとおりです。

  • 応答コールバックエラー時にデフォルトのonResponseフックによって書き込まれるエラーログ
  • エラー管理時にdefaultErrorHandlerによって書き込まれるエラーログと情報ログ
  • 存在しないルートがリクエストされたときにfourOhFourハンドラーによって書き込まれる情報ログ

Fastifyによって発行される他のログメッセージ（非推奨の警告や、サーバーが閉じている間にリクエストが受信されたときに発行されるメッセージなど）は有効のままです。

// Examples of hooks to replicate the disabled functionality.
fastify.addHook('onRequest', (req, reply, done) => {
  req.log.info({ url: req.raw.url, id: req.id }, 'received request')
  done()
})

fastify.addHook('onResponse', (req, reply, done) => {
  req.log.info({ url: req.raw.originalUrl, statusCode: reply.raw.statusCode }, 'request completed')
  done()
})

serverFactory​

serverFactoryオプションを使用すると、カスタムHTTPサーバーをFastifyに渡すことができます。

serverFactoryは、requestオブジェクトとresponseオブジェクトをパラメータとして受け取るhandlerパラメータと、Fastifyに渡したのと同じオプションオブジェクトを受け取る関数です。

const serverFactory = (handler, opts) => {
  const server = http.createServer((req, res) => {
    handler(req, res)
  })

  return server
}

const fastify = Fastify({ serverFactory })

fastify.get('/', (req, reply) => {
  reply.send({ hello: 'world' })
})

fastify.listen({ port: 3000 })

内部的には、FastifyはNodeコアHTTPサーバーのAPIを使用しているため、カスタムサーバーを使用する場合は、同じAPIが公開されていることを確認する必要があります。そうでない場合は、returnステートメントの前にserverFactory関数内でサーバーインスタンスを拡張できます。

caseSensitive​

  • デフォルト: true

trueの場合、ルートは大文字と小文字を区別して登録されます。つまり、/fooは/Fooと等しくありません。falseの場合、ルートは大文字と小文字を区別しません。

このオプションをfalseに設定すると、RFC3986に反することに注意してください。

caseSensitiveをfalseに設定すると、すべてのパスは小文字として一致しますが、ルートパラメータまたはワイルドカードは元の文字の大小文字を維持します。このオプションはクエリ文字列には影響しません。クエリ文字列の処理を変更するには、querystringParserを参照してください。

fastify.get('/user/:username', (request, reply) => {
  // Given the URL: /USER/NodeJS
  console.log(request.params.username) // -> 'NodeJS'
})

allowUnsafeRegex​

  • デフォルト false

デフォルトでは無効になっているため、ルートは安全な正規表現のみを許可します。安全でない式を使用するには、allowUnsafeRegexをtrueに設定します。

fastify.get('/user/:id(^([0-9]+){4}$)', (request, reply) => {
  // Throws an error without allowUnsafeRegex = true
})

requestIdHeader​

  • デフォルト: 'request-id'

リクエストIDを設定するために使用されるヘッダー名。リクエストIDセクションを参照してください。requestIdHeaderをtrueに設定すると、requestIdHeaderが"request-id"に設定されます。requestIdHeaderを空でない文字列に設定すると、指定された文字列がrequestIdHeaderとして使用されます。デフォルトでは、requestIdHeaderはfalseに設定されており、すぐにgenReqIdを使用します。requestIdHeaderを空の文字列（""）に設定すると、requestIdHeaderがfalseに設定されます。

  • デフォルト: false
const fastify = require('fastify')({
  requestIdHeader: 'x-custom-id', // -> use 'X-Custom-Id' header if available
  //requestIdHeader: false, // -> always use genReqId
})

requestIdLogLabel​

  • デフォルト: 'reqId'

リクエストをログに記録する際に、リクエスト識別子に使用されるラベルを定義します。

genReqId​

  • デフォルト: 提供されている場合は'request-id'ヘッダーの値、それ以外の場合は単調増加する整数

リクエストIDを生成する関数。パラメータとして生の受信リクエストを受け取ります。この関数はエラーがないことが期待されます。

特に分散システムでは、以下に示すように、デフォルトのID生成の動作をオーバーライドする必要がある場合があります。UUIDを生成するには、hyperidを確認してください。

注 genReqIdは、

[requestIdHeader](#requestidheader)で設定されたヘッダーが利用可能な場合（デフォルトは'request-id'）は呼び出されません。
let i = 0
const fastify = require('fastify')({
  genReqId: function (req) { return i++ }
})

trustProxy​

  • デフォルト: false
  • true/false: すべてのプロキシを信頼する（true）か、プロキシを信頼しない（false）。
  • string: 指定されたIP/CIDRのみを信頼する（例: '127.0.0.1'）。カンマ区切りの値のリスト（例: '127.0.0.1,192.168.1.1/24'）にすることができます。
  • Array<string>: 指定されたIP/CIDRリストのみを信頼する（例: ['127.0.0.1']）。
  • number: フロントエンドプロキシサーバーからのn番目のホップをクライアントとして信頼します。
  • Function: addressを最初の引数として受け取るカスタム信頼関数
    function myTrustFn(address, hop) {
      return address === '1.2.3.4' || hop === 1
    }

trustProxyオプションを有効にすると、Fastifyはプロキシの背後にあることを認識し、X-Forwarded-*ヘッダーフィールドが信頼できることを認識します。それ以外の場合は、簡単にスプーフィングされる可能性があります。

const fastify = Fastify({ trustProxy: true })

詳細な例については、proxy-addrパッケージを参照してください。

requestオブジェクトで、ip、ips、host、およびprotocolの値にアクセスできます。

fastify.get('/', (request, reply) => {
  console.log(request.ip)
  console.log(request.ips)
  console.log(request.host)
  console.log(request.protocol)
})

注 リクエストに複数のx-forwarded-hostまたはx-forwarded-protoヘッダーが含まれている場合、request.hostnameおよびrequest.protocolを導出するために使用されるのは最後のヘッダーのみです。

pluginTimeout​

  • デフォルト: 10000

プラグインがロードできる最大時間（ミリ秒単位）。そうでない場合、readyはコード'ERR_AVVIO_PLUGIN_TIMEOUT'のエラーで完了します。0に設定すると、このチェックが無効になります。これは、avvioのtimeoutパラメータを制御します。

querystringParser​

Fastifyが使用するデフォルトのクエリ文字列パーサーは、Node.jsのコアquerystringモジュールです。

このオプションを使用すると、qsなどのカスタムパーサーを使用できます。

キー（値ではなく）のみを大文字と小文字を区別しないようにする場合は、カスタムパーサーを使用してキーのみを小文字に変換することをお勧めします。

const qs = require('qs')
const fastify = require('fastify')({
  querystringParser: str => qs.parse(str)
})

また、Fastifyのデフォルトパーサーを使用できますが、以下に示す大文字と小文字を区別しないキーと値の例のように、いくつかの処理動作を変更できます。

const querystring = require('node:querystring')
const fastify = require('fastify')({
  querystringParser: str => querystring.parse(str.toLowerCase())
})

exposeHeadRoutes​

  • デフォルト: true

定義された各GETルートに対して、兄弟のHEADルートを自動的に作成します。このオプションを無効にせずにカスタムのHEADハンドラーが必要な場合は、GETルートの前に定義してください。

constraints​

Fastifyの組み込みルート制約はfind-my-wayによって提供され、versionまたはhostによってルートを制約できます。find-my-wayの戦略を含むconstraintsオブジェクトを提供することにより、新しい制約戦略を追加したり、組み込み戦略をオーバーライドしたりできます。制約戦略の詳細については、find-my-wayのドキュメントを参照してください。

const customVersionStrategy = {
  storage: function () {
    const versions = {}
    return {
      get: (version) => { return versions[version] || null },
      set: (version, store) => { versions[version] = store }
    }
  },
  deriveVersion: (req, ctx) => {
    return req.headers['accept']
  }
}

const fastify = require('fastify')({
  constraints: {
    version: customVersionStrategy
  }
})

return503OnClosing​

  • デフォルト: true

closeサーバーメソッドの呼び出し後に503を返します。falseの場合、サーバーは通常どおり受信リクエストをルーティングします。

ajv​

カスタムインスタンスを提供せずに、Fastifyで使用されるAjv v8インスタンスを構成します。デフォルトの構成については、#schema-validatorセクションで説明されています。

const fastify = require('fastify')({
  ajv: {
    customOptions: {
      removeAdditional: 'all' // Refer to [ajv options](https://ajv.js.org/options.html#removeadditional)
    },
    plugins: [
      require('ajv-merge-patch'),
      [require('ajv-keywords'), 'instanceof']
      // Usage: [plugin, pluginOptions] - Plugin with options
      // Usage: plugin - Plugin without options
    ]
  }
})

serializerOpts​

レスポンスのペイロードをシリアライズするデフォルトのfast-json-stringifyインスタンスのオプションをカスタマイズします。

const fastify = require('fastify')({
  serializerOpts: {
    rounding: 'ceil'
  }
})

http2SessionTimeout​

  • デフォルト: 72000

すべての受信HTTP/2セッションにデフォルトのタイムアウトをミリ秒単位で設定します。セッションはタイムアウト時に閉じられます。

このオプションは、HTTP/2を使用する場合に、正常な「閉じる」エクスペリエンスを提供するために必要です。低いデフォルト値は、サービス拒否攻撃を軽減するために選択されています。サーバーがロードバランサーの背後にある場合、または自動的にスケールできる場合、この値はユースケースに合わせて増やすことができます。Nodeコアはこれをデフォルトで0に設定します。

frameworkErrors​

  • デフォルト: null

Fastifyは、最も一般的なユースケースに対するデフォルトのエラーハンドラーを提供します。このオプションを使用して、カスタムコードでこれらのハンドラーの1つ以上をオーバーライドできます。

注 現在、FST_ERR_BAD_URLとFST_ERR_ASYNC_CONSTRAINTのみが実装されています。

const fastify = require('fastify')({
  frameworkErrors: function (error, req, res) {
    if (error instanceof FST_ERR_BAD_URL) {
      res.code(400)
      return res.send("Provided url is not valid")
    } else if(error instanceof FST_ERR_ASYNC_CONSTRAINT) {
      res.code(400)
      return res.send("Provided header is not valid")
    } else {
      res.send(err)
    }
  }
})

clientErrorHandler​

クライアント接続によって発行されたerrorイベントをリッスンし、400で応答するclientErrorHandlerを設定します。

このオプションを使用すると、デフォルトのclientErrorHandlerをオーバーライドできます。

  • デフォルト
function defaultClientErrorHandler (err, socket) {
  if (err.code === 'ECONNRESET') {
    return
  }

  const body = JSON.stringify({
    error: http.STATUS_CODES['400'],
    message: 'Client Error',
    statusCode: 400
  })
  this.log.trace({ err }, 'client error')

  if (socket.writable) {
    socket.end([
      'HTTP/1.1 400 Bad Request',
      `Content-Length: ${body.length}`,
      `Content-Type: application/json\r\n\r\n${body}`
    ].join('\r\n'))
  }
}

注 clientErrorHandlerは生のソケットで動作します。ハンドラーは、ステータス行、HTTPヘッダー、およびメッセージ本文を含む適切に形成されたHTTP応答を返すことが期待されます。ソケットへの書き込みを試みる前に、ソケットがすでに破棄されている可能性があるため、ハンドラーはソケットがまだ書き込み可能かどうかを確認する必要があります。

const fastify = require('fastify')({
  clientErrorHandler: function (err, socket) {
    const body = JSON.stringify({
      error: {
        message: 'Client error',
        code: '400'
      }
    })

    // `this` is bound to fastify instance
    this.log.trace({ err }, 'client error')

    // the handler is responsible for generating a valid HTTP response
    socket.end([
      'HTTP/1.1 400 Bad Request',
      `Content-Length: ${body.length}`,
      `Content-Type: application/json\r\n\r\n${body}`
    ].join('\r\n'))
  }
})

rewriteUrl​

URLを書き換えることができる文字列を返す同期コールバック関数を設定します。これは、URLを変更するプロキシの背後にいる場合に役立ちます。URLを書き換えると、reqオブジェクトのurlプロパティが変更されます。

rewriteUrlはルーティング前に呼び出され、カプセル化されておらず、インスタンス全体の構成であることに注意してください。

// @param {object} req The raw Node.js HTTP request, not the `FastifyRequest` object.
// @this Fastify The root Fastify instance (not an encapsulated instance).
// @returns {string} The path that the request should be mapped to.
function rewriteUrl (req) { 
  if (req.url === '/hi') {
    this.log.debug({ originalUrl: req.url, url: '/hello' }, 'rewrite url');
    return '/hello'
  } else {
    return req.url;
  }
}

useSemicolonDelimiter​

  • デフォルト false

Fastifyはfind-my-wayを使用しており、;文字（コード59）、たとえば/dev;foo=barでパスとクエリ文字列を分離することをサポートしています。この決定は以下に由来します。[delvedor/find-my-way#76](https://github.com/delvedor/find-my-way/issues/76)を参照してください。このオプションは、; で分割する必要がある場合の、後方互換性をサポートします。; での分割を有効にするには、useSemicolonDelimiter を true に設定してください。

const fastify = require('fastify')({
  useSemicolonDelimiter: true
})

fastify.get('/dev', async (request, reply) => {
  // An example request such as `/dev;foo=bar`
  // Will produce the following query params result `{ foo = 'bar' }`
  return request.query
})

インスタンス​

サーバーメソッド​

server​

fastify.server: Fastifyファクトリ関数によって返されるNode coreのserverオブジェクトです。

警告 不適切に使用すると、Fastifyの特定の機能が中断される可能性があります。リスナーのアタッチのみに使用することをお勧めします。

after​

現在のプラグインと、その内部に登録されたすべてのプラグインのロードが完了したときに呼び出されます。常にfastify.readyメソッドより前に実行されます。

fastify
  .register((instance, opts, done) => {
    console.log('Current plugin')
    done()
  })
  .after(err => {
    console.log('After current plugin')
  })
  .register((instance, opts, done) => {
    console.log('Next plugin')
    done()
  })
  .ready(err => {
    console.log('Everything has been loaded')
  })

関数なしでafter()が呼び出された場合、Promiseを返します。

fastify.register(async (instance, opts) => {
  console.log('Current plugin')
})

await fastify.after()
console.log('After current plugin')

fastify.register(async (instance, opts) => {
  console.log('Next plugin')
})

await fastify.ready()

console.log('Everything has been loaded')

ready​

すべてのプラグインがロードされたときに呼び出される関数です。問題が発生した場合、エラーパラメータを受け取ります。

fastify.ready(err => {
  if (err) throw err
})

引数なしで呼び出された場合、Promiseを返します。

fastify.ready().then(() => {
  console.log('successfully booted!')
}, (err) => {
  console.log('an error happened', err)
})

listen​

サーバーを起動し、内部的に.ready()イベントを待ちます。シグネチャは.listen([options][, callback])です。optionsオブジェクトとcallbackパラメータの両方が、Node.jsコアのoptionsオブジェクトを拡張します。したがって、すべてのコアオプションは、次のFastify固有の追加オプションで使用できます。

listenTextResolver​

サーバーが正常に起動した後にログに記録するテキストのオプションのリゾルバーを設定します。このオプションを使用すると、デフォルトのServer listening at [address]ログエントリをオーバーライドできます。

server.listen({ 
  port: 9080, 
  listenTextResolver: (address) => { return `Prometheus metrics server is listening at ${address}` } 
})

デフォルトでは、サーバーは特定のホストが提供されていない場合、localhostによって解決されたアドレスでリッスンします。利用可能なすべてのインターフェースでリッスンする場合は、アドレスに0.0.0.0を指定すると、すべてのIPv4アドレスでリッスンします。次の表は、localhostをターゲットにするときのhostの可能な値と、hostの値の結果の詳細を示しています。

ホストIPv4IPv6
::✅*✅
:: + ipv6Only🚫✅
0.0.0.0✅🚫
localhost✅✅
127.0.0.1✅🚫
::1🚫✅
* アドレスに `::` を使用すると、すべてのIPv6アドレスでリッスンし、OSによっては、[すべてのIPv4アドレス](https://node.dokyumento.jp/api/net.html#serverlistenport-host-backlog-callback)でもリッスンする場合があります。

すべてのインターフェースでリッスンする場合は注意してください。固有のセキュリティリスクが伴います。

デフォルトでは、port: 0（最初に利用可能なオープンポートを選択）およびhost: 'localhost'でリッスンします。

fastify.listen((err, address) => {
  if (err) {
    fastify.log.error(err)
    process.exit(1)
  }
})

アドレスの指定もサポートされています。

fastify.listen({ port: 3000, host: '127.0.0.1' }, (err, address) => {
  if (err) {
    fastify.log.error(err)
    process.exit(1)
  }
})

コールバックが提供されない場合、Promiseが返されます。

fastify.listen({ port: 3000 })
  .then((address) => console.log(`server listening on ${address}`))
  .catch(err => {
    console.log('Error starting server:', err)
    process.exit(1)
  })

Docker、およびその他のコンテナにデプロイする場合は、0.0.0.0でリッスンすることをお勧めします。これは、マップされたポートをデフォルトでlocalhostに公開しないためです。

fastify.listen({ port: 3000, host: '0.0.0.0' }, (err, address) => {
  if (err) {
    fastify.log.error(err)
    process.exit(1)
  }
})

portが省略されている（またはゼロに設定されている）場合、ランダムに利用可能なポートが自動的に選択されます（fastify.server.address().port経由で利用可能）。

listenのデフォルトオプションは次のとおりです。

fastify.listen({
  port: 0,
  host: 'localhost',
  exclusive: false,
  readableAll: false,
  writableAll: false,
  ipv6Only: false
}, (err) => {})

addresses​

このメソッドは、サーバーがリッスンしているアドレスの配列を返します。listen()が呼び出される前、またはclose()関数の後に呼び出すと、空の配列が返されます。

await fastify.listen({ port: 8080 })
const addresses = fastify.addresses()
// [
//   { port: 8080, family: 'IPv6', address: '::1' },
//   { port: 8080, family: 'IPv4', address: '127.0.0.1' }
// ]

配列には、fastify.server.address()も含まれていることに注意してください。

routing​

内部ルーターのlookupメソッドにアクセスし、リクエストを適切なハンドラーに一致させるためのメソッドです。

fastify.routing(req, res)

route​

サーバーにルートを追加するメソッドです。ショートカット関数もあります。こちらを確認してください。

hasRoute​

ルートが内部ルーターにすでに登録されているかどうかを確認するメソッドです。ペイロードとしてオブジェクトを期待します。urlとmethodは必須フィールドです。constraintsを指定することも可能です。ルートが登録されている場合はtrueを返し、登録されていない場合はfalseを返します。

const routeExists = fastify.hasRoute({
  url: '/',
  method: 'GET',
  constraints: { version: '1.0.0' } // optional
})

if (routeExists === false) {
  // add route
}

findRoute​

内部ルーターにすでに登録されているルートを取得するメソッドです。ペイロードとしてオブジェクトを期待します。urlとmethodは必須フィールドです。constraintsを指定することも可能です。メソッドはルートオブジェクトを返し、ルートが見つからない場合はnullを返します。

const route = fastify.findRoute({
  url: '/artists/:artistId',
  method: 'GET',
  constraints: { version: '1.0.0' } // optional
})

if (route !== null) {
  // perform some route checks
  console.log(route.params)   // `{artistId: ':artistId'}`
}

close​

fastify.close(callback): この関数を呼び出してサーバーインスタンスを閉じ、'onClose'フックを実行します。

closeを呼び出すと、サーバーは新しいすべての受信リクエストに対して503エラーで応答し、そのリクエストを破棄します。この動作を変更するには、return503OnClosingフラグを参照してください。

引数なしで呼び出された場合、Promiseを返します。

fastify.close().then(() => {
  console.log('successfully closed!')
}, (err) => {
  console.log('an error happened', err)
})

decorate*​

fastifyインスタンス、Reply、またはRequestをデコレートする必要がある場合に役立つ関数です。こちらを確認してください。

register​

Fastifyを使用すると、プラグインで機能を拡張できます。プラグインは、ルートのセット、サーバーデコレーターなど、何でもかまいません。こちらを確認してください。

addHook​

Fastifyのライフサイクルに特定のフックを追加する関数です。こちらを確認してください。

prefix​

ルートにプレフィックスとして付加される完全パスです。

例

fastify.register(function (instance, opts, done) {
  instance.get('/foo', function (request, reply) {
    // Will log "prefix: /v1"
    request.log.info('prefix: %s', instance.prefix)
    reply.send({ prefix: instance.prefix })
  })

  instance.register(function (instance, opts, done) {
    instance.get('/bar', function (request, reply) {
      // Will log "prefix: /v1/v2"
      request.log.info('prefix: %s', instance.prefix)
      reply.send({ prefix: instance.prefix })
    })

    done()
  }, { prefix: '/v2' })

  done()
}, { prefix: '/v1' })

pluginName​

現在のプラグインの名前です。ルートプラグインは'fastify'と呼ばれます。名前を定義する方法はいくつかあります（順に）。

  1. fastify-pluginを使用する場合、メタデータのnameが使用されます。
  2. エクスポートされたプラグインにSymbol.for('fastify.display-name')プロパティがある場合、そのプロパティの値が使用されます。例：pluginFn[Symbol.for('fastify.display-name')] = "Custom Name"
  3. プラグインをmodule.exportsする場合、ファイル名が使用されます。
  4. 通常の関数宣言を使用する場合、関数名が使用されます。

フォールバック：プラグインの最初の2行は、プラグイン名を表します。改行は--に置き換えられます。これにより、多数のプラグインを扱う場合に根本原因を特定するのに役立ちます。

警告 ネストされたプラグインを扱う場合、fastify-pluginの使用法によって名前が異なります。新しいスコープが作成されないため、コンテキストデータを付加する場所がないためです。その場合、プラグイン名はfastify -> plugin-A -> plugin-Bの形式で、関与するすべてのプラグインのブート順序を表します。

hasPlugin​

特定のプラグインが登録されているかどうかを確認するメソッドです。プラグインメタデータ名に依存します。プラグインが登録されている場合はtrueを返します。それ以外の場合はfalseを返します。

const fastify = require('fastify')()
fastify.register(require('@fastify/cookie'), {
  secret: 'my-secret',
  parseOptions: {}
})

fastify.ready(() => {
  fastify.hasPlugin('@fastify/cookie') // true
})

listeningOrigin​

サーバーがリッスンしている現在のオリジンです。たとえば、TCPソケットベースのサーバーはhttp://127.0.0.1:3000のようなベースアドレスを返し、Unixソケットサーバーはfastify.temp.sockのようなソケットパスを返します。

log​

ロガーインスタンスです。こちらを確認してください。

version​

インスタンスのFastifyバージョンです。プラグインのサポートに使用されます。プラグインでバージョンがどのように使用されるかについては、プラグインを参照してください。

inject​

偽のHTTPインジェクション（テスト用）については、こちらをご覧ください。

addHttpMethod​

Fastifyは、デフォルトでGET、HEAD、TRACE、DELETE、OPTIONS、PATCH、PUT、およびPOSTのHTTPメソッドをサポートしています。addHttpMethodメソッドを使用すると、Node.jsでサポートされている、標準ではないHTTPメソッドをサーバーに追加できます。

// Add a new HTTP method called 'MKCOL' that supports a request body
fastify.addHttpMethod('MKCOL', { hasBody: true,  })

// Add a new HTTP method called 'COPY' that does not support a request body
fastify.addHttpMethod('COPY')

addHttpMethodを呼び出した後、新しいHTTPメソッドのルートを定義するために、ルートショートカットメソッドを使用できます。

fastify.addHttpMethod('MKCOL', { hasBody: true })
fastify.mkcol('/', (req, reply) => {
  // Handle the 'MKCOL' request
})

addSchema​

fastify.addSchema(schemaObj) は、Fastify インスタンスに JSON スキーマを追加します。これにより、標準の $ref キーワードを使用するだけで、アプリケーションのどこでも再利用できます。

詳細については、バリデーションとシリアライゼーションのドキュメントを参照してください。

getSchemas​

fastify.getSchemas() は、.addSchema を介して追加されたすべてのスキーマのハッシュを返します。ハッシュのキーは、提供された JSON スキーマの $id です。

getSchema​

fastify.getSchema(id) は、.addSchema で追加され、一致する id を持つ JSON スキーマを返します。見つからない場合は undefined を返します。

setReplySerializer​

すべてのルートのリプライシリアライザーを設定します。これは、Reply.serializer(func) が設定されていない場合のデフォルトとして使用されます。ハンドラーは完全にカプセル化されているため、異なるプラグインが異なるエラーハンドラーを設定できます。注意: この関数パラメーターはステータス 2xx の場合にのみ呼び出されます。エラーについては、setErrorHandler を確認してください。

fastify.setReplySerializer(function (payload, statusCode){
  // serialize the payload with a sync function
  return `my serialized ${statusCode} content: ${payload}`
})

setValidatorCompiler​

すべてのルートのスキーマバリデーターコンパイラーを設定します。#schema-validatorを参照してください。

setSchemaErrorFormatter​

すべてのルートのスキーマエラーフォーマッターを設定します。#error-handlingを参照してください。

setSerializerCompiler​

すべてのルートのスキーマシリアライザーコンパイラーを設定します。#schema-serializerを参照してください。

注意 setReplySerializer が設定されている場合は優先されます。

validatorCompiler​

このプロパティは、スキーマバリデーターを取得するために使用できます。設定されていない場合、サーバーが起動するまでは null になり、その後、データ検証用の関数にコンパイルされた入力 schema を返す function ({ schema, method, url, httpPart }) というシグネチャを持つ関数になります。入力 schema は、.addSchema 関数で追加されたすべての共有スキーマにアクセスできます。

serializerCompiler​

このプロパティは、スキーマシリアライザーを取得するために使用できます。設定されていない場合、サーバーが起動するまでは null になり、その後、データ検証用の関数にコンパイルされた入力 schema を返す function ({ schema, method, url, httpPart }) というシグネチャを持つ関数になります。入力 schema は、.addSchema 関数で追加されたすべての共有スキーマにアクセスできます。

schemaErrorFormatter​

このプロパティは、validationCompiler がスキーマの検証に失敗したときに発生するエラーをフォーマットする関数を設定するために使用できます。#error-handlingを参照してください。

schemaController​

このプロパティは、完全に管理するために使用できます

  • bucket: アプリケーションのスキーマが格納される場所
  • compilersFactory: JSON スキーマをコンパイルする必要があるモジュール

スキーマが Fastify に未知の別のデータ構造に格納されている場合に役立ちます。

別のユースケースは、すべてのスキーマ処理を調整することです。これにより、Ajv v8 JTD またはスタンドアロン機能を使用できます。JTD やスタンドアロンモードを使用するには、@fastify/ajv-compiler ドキュメントを参照してください。

const fastify = Fastify({
  schemaController: {
    /**
     * This factory is called whenever `fastify.register()` is called.
     * It may receive as input the schemas of the parent context if some schemas have been added.
     * @param {object} parentSchemas these schemas will be returned by the
     * `getSchemas()` method function of the returned `bucket`.
     */
    bucket: function factory (parentSchemas) {
      return {
        add (inputSchema) {
          // This function must store the schema added by the user.
          // This function is invoked when `fastify.addSchema()` is called.
        },
        getSchema (schema$id) {
          // This function must return the raw schema requested by the `schema$id`.
          // This function is invoked when `fastify.getSchema(id)` is called.
          return aSchema
        },
        getSchemas () {
          // This function must return all the schemas referenced by the routes schemas' $ref
          // It must return a JSON where the property is the schema `$id` and the value is the raw JSON Schema.
          const allTheSchemaStored = {
            'schema$id1': schema1,
            'schema$id2': schema2
          }
          return allTheSchemaStored
        }
      }
    },

    /**
     * The compilers factory lets you fully control the validator and serializer
     * in the Fastify's lifecycle, providing the encapsulation to your compilers.
     */
    compilersFactory: {
      /**
       * This factory is called whenever a new validator instance is needed.
       * It may be called whenever `fastify.register()` is called only if new schemas have been added to the
       * encapsulation context.
       * It may receive as input the schemas of the parent context if some schemas have been added.
       * @param {object} externalSchemas these schemas will be returned by the
       * `bucket.getSchemas()`. Needed to resolve the external references $ref.
       * @param {object} ajvServerOption the server `ajv` options to build your compilers accordingly
       */
      buildValidator: function factory (externalSchemas, ajvServerOption) {
        // This factory function must return a schema validator compiler.
        // See [#schema-validator](./Validation-and-Serialization.md#schema-validator) for details.
        const yourAjvInstance = new Ajv(ajvServerOption.customOptions)
        return function validatorCompiler ({ schema, method, url, httpPart }) {
          return yourAjvInstance.compile(schema)
        }
      },

      /**
       * This factory is called whenever a new serializer instance is needed.
       * It may be called whenever `fastify.register()` is called only if new schemas have been added to the
       * encapsulation context.
       * It may receive as input the schemas of the parent context if some schemas have been added.
       * @param {object} externalSchemas these schemas will be returned by the
       * `bucket.getSchemas()`. Needed to resolve the external references $ref.
       * @param {object} serializerOptsServerOption the server `serializerOpts`
       * options to build your compilers accordingly
       */
      buildSerializer: function factory (externalSchemas, serializerOptsServerOption) {
        // This factory function must return a schema serializer compiler.
        // See [#schema-serializer](./Validation-and-Serialization.md#schema-serializer) for details.
        return function serializerCompiler ({ schema, method, url, httpStatus, contentType }) {
          return data => JSON.stringify(data)
        }
      }
    }
  }
});

setNotFoundHandler​

fastify.setNotFoundHandler(handler(request, reply)): 404 ハンドラーを設定します。この呼び出しはプレフィックスによってカプセル化されるため、異なるプラグインは、異なる prefix オプション が fastify.register() に渡された場合、異なる not found ハンドラーを設定できます。ハンドラーは通常のルートハンドラーとして扱われるため、リクエストは完全な Fastify ライフサイクル を通過します。async-await もサポートされています。

404 ハンドラーの preValidation および preHandler フックも登録できます。

注意 このメソッドを使用して登録された preValidation フックは、Fastify が認識しないルートに対して実行され、ルートハンドラーが手動で reply.callNotFound を呼び出した場合は 実行されません。その場合は、preHandler のみが実行されます。

fastify.setNotFoundHandler({
  preValidation: (req, reply, done) => {
    // your code
    done()
  },
  preHandler: (req, reply, done) => {
    // your code
    done()
  }
}, function (request, reply) {
    // Default not found handler with preValidation and preHandler hooks
})

fastify.register(function (instance, options, done) {
  instance.setNotFoundHandler(function (request, reply) {
    // Handle not found request without preValidation and preHandler hooks
    // to URLs that begin with '/v1'
  })
  done()
}, { prefix: '/v1' })

Fastify は、プラグインが登録される前に、起動時にデフォルトの 404 ハンドラーを追加するために setNotFoundHandler を呼び出します。たとえば、プラグインを使用してデフォルトの 404 ハンドラーの動作を拡張する場合は、登録されたこれらのプラグインのコンテキスト内で引数なしで setNotFoundHandler を呼び出すことができます fastify.setNotFoundHandler()。

注意 リクエストオブジェクトの一部の設定プロパティは、カスタムの not found ハンドラー内では未定義になります。例：request.routerPath、routerMethod、context.config。このメソッドの設計目標は、共通の not found ルートを呼び出せるようにすることです。ルートごとにカスタマイズされた 404 レスポンスを返すには、レスポンス自体でそれを行うことができます。

setErrorHandler​

fastify.setErrorHandler(handler(error, request, reply)): エラーが発生したときに呼び出される関数を設定します。ハンドラーは Fastify インスタンスにバインドされ、完全にカプセル化されているため、異なるプラグインが異なるエラーハンドラーを設定できます。async-await もサポートされています。

エラーの statusCode が 400 未満の場合、Fastify はエラーハンドラーを呼び出す前に自動的に 500 に設定します。

setErrorHandler は キャッチしません

  • レスポンスがすでにクライアントに送信されているため、onResponse フックでスローされたエラー。代わりに onSend フックを使用してください。
  • not found (404) エラー。代わりに setNotFoundHandler を使用してください。
fastify.setErrorHandler(function (error, request, reply) {
  // Log error
  this.log.error(error)
  // Send error response
  reply.status(409).send({ ok: false })
})

Fastify には、エラーハンドラーが設定されていない場合に呼び出されるデフォルトの関数が用意されています。これは fastify.errorHandler を使用してアクセスでき、statusCode に応じてエラーをログに記録します。

var statusCode = error.statusCode
if (statusCode >= 500) {
  log.error(error)
} else if (statusCode >= 400) {
  log.info(error)
} else {
  log.error(error)
}

setChildLoggerFactory​

fastify.setChildLoggerFactory(factory(logger, bindings, opts, rawReq)): 各リクエストのチャイルドロガーインスタンスを作成するときに呼び出される関数を設定します。これにより、チャイルドロガーのバインディングとロガーオプションの変更または追加、またはカスタムチャイルドロガーの実装の返却が可能になります。

チャイルドロガーのバインディングは、チャイルドロガーの作成時に Pino によって事前にシリアル化されるため、ログごとのバインディングよりもパフォーマンス上の利点があります。

最初のパラメーターは親ロガーインスタンスで、その後に、チャイルドロガーに渡す必要のあるデフォルトのバインディングとロガーオプション、最後に生の要求 (Fastify リクエストオブジェクトではありません) が続きます。この関数は、this が Fastify インスタンスであるとバインドされています。

例

const fastify = require('fastify')({
  childLoggerFactory: function (logger, bindings, opts, rawReq) {
    // Calculate additional bindings from the request if needed
    bindings.traceContext = rawReq.headers['x-cloud-trace-context']
    return logger.child(bindings, opts)
  }
})

ハンドラーは Fastify インスタンスにバインドされ、完全にカプセル化されているため、異なるプラグインが異なるロガーファクトリーを設定できます。

setGenReqId​

fastify.setGenReqId(function (rawReq)) 追加の Fastify インスタンスのリクエスト ID を設定するための同期関数。パラメーターとして *生の* 受信リクエストを受け取ります。指定された関数は、いかなる場合でもエラーをスローしてはなりません。

特に分散システムでは、異なるユースケースを処理するために異なる ID を生成するカスタムの方法を処理するために、デフォルトの ID 生成の動作をオーバーライドする必要がある場合があります。観測性または webhook プラグインなど。

例

const fastify = require('fastify')({
  genReqId: (req) => {
    return 'base'
  }
})

fastify.register((instance, opts, done) => {
  instance.setGenReqId((req) => {
    // custom request ID for `/webhooks`
    return 'webhooks-id'
  })
  done()
}, { prefix: '/webhooks' })

fastify.register((instance, opts, done) => {
  instance.setGenReqId((req) => {
    // custom request ID for `/observability`
    return 'observability-id'
  })
  done()
}, { prefix: '/observability' })

ハンドラーは Fastify インスタンスにバインドされ、完全にカプセル化されているため、異なるプラグインが異なるリクエスト ID を設定できます。

addConstraintStrategy​

カスタム制約戦略を追加する関数。新しい制約タイプを登録するには、値をハンドラーに一致させる方法と、リクエストから制約値を取得する方法を知っている新しい制約戦略を追加する必要があります。

fastify.addConstraintStrategy メソッドを使用してカスタム制約戦略を追加します。

const customResponseTypeStrategy = {
  // strategy name for referencing in the route handler `constraints` options
  name: 'accept',
  // storage factory for storing routes in the find-my-way route tree
  storage: function () {
    let handlers = {}
    return {
      get: (type) => { return handlers[type] || null },
      set: (type, store) => { handlers[type] = store }
    }
  },
  // function to get the value of the constraint from each incoming request
  deriveConstraint: (req, ctx) => {
    return req.headers['accept']
  },
  // optional flag marking if handlers without constraints can match requests that have a value for this constraint
  mustMatchWhenDerived: true
}

const router = Fastify();
router.addConstraintStrategy(customResponseTypeStrategy);

hasConstraintStrategy​

fastify.hasConstraintStrategy(strategyName) は、同じ名前のカスタム制約戦略がすでに存在するかどうかを確認します。

printRoutes​

fastify.printRoutes(): Fastify ルーターは、HTTP メソッドごとにルートのツリーを構築します。HTTP メソッドを指定せずに prettyPrint を呼び出すと、すべてのツリーが 1 つにマージされて出力されます。マージされたツリーは、内部ルーター構造を表していません。デバッグには使用しないでください。

ready 呼び出しの中または後に呼び出すことを忘れないでください。

fastify.get('/test', () => {})
fastify.get('/test/hello', () => {})
fastify.get('/testing', () => {})
fastify.get('/testing/:param', () => {})
fastify.put('/update', () => {})

fastify.ready(() => {
  console.log(fastify.printRoutes())
  // └── /
  //     ├── test (GET)
  //     │   ├── /hello (GET)
  //     │   └── ing (GET)
  //     │       └── /
  //     │           └── :param (GET)
  //     └── update (PUT)
})

内部ルータツリーを出力する場合は、method パラメーターを指定する必要があります。出力されたツリーは、内部ルーター構造を表します。デバッグに使用できます。

  console.log(fastify.printRoutes({ method: 'GET' }))
  // └── /
  //     └── test (GET)
  //         ├── /hello (GET)
  //         └── ing (GET)
  //             └── /
  //                 └── :param (GET)

  console.log(fastify.printRoutes({ method: 'PUT' }))
  // └── /
  //     └── update (PUT)

fastify.printRoutes({ commonPrefix: false }) は、圧縮されたツリーを表示します。これは、共通のプレフィックスを持つ多数のルートがある場合に役立つ場合があります。内部のルーター構造を表すものではありません。デバッグには使用しないでください。

  console.log(fastify.printRoutes({ commonPrefix: false }))
  // ├── /test (GET)
  // │   ├── /hello (GET)
  // │   └── ing (GET)
  // │       └── /:param (GET)
  // └── /update (PUT)

fastify.printRoutes({ includeMeta: (true | []) }) は、表示される各ルートの route.store オブジェクトのプロパティを表示します。これは、キーの array（例：['onRequest', Symbol('key')]）であるか、すべてのプロパティを表示する場合は true になります。ショートカットオプションとして、fastify.printRoutes({ includeHooks: true }) はすべての フック を含めます。

  fastify.get('/test', () => {})
  fastify.get('/test/hello', () => {})

  const onTimeout = () => {}

  fastify.addHook('onRequest', () => {})
  fastify.addHook('onTimeout', onTimeout)

  console.log(fastify.printRoutes({ includeHooks: true, includeMeta: ['errorHandler'] }))
  // └── /
  //     └── test (GET)
  //         • (onTimeout) ["onTimeout()"]
  //         • (onRequest) ["anonymous()"]
  //         • (errorHandler) "defaultErrorHandler()"
  //         test (HEAD)
  //         • (onTimeout) ["onTimeout()"]
  //         • (onRequest) ["anonymous()"]
  //         • (onSend) ["headRouteOnSendHandler()"]
  //         • (errorHandler) "defaultErrorHandler()"
  //         └── /hello (GET)
  //             • (onTimeout) ["onTimeout()"]
  //             • (onRequest) ["anonymous()"]
  //             • (errorHandler) "defaultErrorHandler()"
  //             /hello (HEAD)
  //             • (onTimeout) ["onTimeout()"]
  //             • (onRequest) ["anonymous()"]
  //             • (onSend) ["headRouteOnSendHandler()"]
  //             • (errorHandler) "defaultErrorHandler()"

  console.log(fastify.printRoutes({ includeHooks: true }))
  // └── /
  //     └── test (GET)
  //         • (onTimeout) ["onTimeout()"]
  //         • (onRequest) ["anonymous()"]
  //         test (HEAD)
  //         • (onTimeout) ["onTimeout()"]
  //         • (onRequest) ["anonymous()"]
  //         • (onSend) ["headRouteOnSendHandler()"]
  //         └── /hello (GET)
  //             • (onTimeout) ["onTimeout()"]
  //             • (onRequest) ["anonymous()"]
  //             /hello (HEAD)
  //             • (onTimeout) ["onTimeout()"]
  //             • (onRequest) ["anonymous()"]
  //             • (onSend) ["headRouteOnSendHandler()"]

printPlugins​

fastify.printPlugins(): avvio が使用する内部プラグインツリーの表現を出力します。require の順序の問題をデバッグするのに役立ちます。

ready 呼び出しの中または後に呼び出すことを忘れないでください。

fastify.register(async function foo (instance) {
  instance.register(async function bar () {})
})
fastify.register(async function baz () {})

fastify.ready(() => {
  console.error(fastify.printPlugins())
  // will output the following to stderr:
  // └── root
  //     ├── foo
  //     │   └── bar
  //     └── baz
})

addContentTypeParser​

fastify.addContentTypeParser(content-type, options, parser) は、指定されたコンテンツタイプ用のカスタムパーサーを渡すために使用されます。カスタムコンテンツタイプ（例：text/json, application/vnd.oasis.opendocument.text）のパーサーを追加するのに役立ちます。content-type は、文字列、文字列の配列、または RegExp にすることができます。

// The two arguments passed to getDefaultJsonParser are for ProtoType poisoning
// and Constructor Poisoning configuration respectively. The possible values are
// 'ignore', 'remove', 'error'. ignore  skips all validations and it is similar
// to calling JSON.parse() directly. See the
// [`secure-json-parse` documentation](https://github.com/fastify/secure-json-parse#api) for more information.

fastify.addContentTypeParser('text/json', { asString: true }, fastify.getDefaultJsonParser('ignore', 'ignore'))

hasContentTypeParser​

fastify.hasContentTypeParser(contentType) は、指定されたコンテンツタイプに対して現在のコンテキストにコンテンツタイプパーサーがあるかどうかを確認するために使用されます。

fastify.hasContentTypeParser('text/json')

fastify.hasContentTypeParser(/^.+\/json$/)

removeContentTypeParser​

fastify.removeContentTypeParser(contentType) は、現在のコンテキストでコンテンツタイプパーサーを削除するために使用されます。このメソッドを使用すると、たとえば、application/json と text/plain の両方の組み込みパーサーを削除できます。

fastify.removeContentTypeParser('application/json')

fastify.removeContentTypeParser(['application/json', 'text/plain'])

removeAllContentTypeParsers​

fastify.removeAllContentTypeParsers() メソッドを使用すると、現在のコンテキストにあるすべてのコンテンツタイプパーサーを削除できます。このメソッドの使用例として、キャッチオールコンテンツタイプパーサーの実装があります。fastify.addContentTypeParser() でこのパーサーを追加する前に、removeAllContentTypeParsers メソッドを呼び出すことができます。

さまざまなコンテンツタイプパーサーAPIの使用方法の詳細については、こちらを参照してください。

getDefaultJsonParser​

fastify.getDefaultJsonParser(onProtoPoisoning, onConstructorPoisoning) は2つの引数を取ります。最初の引数は ProtoType ポイズニングの設定、2番目の引数はコンストラクターポイズニングの設定です。詳細については、secure-json-parse ドキュメントを参照してください。

defaultTextParser​

fastify.defaultTextParser() は、コンテンツをプレーンテキストとして解析するために使用できます。

fastify.addContentTypeParser('text/json', { asString: true }, fastify.defaultTextParser)

errorHandler​

fastify.errorHandler は、Fastify のデフォルトのエラーハンドラーを使用してエラーを処理するために使用できます。

fastify.get('/', {
  errorHandler: (error, request, reply) => {
    if (error.code === 'SOMETHING_SPECIFIC') {
      reply.send({ custom: 'response' })
      return
    }

    fastify.errorHandler(error, request, response)
  }
}, handler)

childLoggerFactory​

fastify.childLoggerFactory は、Fastifyインスタンスのカスタムロガーファクトリ関数を返します。詳細については、childLoggerFactory 設定オプションを参照してください。

Symbol.asyncDispose​

fastify[Symbol.asyncDispose] は、Fastifyインスタンスが閉じられたときに呼び出される非同期関数を定義するために使用できるシンボルです。

これは、Fastifyインスタンスが閉じられたときにリソースが確実にクリーンアップされるようにするために、using TypeScriptキーワードと一緒に一般的に使用されます。

これは、関数内から戻った後にすべてのFastifyリソースを閉じる必要がある短寿命のプロセスまたはユニットテスト内で完全に組み合わされます。

test('Uses app and closes it afterwards', async () => {
  await using app = fastify();
  // do something with app.
})

上記の例では、テストが終了するとFastifyが自動的に閉じられます。

詳細については、ECMAScript Explicit Resource Management および TypeScript 5.2 で導入された using キーワード を参照してください。

initialConfig​

fastify.initialConfig: ユーザーが Fastify インスタンスに渡した初期オプションを登録する凍結された読み取り専用オブジェクトを公開します。

現在公開できるプロパティは

  • connectionTimeout
  • keepAliveTimeout
  • bodyLimit
  • caseSensitive
  • allowUnsafeRegex
  • http2
  • https（明示的に渡された場合は false/true または { allowHTTP1: true/false } を返します）
  • ignoreTrailingSlash
  • disableRequestLogging
  • maxParamLength
  • onProtoPoisoning
  • onConstructorPoisoning
  • pluginTimeout
  • requestIdHeader
  • requestIdLogLabel
  • http2SessionTimeout
  • useSemicolonDelimiter
const { readFileSync } = require('node:fs')
const Fastify = require('fastify')

const fastify = Fastify({
  https: {
    allowHTTP1: true,
    key: readFileSync('./fastify.key'),
    cert: readFileSync('./fastify.cert')
  },
  logger: { level: 'trace'},
  ignoreTrailingSlash: true,
  maxParamLength: 200,
  caseSensitive: true,
  trustProxy: '127.0.0.1,192.168.1.1/24',
})

console.log(fastify.initialConfig)
/*
will log :
{
  caseSensitive: true,
  https: { allowHTTP1: true },
  ignoreTrailingSlash: true,
  maxParamLength: 200
}
*/

fastify.register(async (instance, opts) => {
  instance.get('/', async (request, reply) => {
    return instance.initialConfig
    /*
    will return :
    {
      caseSensitive: true,
      https: { allowHTTP1: true },
      ignoreTrailingSlash: true,
      maxParamLength: 200
    }
    */
  })

  instance.get('/error', async (request, reply) => {
    // will throw an error because initialConfig is read-only
    // and can not be modified
    instance.initialConfig.https.allowHTTP1 = false

    return instance.initialConfig
  })
})

// Start listening.
fastify.listen({ port: 3000 }, (err) => {
  if (err) {
    fastify.log.error(err)
    process.exit(1)
  }
})