Automatically convert exclusivity violations to duplicate exceptions on the way out

There's only a little bit of magic here
to convert the EdgeDB property name to the "field path".
We look at the gql input args to try to determine this.

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/core/exception/exception.filter.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;
     }

src/core/exception/exception.normalizer.ts

@@ -1,19 +1,21 @@
 import { ApolloServerErrorCode as ApolloCode } from '@apollo/server/errors';
-import { Inject, Injectable } from '@nestjs/common';
+import { ArgumentsHost, Inject, Injectable } from '@nestjs/common';
 // eslint-disable-next-line no-restricted-imports
 import * as Nest from '@nestjs/common';
 import { isNotFalsy, setHas, setOf, simpleSwitch } from '@seedcompany/common';
 import { GraphQLError } from 'graphql';
 import { uniq } from 'lodash';
 import {
   AbstractClassType,
+  DuplicateException,
   Exception,
   getParentTypes,
   getPreviousList,
   JsonSet,
 } from '~/common';
 import type { ConfigService } from '~/core';
 import * as Neo from '../database/errors';
+import { ExclusivityViolationError } from '../edgedb/exclusivity-violation.error';
 import { isSrcFrame } from './is-src-frame';
 import { normalizeFramePath } from './normalize-frame-path';
 
@@ -29,14 +31,14 @@ export interface ExceptionJson {
 export class ExceptionNormalizer {
   constructor(@Inject('CONFIG') private readonly config?: ConfigService) {}
 
-  normalize(ex: Error): ExceptionJson {
+  normalize(ex: Error, context?: ArgumentsHost): ExceptionJson {
     const {
       message = ex.message,
       stack = ex.stack,
       code: _,
       codes,
       ...extensions
-    } = this.gatherExtraInfo(ex);
+    } = this.gatherExtraInfo(ex, context);
     return {
       message,
       code: codes[0],
@@ -52,7 +54,10 @@ export class ExceptionNormalizer {
     };
   }
 
-  private gatherExtraInfo(ex: Error): Record<string, any> {
+  private gatherExtraInfo(
+    ex: Error,
+    context?: ArgumentsHost,
+  ): Record<string, any> {
     if (ex instanceof Nest.HttpException) {
       return this.httpException(ex);
     }
@@ -87,10 +92,16 @@ export class ExceptionNormalizer {
       };
     }
 
+    if (ex instanceof ExclusivityViolationError) {
+      ex = DuplicateException.fromDB(ex, context);
+    }
+
     if (ex instanceof Exception) {
       const { name, message, stack, previous, ...rest } = ex;
       return {
+        message,
         codes: this.errorToCodes(ex),
+        stack,
         ...rest,
       };
     }