25825851260

Committed 13 May 2026 08:54PM UTC coverage: 75.097% (+0.05%) from 75.048%

Build # 25825851260

Build Type

push

github

Committed by

web-flow

Commit Message

fix: correctly categorize errors related to saturated project databases (#1106)

* fix: correctly categorize errors related to saturated project databases

* unify slowdown error handeling between standard api and S3

Coverage Stats

4042 of 5947 branches covered (67.97%)

Branch coverage included in aggregate %.

4 of 4 new or added lines in 3 files covered. (100.0%)

3 existing lines in 3 files now uncovered.

8165 of 10308 relevant lines covered (79.21%)

413.6 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

79.59

/src/http/error-handler.ts

import { FastifyError } from '@fastify/error'
import { ErrorCode, isRenderableError, StorageBackendError, StorageError } from '@internal/errors'
import { isDatabaseSlowDownError } from '@internal/errors/database-error'
import { FastifyInstance } from 'fastify'

/**
 * The global error handler for all the uncaught exceptions within a request.
 * We try our best to display meaningful information to our users
 * and log any error that occurs
 * @param app
 * @param options
 */
export const setErrorHandler = (
  app: FastifyInstance,
  options?: {
    respectStatusCode?: boolean
    formatter?: (error: StorageError) => Record<string, unknown>
  }
) => {
  app.setErrorHandler<Error>(function (error, request, reply) {
    const formatter = options?.formatter || ((e) => e)
    // We assign the error received.
    // it will be logged in the request log plugin
    request.executionError = error

    // database error
    if (isDatabaseSlowDownError(error)) {
      return reply.status(429).send(
        formatter({
          statusCode: `429`,
          error: 'too_many_connections',
          code: ErrorCode.SlowDown,
          message: 'Too many connections issued to the database',
        })
      )
    }

    if (isRenderableError(error)) {
      const renderableError = error.render()
      const statusCode = options?.respectStatusCode
        ? parseInt(renderableError.statusCode, 10)
        : error.userStatusCode
          ? error.userStatusCode
          : renderableError.statusCode === '500'
            ? 500
            : 400

      if (
        renderableError.code === ErrorCode.AbortedTerminate ||
        (error instanceof StorageBackendError && error.shouldCloseConnection())
      ) {
        reply.header('Connection', 'close')

        reply.raw.once('finish', () => {
          setTimeout(() => {
            if (!request.raw.closed) {
              request.raw.destroy()
            }
          }, 3000)
        })
      }

      return reply.status(statusCode).send(
        formatter({
          ...renderableError,
          error: error.error || renderableError.code,
        })
      )
    }

    // Fastify errors
    if ('statusCode' in error) {
      const err = error as FastifyError

      if (err.code === 'FST_ERR_CTP_INVALID_MEDIA_TYPE') {
        return reply.status(400).send(
          formatter({
            statusCode: '415',
            code: ErrorCode.InvalidMimeType,
            error: 'invalid_mime_type',
            message: 'Invalid Content-Type header',
          })
        )
      }

      return reply.status(err.statusCode || 500).send(
        formatter({
          statusCode: `${err.statusCode}`,
          error: err.name,
          code: ErrorCode.InternalError,
          message: err.message,
        })
      )
    }

    return reply.status(500).send(
      formatter({
        statusCode: '500',
        error: 'Internal',
        message: 'Internal Server Error',
        code: ErrorCode.InternalError,
      })
    )
  })
}

1	import { FastifyError } from '@fastify/error'
2	import { ErrorCode, isRenderableError, StorageBackendError, StorageError } from '@internal/errors'
3	import { isDatabaseSlowDownError } from '@internal/errors/database-error'
4	import { FastifyInstance } from 'fastify'
5
6	/**
7	* The global error handler for all the uncaught exceptions within a request.
8	* We try our best to display meaningful information to our users
9	* and log any error that occurs
10	* @param app
11	* @param options
12	*/
13	export const setErrorHandler = (	28✔
14	app: FastifyInstance,
15	options?: {
16	respectStatusCode?: boolean
17	formatter?: (error: StorageError) => Record<string, unknown>
18	}
19	) => {
20	app.setErrorHandler<Error>(function (error, request, reply) {	830✔
21	const formatter = options?.formatter \|\| ((e) => e)	249✔
22	// We assign the error received.
23	// it will be logged in the request log plugin
24	request.executionError = error	249✔
25
26	// database error
27	if (isDatabaseSlowDownError(error)) {	249!
UNCOV 28	return reply.status(429).send(	×
29	formatter({
30	statusCode: `429`,
31	error: 'too_many_connections',
32	code: ErrorCode.SlowDown,
33	message: 'Too many connections issued to the database',
34	})
35	)
36	}
37
38	if (isRenderableError(error)) {	249✔
39	const renderableError = error.render()	187✔
40	const statusCode = options?.respectStatusCode	187✔
41	? parseInt(renderableError.statusCode, 10)
42	: error.userStatusCode	160!
43	? error.userStatusCode
44	: renderableError.statusCode === '500'	×
45	? 500
46	: 400
47
48	if (	187✔
49	renderableError.code === ErrorCode.AbortedTerminate \|\|	561✔
50	(error instanceof StorageBackendError && error.shouldCloseConnection())
51	) {
52	reply.header('Connection', 'close')	1✔
53
54	reply.raw.once('finish', () => {	1✔
55	setTimeout(() => {	1✔
56	if (!request.raw.closed) {	×
57	request.raw.destroy()	×
58	}
59	}, 3000)
60	})
61	}
62
63	return reply.status(statusCode).send(	187✔
64	formatter({
65	...renderableError,
66	error: error.error \|\| renderableError.code,	219✔
67	})
68	)
69	}
70
71	// Fastify errors
72	if ('statusCode' in error) {	62✔
73	const err = error as FastifyError	58✔
74
75	if (err.code === 'FST_ERR_CTP_INVALID_MEDIA_TYPE') {	58✔
76	return reply.status(400).send(	3✔
77	formatter({
78	statusCode: '415',
79	code: ErrorCode.InvalidMimeType,
80	error: 'invalid_mime_type',
81	message: 'Invalid Content-Type header',
82	})
83	)
84	}
85
86	return reply.status(err.statusCode \|\| 500).send(	55!
87	formatter({
88	statusCode: `${err.statusCode}`,
89	error: err.name,
90	code: ErrorCode.InternalError,
91	message: err.message,
92	})
93	)
94	}
95
96	return reply.status(500).send(	4✔
97	formatter({
98	statusCode: '500',
99	error: 'Internal',
100	message: 'Internal Server Error',
101	code: ErrorCode.InternalError,
102	})
103	)
104	})
105	}

supabase / storage / 25825851260

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous