Merge pull request #3181 from SeedCompany/exception-tracing

Author: CarsonF

src/common/exceptions/duplicate.exception.ts

@@ -29,8 +29,6 @@ export class DuplicateException extends InputException {
     ).find((path) => property === path || path.endsWith('.' + property));
     property = guessedPath ?? property;
 
-    const ex = new DuplicateException(property, message, exception);
-    ex.stack = exception.stack;
-    return ex;
+    return new DuplicateException(property, message, exception);
   }
 }

src/common/exceptions/exception.ts

@@ -3,36 +3,23 @@
  * Don't throw this, but rather a sub-class instead.
  */
 export abstract class Exception extends Error {
-  /**
-   * Basically just to group exceptions into client/server groups.
-   * This may be removed later.
-   */
-  abstract readonly status: number;
+  declare cause?: Error;
 
-  constructor(message: string, readonly previous?: Error) {
-    super(message);
+  constructor(message: string, cause?: Error) {
+    super(message, { cause });
     this.name = this.constructor.name;
   }
 }
 
-export class ServerException extends Exception {
-  readonly status: number = 500;
-}
-
-export class ClientException extends Exception {
-  readonly status: number = 400;
-}
+export class ServerException extends Exception {}
 
-export const hasPrevious = (e: Error): e is Error & { previous: Error } =>
-  'previous' in e && e.previous instanceof Error;
+export class ClientException extends Exception {}
 
-export function getPreviousList(ex: Error, includeSelf: boolean) {
+export function getCauseList(ex: Error, includeSelf = true): readonly Error[] {
   const previous: Error[] = includeSelf ? [ex] : [];
   let current = ex;
-  while (current.cause instanceof Error || hasPrevious(current)) {
-    current = hasPrevious(current)
-      ? current.previous
-      : (current.cause as Error);
+  while (current.cause instanceof Error) {
+    current = current.cause;
     previous.push(current);
   }
   return previous;

src/common/exceptions/unauthorized.exception.ts

@@ -1,7 +1,5 @@
-import { HttpStatus } from '@nestjs/common';
 import { lowerCase } from 'lodash';
 import pluralize from 'plur';
-import { Writable as Mutable } from 'type-fest';
 import { EnhancedResource } from '../resource.dto';
 import { InputException, InputExceptionArgs } from './input.exception';
 
@@ -67,7 +65,6 @@ export class UnauthorizedException extends InputException {
 
   constructor(...args: InputExceptionArgs) {
     super(...InputException.parseArgs(`Insufficient permission`, args));
-    (this as Mutable<this>).status = HttpStatus.FORBIDDEN;
   }
 
   static fromPrivileges(

src/core/database/transaction.ts

@@ -1,7 +1,7 @@
 import { Connection } from 'cypher-query-builder';
 import { Duration, DurationLike } from 'luxon';
 import { Transaction as NeoTransaction } from 'neo4j-driver';
-import { getPreviousList, ServerException } from '../../common';
+import { getCauseList, ServerException } from '../../common';
 import { ILogger } from '../logger';
 import { PatchedConnection } from './cypher.factory';
 import { isNeo4jError } from './errors';
@@ -120,9 +120,7 @@ Connection.prototype.runInTransaction = async function withTransaction<R>(
           // throw that here and save the original.
           // This allows neo4j to check if the error is retry-able.
           // If it is, then this error doesn't matter; otherwise we'll unwrap below.
-          const maybeRetryableError = getPreviousList(error, true).find(
-            isNeo4jError,
-          );
+          const maybeRetryableError = getCauseList(error).find(isNeo4jError);
           if (maybeRetryableError) {
             errorMap.set(maybeRetryableError, error);
             throw maybeRetryableError;

src/core/edgedb/edgedb.service.ts

@@ -1,10 +1,11 @@
 /* eslint-disable @typescript-eslint/unified-signatures */
 import { Injectable, Optional } from '@nestjs/common';
-import { $, Executor } from 'edgedb';
+import { $, ConstraintViolationError, EdgeDBError, Executor } from 'edgedb';
 import { QueryArgs } from 'edgedb/dist/ifaces';
 import { retry, RetryOptions } from '~/common/retry';
+import { jestSkipFileInExceptionSource } from '../exception';
 import { TypedEdgeQL } from './edgeql';
-import { ExclusivityViolationError } from './exclusivity-violation.error';
+import { enhanceConstraintError } from './errors';
 import { InlineQueryRuntimeMap } from './generated-client/inline-queries';
 import { ApplyOptions, OptionsContext } from './options.context';
 import { Client } from './reexports';
@@ -131,10 +132,22 @@ export class EdgeDB {
       }
     } catch (e) {
       // Ignore this call in stack trace. This puts the actual query as the first.
-      e.stack = e.stack!.replace(/^\s+at EdgeDB\.run.+\n/m, '');
+      e.stack = e.stack!.replace(/^\s+at(?: async)? EdgeDB\.run.+$\n/m, '');
+
+      // Don't present abstract repositories as the src block in jest reports
+      // for DB execution errors.
+      // There shouldn't be anything specific to there to be helpful.
+      // This is a bit of a broad assumption though, so only do for jest and
+      // keep the frame for actual use from users/devs.
+      if (e instanceof EdgeDBError) {
+        jestSkipFileInExceptionSource(
+          e,
+          /^\s+at .+src[/|\\]core[/|\\]edgedb[/|\\].+\.repository\..+$\n/gm,
+        );
+      }
 
-      if (ExclusivityViolationError.is(e)) {
-        throw ExclusivityViolationError.cast(e);
+      if (e instanceof ConstraintViolationError) {
+        throw enhanceConstraintError(e);
       }
       throw e;
     }

src/core/edgedb/errors/constraint-violation.error.ts

@@ -0,0 +1,36 @@
+import { ConstraintViolationError } from 'edgedb';
+import { LiteralUnion } from 'type-fest';
+import type { AllResourceDBNames } from '~/core/resources';
+import { ExclusivityViolationError } from './exclusivity-violation.error';
+
+declare module 'edgedb' {
+  interface ConstraintViolationError {
+    readonly objectFQN: AllResourceDBNames;
+    readonly property: string;
+    readonly constraint: LiteralUnion<'std::exclusive' | 'std::regexp', string>;
+  }
+}
+
+export const enhanceConstraintError = (e: ConstraintViolationError) => {
+  // @ts-expect-error it is a private field
+  const attrs: Map<number, Uint8Array> = e._attrs;
+
+  const detail = new TextDecoder('utf8').decode(attrs.get(2 /* details */));
+  const matches = detail.match(
+    /^violated constraint '(?<constraint>.+)' on property '(?<property>.+)' of object type '(?<fqn>.+)'$/,
+  );
+  if (!matches) {
+    throw new Error(`Could not parse constraint violation error`, { cause: e });
+  }
+  const { fqn, property, constraint } = matches.groups!;
+
+  if (constraint === 'std::exclusive') {
+    e = ExclusivityViolationError.cast(e);
+  }
+
+  return Object.assign(e, {
+    objectFQN: fqn,
+    property: property,
+    constraint: constraint,
+  });
+};

src/core/edgedb/errors/exclusivity-violation.error.ts

@@ -0,0 +1,25 @@
+import { ConstraintViolationError } from 'edgedb';
+
+export class ExclusivityViolationError extends ConstraintViolationError {
+  static cast(e: ConstraintViolationError) {
+    // @ts-expect-error it is a private field
+    const message: string = e._message;
+    // @ts-expect-error it is a private field
+    const query: string = e._query;
+    // @ts-expect-error it is a private field
+    const attrs: Map<number, Uint8Array> = e._attrs;
+
+    const ex = new ExclusivityViolationError(message);
+
+    ex.stack = e.stack!.replace(
+      /^ConstraintViolationError:/,
+      'ExclusivityViolationError:',
+    );
+    // @ts-expect-error it's a private field
+    ex._query = query;
+    // @ts-expect-error it's a private field
+    ex._attrs = attrs;
+
+    return ex;
+  }
+}

src/core/edgedb/errors/index.ts

@@ -0,0 +1,2 @@
+export * from './constraint-violation.error';
+export * from './exclusivity-violation.error';

src/core/edgedb/exclusivity-violation.error.ts

@@ -4,7 +4,7 @@ export * from './options';
 export type { OptionsFn } from './options.context';
 export * from './edgedb.service';
 export * from './withScope';
-export * from './exclusivity-violation.error';
+export * from './errors/exclusivity-violation.error';
 export * from './common.repository';
 export * from './dto.repository';
 export * from './query-util/disable-access-policies.option';