Cast edgedb exclusivity violation to its own class

This makes instanceof checks easy, and provides the property and object FQN names

Author: CarsonF

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,36 @@ 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`);
-      }
-      const exeMethod = cardinalityToExecutorMethod[cardinality];
+    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);
-    }
+        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);
+      // 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) {
+      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

@@ -1,5 +1,4 @@
-import { ConstraintViolationError } from 'edgedb';
+import { ExclusivityViolationError } from './exclusivity-violation.error';
 
 export const isExclusivityViolation = (e: unknown, property: string) =>
-  e instanceof ConstraintViolationError &&
-  e.message === `${property} violates exclusivity constraint`;
+  e instanceof ExclusivityViolationError && e.property === property;

src/core/edgedb/exclusivity-violation.error.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/index.ts

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