Fix custom errors thrown as 500 (#6238)

We call convertExceptionToGraphQLError in the exception handler for http
exceptions but we don't take into account those that already are
graphqlErrors and because of that the logic of convertExceptionToGraphql
is to fallback to a 500.
Now if the exception is a BaseGraphqlError (custom graphql error we
throw in the code), we throw them directly.

BEFORE
<img width="957" alt="Screenshot 2024-07-12 at 15 33 03"
src="https://github.com/user-attachments/assets/22ddae13-4996-4ad3-8f86-dd17c2922ca8">


AFTER
<img width="923" alt="Screenshot 2024-07-12 at 15 32 01"
src="https://github.com/user-attachments/assets/d3d6db93-6d28-495c-a4b4-ba4e47d45abd">

---------

Co-authored-by: Charles Bochet <charles@twenty.com>

packages/twenty-server/src/engine/core-modules/graphql/engine-graphql.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+
+import { useGraphQLErrorHandlerHook } from 'src/engine/core-modules/graphql/hooks/use-graphql-error-handler.hook';
+import { ExceptionHandlerModule } from 'src/engine/integrations/exception-handler/exception-handler.module';
+
+@Module({
+  imports: [ExceptionHandlerModule],
+  exports: [useGraphQLErrorHandlerHook],
+  providers: [],
+})
+export class EngineGraphQLModule {}

packages/twenty-server/src/engine/core-modules/graphql/hooks/use-graphql-error-handler.hook.ts

@@ -0,0 +1,133 @@
+import {
+  OnExecuteDoneHookResultOnNextHook,
+  Plugin,
+  getDocumentString,
+  handleStreamOrSingleExecutionResult,
+} from '@envelop/core';
+import { GraphQLError, Kind, OperationDefinitionNode, print } from 'graphql';
+
+import { GraphQLContext } from 'src/engine/api/graphql/graphql-config/interfaces/graphql-context.interface';
+
+import { generateGraphQLErrorFromError } from 'src/engine/core-modules/graphql/utils/generate-graphql-error-from-error.util';
+import { BaseGraphQLError } from 'src/engine/core-modules/graphql/utils/graphql-errors.util';
+import { shouldCaptureException } from 'src/engine/core-modules/graphql/utils/should-capture-exception.util';
+import { ExceptionHandlerService } from 'src/engine/integrations/exception-handler/exception-handler.service';
+
+type GraphQLErrorHandlerHookOptions = {
+  /**
+   * The exception handler service to use.
+   */
+  exceptionHandlerService: ExceptionHandlerService;
+  /**
+   * The key of the event id in the error's extension. `null` to disable.
+   * @default exceptionEventId
+   */
+  eventIdKey?: string | null;
+};
+
+export const useGraphQLErrorHandlerHook = <
+  PluginContext extends GraphQLContext,
+>(
+  options: GraphQLErrorHandlerHookOptions,
+): Plugin<PluginContext> => {
+  const eventIdKey = options.eventIdKey === null ? null : 'exceptionEventId';
+
+  function addEventId(
+    err: GraphQLError,
+    eventId: string | undefined | null,
+  ): GraphQLError {
+    if (eventIdKey !== null && eventId) {
+      err.extensions[eventIdKey] = eventId;
+    }
+
+    return err;
+  }
+
+  return {
+    async onExecute({ args }) {
+      const exceptionHandlerService = options.exceptionHandlerService;
+      const rootOperation = args.document.definitions.find(
+        (o) => o.kind === Kind.OPERATION_DEFINITION,
+      ) as OperationDefinitionNode;
+      const operationType = rootOperation.operation;
+      const user = args.contextValue.req.user;
+      const document = getDocumentString(args.document, print);
+      const opName =
+        args.operationName ||
+        rootOperation.name?.value ||
+        'Anonymous Operation';
+
+      return {
+        onExecuteDone(payload) {
+          const handleResult: OnExecuteDoneHookResultOnNextHook<object> = ({
+            result,
+            setResult,
+          }) => {
+            if (result.errors && result.errors.length > 0) {
+              const errorsToCapture = result.errors.reduce<BaseGraphQLError[]>(
+                (acc, error) => {
+                  if (!(error instanceof BaseGraphQLError)) {
+                    error = generateGraphQLErrorFromError(error);
+                  }
+
+                  if (shouldCaptureException(error)) {
+                    acc.push(error);
+                  }
+
+                  return acc;
+                },
+                [],
+              );
+
+              if (errorsToCapture.length > 0) {
+                const eventIds = exceptionHandlerService.captureExceptions(
+                  errorsToCapture,
+                  {
+                    operation: {
+                      name: opName,
+                      type: operationType,
+                    },
+                    document,
+                    user,
+                  },
+                );
+
+                errorsToCapture.map((err, i) => addEventId(err, eventIds?.[i]));
+              }
+
+              const nonCapturedErrors = result.errors.filter(
+                (error) => !errorsToCapture.includes(error),
+              );
+
+              setResult({
+                ...result,
+                errors: [...nonCapturedErrors, ...errorsToCapture],
+              });
+            }
+          };
+
+          return handleStreamOrSingleExecutionResult(payload, handleResult);
+        },
+      };
+    },
+    onValidate: ({ context, validateFn, params: { documentAST, schema } }) => {
+      const errors = validateFn(schema, documentAST);
+
+      if (Array.isArray(errors) && errors.length > 0) {
+        const headers = context.req.headers;
+        const currentSchemaVersion = context.req.cacheVersion;
+
+        const requestSchemaVersion = headers['x-schema-version'];
+
+        if (
+          requestSchemaVersion &&
+          requestSchemaVersion !== currentSchemaVersion
+        ) {
+          throw new GraphQLError(
+            `Schema version mismatch, please refresh the page.`,
+          );
+        }
+      }
+    },
+  };
+};

packages/twenty-server/src/engine/core-modules/graphql/utils/generate-graphql-error-from-error.util.ts

@@ -0,0 +1,18 @@
+import {
+  BaseGraphQLError,
+  ErrorCode,
+} from 'src/engine/core-modules/graphql/utils/graphql-errors.util';
+
+export const generateGraphQLErrorFromError = (error: Error) => {
+  const graphqlError = new BaseGraphQLError(
+    error.name,
+    ErrorCode.INTERNAL_SERVER_ERROR,
+  );
+
+  if (process.env.NODE_ENV === 'development') {
+    graphqlError.stack = error.stack;
+    graphqlError.extensions['response'] = error.message;
+  }
+
+  return error;
+};

packages/twenty-server/src/engine/core-modules/graphql/utils/graphql-errors.util.ts

@@ -0,0 +1,193 @@
+import {
+  ASTNode,
+  GraphQLError,
+  GraphQLFormattedError,
+  Source,
+  SourceLocation,
+} from 'graphql';
+
+declare module 'graphql' {
+  export interface GraphQLErrorExtensions {
+    exception?: {
+      code?: string;
+      stacktrace?: ReadonlyArray<string>;
+    };
+  }
+}
+
+export enum ErrorCode {
+  GRAPHQL_PARSE_FAILED = 'GRAPHQL_PARSE_FAILED',
+  GRAPHQL_VALIDATION_FAILED = 'GRAPHQL_VALIDATION_FAILED',
+  UNAUTHENTICATED = 'UNAUTHENTICATED',
+  FORBIDDEN = 'FORBIDDEN',
+  PERSISTED_QUERY_NOT_FOUND = 'PERSISTED_QUERY_NOT_FOUND',
+  PERSISTED_QUERY_NOT_SUPPORTED = 'PERSISTED_QUERY_NOT_SUPPORTED',
+  BAD_USER_INPUT = 'BAD_USER_INPUT',
+  NOT_FOUND = 'NOT_FOUND',
+  METHOD_NOT_ALLOWED = 'METHOD_NOT_ALLOWED',
+  CONFLICT = 'CONFLICT',
+  TIMEOUT = 'TIMEOUT',
+  INTERNAL_SERVER_ERROR = 'INTERNAL_SERVER_ERROR',
+}
+
+export class BaseGraphQLError extends GraphQLError {
+  public extensions: Record<string, any>;
+  override readonly name!: string;
+  readonly locations: ReadonlyArray<SourceLocation> | undefined;
+  readonly path: ReadonlyArray<string | number> | undefined;
+  readonly source: Source | undefined;
+  readonly positions: ReadonlyArray<number> | undefined;
+  readonly nodes: ReadonlyArray<ASTNode> | undefined;
+  public originalError: Error | undefined;
+
+  [key: string]: any;
+
+  constructor(
+    message: string,
+    code?: string,
+    extensions?: Record<string, any>,
+  ) {
+    super(message);
+
+    // if no name provided, use the default. defineProperty ensures that it stays non-enumerable
+    if (!this.name) {
+      Object.defineProperty(this, 'name', { value: 'ApolloError' });
+    }
+
+    if (extensions?.extensions) {
+      throw Error(
+        'Pass extensions directly as the third argument of the ApolloError constructor: `new ' +
+          'ApolloError(message, code, {myExt: value})`, not `new ApolloError(message, code, ' +
+          '{extensions: {myExt: value}})`',
+      );
+    }
+
+    this.extensions = { ...extensions, code };
+  }
+
+  toJSON(): GraphQLFormattedError {
+    return toGraphQLError(this).toJSON();
+  }
+
+  override toString(): string {
+    return toGraphQLError(this).toString();
+  }
+
+  get [Symbol.toStringTag](): string {
+    return this.name;
+  }
+}
+
+function toGraphQLError(error: BaseGraphQLError): GraphQLError {
+  return new GraphQLError(error.message, {
+    nodes: error.nodes,
+    source: error.source,
+    positions: error.positions,
+    path: error.path,
+    originalError: error.originalError,
+    extensions: error.extensions,
+  });
+}
+
+export class SyntaxError extends BaseGraphQLError {
+  constructor(message: string) {
+    super(message, ErrorCode.GRAPHQL_PARSE_FAILED);
+
+    Object.defineProperty(this, 'name', { value: 'SyntaxError' });
+  }
+}
+
+export class ValidationError extends BaseGraphQLError {
+  constructor(message: string) {
+    super(message, ErrorCode.GRAPHQL_VALIDATION_FAILED);
+
+    Object.defineProperty(this, 'name', { value: 'ValidationError' });
+  }
+}
+
+export class AuthenticationError extends BaseGraphQLError {
+  constructor(message: string) {
+    super(message, ErrorCode.UNAUTHENTICATED);
+
+    Object.defineProperty(this, 'name', { value: 'AuthenticationError' });
+  }
+}
+
+export class ForbiddenError extends BaseGraphQLError {
+  constructor(message: string) {
+    super(message, ErrorCode.FORBIDDEN);
+
+    Object.defineProperty(this, 'name', { value: 'ForbiddenError' });
+  }
+}
+
+export class PersistedQueryNotFoundError extends BaseGraphQLError {
+  constructor() {
+    super('PersistedQueryNotFound', ErrorCode.PERSISTED_QUERY_NOT_FOUND);
+
+    Object.defineProperty(this, 'name', {
+      value: 'PersistedQueryNotFoundError',
+    });
+  }
+}
+
+export class PersistedQueryNotSupportedError extends BaseGraphQLError {
+  constructor() {
+    super(
+      'PersistedQueryNotSupported',
+      ErrorCode.PERSISTED_QUERY_NOT_SUPPORTED,
+    );
+
+    Object.defineProperty(this, 'name', {
+      value: 'PersistedQueryNotSupportedError',
+    });
+  }
+}
+
+export class UserInputError extends BaseGraphQLError {
+  constructor(message: string) {
+    super(message, ErrorCode.BAD_USER_INPUT);
+
+    Object.defineProperty(this, 'name', { value: 'UserInputError' });
+  }
+}
+
+export class NotFoundError extends BaseGraphQLError {
+  constructor(message: string) {
+    super(message, ErrorCode.NOT_FOUND);
+
+    Object.defineProperty(this, 'name', { value: 'NotFoundError' });
+  }
+}
+
+export class MethodNotAllowedError extends BaseGraphQLError {
+  constructor(message: string) {
+    super(message, ErrorCode.METHOD_NOT_ALLOWED);
+
+    Object.defineProperty(this, 'name', { value: 'MethodNotAllowedError' });
+  }
+}
+
+export class ConflictError extends BaseGraphQLError {
+  constructor(message: string) {
+    super(message, ErrorCode.CONFLICT);
+
+    Object.defineProperty(this, 'name', { value: 'ConflictError' });
+  }
+}
+
+export class TimeoutError extends BaseGraphQLError {
+  constructor(message: string) {
+    super(message, ErrorCode.TIMEOUT);
+
+    Object.defineProperty(this, 'name', { value: 'TimeoutError' });
+  }
+}
+
+export class InternalServerError extends BaseGraphQLError {
+  constructor(message: string) {
+    super(message, ErrorCode.INTERNAL_SERVER_ERROR);
+
+    Object.defineProperty(this, 'name', { value: 'InternalServerError' });
+  }
+}

packages/twenty-server/src/engine/core-modules/graphql/utils/should-capture-exception.util.ts

@@ -0,0 +1,26 @@
+import {
+  BaseGraphQLError,
+  ErrorCode,
+} from 'src/engine/core-modules/graphql/utils/graphql-errors.util';
+
+export const graphQLErrorCodesToFilter = [
+  ErrorCode.GRAPHQL_VALIDATION_FAILED,
+  ErrorCode.UNAUTHENTICATED,
+  ErrorCode.FORBIDDEN,
+  ErrorCode.NOT_FOUND,
+  ErrorCode.METHOD_NOT_ALLOWED,
+  ErrorCode.TIMEOUT,
+  ErrorCode.CONFLICT,
+  ErrorCode.BAD_USER_INPUT,
+];
+
+export const shouldCaptureException = (exception: Error): boolean => {
+  if (
+    exception instanceof BaseGraphQLError &&
+    graphQLErrorCodesToFilter.includes(exception?.extensions?.code)
+  ) {
+    return true;
+  }
+
+  return false;
+};

packages/twenty-server/src/engine/core-modules/postgres-credentials/postgres-credentials.service.ts

@@ -1,5 +1,5 @@
-import { InjectRepository } from '@nestjs/typeorm';
 import { BadRequestException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
 
 import { randomBytes } from 'crypto';
 
@@ -9,10 +9,10 @@ import {
   decryptText,
   encryptText,
 } from 'src/engine/core-modules/auth/auth.util';
-import { EnvironmentService } from 'src/engine/integrations/environment/environment.service';
-import { PostgresCredentials } from 'src/engine/core-modules/postgres-credentials/postgres-credentials.entity';
-import { NotFoundError } from 'src/engine/utils/graphql-errors.util';
+import { NotFoundError } from 'src/engine/core-modules/graphql/utils/graphql-errors.util';
 import { PostgresCredentialsDTO } from 'src/engine/core-modules/postgres-credentials/dtos/postgres-credentials.dto';
+import { PostgresCredentials } from 'src/engine/core-modules/postgres-credentials/postgres-credentials.entity';
+import { EnvironmentService } from 'src/engine/integrations/environment/environment.service';
 
 export class PostgresCredentialsService {
   constructor(