Merge pull request #2985 from SeedCompany/edgedb/exceptions

Author: CarsonF

src/common/exceptions/duplicate.exception.ts

@@ -1,3 +1,10 @@
+import { ArgumentsHost } from '@nestjs/common';
+import {
+  GqlContextType as ContextKey,
+  GqlExecutionContext,
+} from '@nestjs/graphql';
+import { lowerCase, upperFirst } from 'lodash';
+import type { ExclusivityViolationError } from '~/core/edgedb';
 import { InputException } from './input.exception';
 
 /**
@@ -11,4 +18,47 @@ export class DuplicateException extends InputException {
       previous,
     );
   }
+
+  static fromDB(exception: ExclusivityViolationError, context?: ArgumentsHost) {
+    let property = exception.property;
+    const message = `${upperFirst(
+      lowerCase(property),
+    )} already exists and needs to be unique`;
+
+    // Attempt to add path prefix automatically to the property name, based
+    // on given GQL input.
+    if (context && context.getType<ContextKey>() === 'graphql') {
+      let gqlArgs = GqlExecutionContext.create(context as any).getArgs();
+
+      // unwind single `input` argument, based on our own conventions
+      if (Object.keys(gqlArgs).length === 1 && 'input' in gqlArgs) {
+        gqlArgs = gqlArgs.input;
+      }
+
+      const flattened = flattenObject(gqlArgs);
+      // Guess the correct path based on property name.
+      // This kinda assumes the property name will be unique amongst all the input.
+      const guessedPath = Object.keys(flattened).find(
+        (path) => property === path || path.endsWith('.' + property),
+      );
+      property = guessedPath ?? property;
+    }
+
+    const ex = new DuplicateException(property, message, exception);
+    ex.stack = exception.stack;
+    return ex;
+  }
 }
+
+const flattenObject = (obj: object, prefix = '') => {
+  const result: Record<string, any> = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      const nestedObj = flattenObject(value, prefix + key + '.');
+      Object.assign(result, nestedObj);
+    } else {
+      result[prefix + key] = value;
+    }
+  }
+  return result;
+};

src/common/exceptions/exception.ts

@@ -29,8 +29,10 @@ export const hasPrevious = (e: Error): e is Error & { previous: Error } =>
 export function getPreviousList(ex: Error, includeSelf: boolean) {
   const previous: Error[] = includeSelf ? [ex] : [];
   let current = ex;
-  while (hasPrevious(current)) {
-    current = current.previous;
+  while (current.cause instanceof Error || hasPrevious(current)) {
+    current = hasPrevious(current)
+      ? current.previous
+      : (current.cause as Error);
     previous.push(current);
   }
   return previous;

src/components/authentication/authentication.edgedb.repository.ts

@@ -108,6 +108,9 @@ export class AuthenticationEdgeDBRepository
       ),
     }));
     const result = await this.db.run(query);
+    if (!result) {
+      return undefined;
+    }
     return {
       userId: result?.user?.id,
       roles: result?.user?.scopedRoles ?? [],

src/components/user/user.edgedb.repository.ts

@@ -1,12 +1,6 @@
 import { Injectable } from '@nestjs/common';
-import {
-  DuplicateException,
-  ID,
-  NotFoundException,
-  ServerException,
-  Session,
-} from '~/common';
-import { e, EdgeDB, isExclusivityViolation } from '~/core/edgedb';
+import { ID, NotFoundException, Session } from '~/common';
+import { e, EdgeDB } from '~/core/edgedb';
 import { CreatePerson, User, UserListInput } from './dto';
 import { UserRepository } from './user.repository';
 
@@ -83,29 +77,14 @@ export class UserEdgedbRepository extends UserRepository {
 
   async create(input: CreatePerson) {
     const query = e.insert(e.User, { ...input });
-    try {
-      const result = await this.edgedb.run(query);
-      return result.id;
-    } catch (e) {
-      if (isExclusivityViolation(e, 'email')) {
-        throw new DuplicateException(
-          'person.email',
-          'Email address is already in use',
-          e,
-        );
-      }
-      throw new ServerException('Failed to create user', e);
-    }
+    const result = await this.edgedb.run(query);
+    return result.id;
   }
 
   async delete(id: ID, _session: Session, _object: User): Promise<void> {
     const query = e.delete(e.User, () => ({
       filter_single: { id },
     }));
-    try {
-      await this.edgedb.run(query);
-    } catch (exception) {
-      throw new ServerException('Failed to delete', exception);
-    }
+    await this.edgedb.run(query);
   }
 }

src/core/edgedb/edgedb.service.ts

@@ -3,6 +3,7 @@ import { Injectable } from '@nestjs/common';
 import { $, Executor } from 'edgedb';
 import { retry, RetryOptions } from '~/common/retry';
 import { TypedEdgeQL } from './edgeql';
+import { ExclusivityViolationError } from './exclusivity-violation.error';
 import { InlineQueryCardinalityMap } from './generated-client/inline-queries';
 import { OptionsContext, OptionsFn } from './options.context';
 import { Client } from './reexports';
@@ -58,29 +59,39 @@ export class EdgeDB {
   ): Promise<R>;
 
   async run(query: any, args?: any) {
-    if (query instanceof TypedEdgeQL) {
-      const cardinality = InlineQueryCardinalityMap.get(query.query);
-      if (!cardinality) {
-        throw new Error(`Query was not found from inline query generation`);
+    try {
+      if (query instanceof TypedEdgeQL) {
+        const cardinality = InlineQueryCardinalityMap.get(query.query);
+        if (!cardinality) {
+          throw new Error(`Query was not found from inline query generation`);
+        }
+        const exeMethod = cardinalityToExecutorMethod[cardinality];
+
+        return await this.executor.current[exeMethod](query.query, args);
       }
-      const exeMethod = cardinalityToExecutorMethod[cardinality];
 
-      return await this.executor.current[exeMethod](query.query, args);
-    }
+      if (query.run) {
+        // eslint-disable-next-line @typescript-eslint/return-await
+        return await query.run(this.executor.current, args);
+      }
 
-    if (query.run) {
-      // eslint-disable-next-line @typescript-eslint/return-await
-      return await query.run(this.executor.current, args);
-    }
+      if (typeof query === 'function') {
+        // eslint-disable-next-line @typescript-eslint/return-await
+        return await query(this.executor.current, args);
+      }
 
-    if (typeof query === 'function') {
-      // eslint-disable-next-line @typescript-eslint/return-await
-      return await query(this.executor.current, args);
-    }
+      // For REPL, as this is untyped and assumes many/empty cardinality
+      if (typeof query === 'string') {
+        return await this.executor.current.query(query, args);
+      }
+    } 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, '');
 
-    // For REPL, as this is untyped and assumes many/empty cardinality
-    if (typeof query === 'string') {
-      return await this.executor.current.query(query, args);
+      if (ExclusivityViolationError.is(e)) {
+        throw ExclusivityViolationError.cast(e);
+      }
+      throw e;
     }
 
     throw new Error('Could not figure out how to run given query');

src/core/edgedb/error.util.ts

@@ -0,0 +1,59 @@
+import { ConstraintViolationError } from 'edgedb';
+
+export class ExclusivityViolationError extends ConstraintViolationError {
+  constructor(
+    readonly objectFQN: string,
+    readonly property: string,
+    message?: string,
+    options?: {
+      cause?: unknown;
+    },
+  ) {
+    super(message, options);
+  }
+
+  static is(e: unknown): e is ConstraintViolationError {
+    return (
+      e instanceof ConstraintViolationError &&
+      (e as any)._message.endsWith(' violates exclusivity constraint')
+    );
+  }
+
+  static cast(e: ConstraintViolationError) {
+    if (e instanceof ExclusivityViolationError) {
+      return e;
+    }
+
+    // @ts-expect-error it's a private field
+    const message: string = e._message;
+    // @ts-expect-error it's a private field
+    const query: string = e._query;
+    // @ts-expect-error it's a private field
+    const attrs: Map<number, Uint8Array> = e._attrs;
+
+    const detail = new TextDecoder('utf8').decode(attrs.get(2 /* details */));
+    const matches = detail.match(
+      /^property '(.+)' of object type '(.+)' violates exclusivity constraint$/,
+    );
+    if (!matches) {
+      throw new Error(
+        `Could not parse exclusivity violation error; details: ${detail}`,
+      );
+    }
+    const property = matches[1];
+    const fqn = matches[2];
+    const ex = new ExclusivityViolationError(fqn, property, message, {
+      cause: e.cause,
+    });
+
+    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/exclusivity-violation.error.ts

@@ -2,4 +2,4 @@ export * from './reexports';
 export { edgeql, EdgeQLArgsOf, EdgeQLReturnOf } from './edgeql';
 export * from './edgedb.service';
 export * from './withScope';
-export * from './error.util';
+export * from './exclusivity-violation.error';

src/core/edgedb/index.ts

@@ -1,6 +1,7 @@
 import { Injectable, OnModuleDestroy } from '@nestjs/common';
 import { AsyncLocalStorage } from 'async_hooks';
-import { Executor } from 'edgedb';
+import { EdgeDBError, Executor } from 'edgedb';
+import { getPreviousList } from '~/common';
 import { Client } from './reexports';
 
 @Injectable()
@@ -13,9 +14,31 @@ export class TransactionContext
   }
 
   async inTx<R>(fn: () => Promise<R>): Promise<R> {
-    return await this.client.transaction(async (tx) => {
-      return await this.run(tx, fn);
-    });
+    const errorMap = new WeakMap<Error, Error>();
+
+    try {
+      return await this.client.transaction(async (tx) => {
+        try {
+          return await this.run(tx, fn);
+        } catch (error) {
+          // If the error "wraps" an EdgeDB error, then
+          // throw that here and save the original.
+          // This allows EdgeDB 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(
+            (e) => e instanceof EdgeDBError,
+          );
+          if (maybeRetryableError) {
+            errorMap.set(maybeRetryableError, error);
+            throw maybeRetryableError;
+          }
+          throw error;
+        }
+      });
+    } catch (error) {
+      // Unwrap the original error if it was wrapped above.
+      throw errorMap.get(error) ?? error;
+    }
   }
 
   get current() {

src/core/edgedb/transaction.context.ts

@@ -32,7 +32,7 @@ export class ExceptionFilter implements GqlExceptionFilter {
 
     let normalized: ExceptionJson;
     try {
-      normalized = this.normalizer.normalize(exception);
+      normalized = this.normalizer.normalize(exception, args);
     } catch (e) {
       throw exception;
     }
@@ -62,6 +62,10 @@ export class ExceptionFilter implements GqlExceptionFilter {
       ? HttpStatus.FORBIDDEN
       : codes.has('Client')
       ? HttpStatus.BAD_REQUEST
+      : codes.has('Transient')
+      ? HttpStatus.SERVICE_UNAVAILABLE
+      : codes.has('NotImplemented')
+      ? HttpStatus.NOT_IMPLEMENTED
       : HttpStatus.INTERNAL_SERVER_ERROR;
 
     const out = {