29118934447

Committed 10 Jul 2026 07:42PM UTC coverage: 50.952% (-28.4%) from 79.376%

Build # 29118934447

Build Type

Pull #1043

github

Committed by

web-flow

Commit Message

Merge 8d0e08428 into b6b815fbd

Pull Request Pull Request #1043: feat: add queue management handlers

Coverage Stats

3545 of 7463 branches covered (47.5%)

Branch coverage included in aggregate %.

240 of 300 new or added lines in 10 files covered. (80.0%)

3797 existing lines in 163 files now uncovered.

6759 of 12760 relevant lines covered (52.97%)

62.74 hits per line

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

77.78

/src/http/error-handler.ts

import { FastifyError } from '@fastify/error'
import {
  ErrorCode,
  getErrorCode,
  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',
          })
        )
      }

      const errorCode = getErrorCode(err)
      const responseErrorCode = (
        errorCode === ErrorCode.UnknownError ? ErrorCode.InternalError : errorCode
      ) as ErrorCode
      const responseStatusCode = err.statusCode || 500

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

supabase / storage / 29118934447

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