pqb 0.3.7 → 0.3.9

package/src/errors.ts

@@ -1,5 +1,49 @@
+import { DatabaseError } from 'pg';
+
 export class PormError extends Error {}
 
+export class QueryError extends DatabaseError {
+  message!: string;
+  code: string | undefined;
+  detail: string | undefined;
+  severity: string | undefined;
+  hint: string | undefined;
+  position: string | undefined;
+  internalPosition: string | undefined;
+  internalQuery: string | undefined;
+  where: string | undefined;
+  schema: string | undefined;
+  table: string | undefined;
+  column: string | undefined;
+  dataType: string | undefined;
+  constraint: string | undefined;
+  file: string | undefined;
+  line: string | undefined;
+  routine: string | undefined;
+
+  get isUnique() {
+    return this.code === '23505';
+  }
+
+  columnsCache?: Record<string, boolean>;
+  get columns() {
+    if (this.columnsCache) return this.columnsCache;
+
+    const columns: Record<string, boolean> = {};
+
+    if (this.detail) {
+      const list = this.detail.match(/\((.*)\)=/)?.[1];
+      if (list) {
+        list.split(', ').forEach((column) => {
+          columns[column.startsWith('"') ? column.slice(1, -1) : column] = true;
+        });
+      }
+    }
+
+    return (this.columnsCache = columns);
+  }
+}
+
 export class NotFoundError extends PormError {
   constructor(message = 'Record is not found') {
     super(message);

package/src/queryMethods/then.test.ts

@@ -1,12 +1,92 @@
-import { db } from '../test-utils';
+import { assertType, UniqueTable, User, useTestDatabase } from '../test-utils';
+import { raw } from '../common';
+import { columnTypes } from '../columnSchema';
+import { QueryError } from '../errors';
 
 describe('then', () => {
+  useTestDatabase();
+
   describe('catch', () => {
-    it.only('should catch error', (done) => {
-      db('kokoko').catch((err) => {
-        expect(err.message).toBe(`relation "kokoko" does not exist`);
+    it('should catch error', (done) => {
+      const query = User.select({
+        column: raw(columnTypes.boolean(), 'koko'),
+      }).catch((err) => {
+        expect(err.message).toBe(`column "koko" does not exist`);
         done();
       });
+
+      assertType<Awaited<typeof query>, { column: boolean }[] | void>();
+    });
+  });
+
+  describe('error handling', () => {
+    it('should capture stack trace properly', async () => {
+      let err: Error | undefined;
+
+      await User.select({ column: raw(columnTypes.boolean(), 'koko') }).catch(
+        (error) => (err = error),
+      );
+
+      expect(err?.stack).toContain('then.test.ts');
+    });
+
+    it('should have isUnique and column names map when violating unique error over single column', async () => {
+      await UniqueTable.insert({
+        one: 'one',
+        two: 1,
+        thirdColumn: 'three',
+        fourthColumn: 1,
+      });
+
+      let err: QueryError | undefined;
+
+      try {
+        await UniqueTable.insert({
+          one: 'one',
+          two: 2,
+          thirdColumn: 'three',
+          fourthColumn: 2,
+        });
+      } catch (error) {
+        if (error instanceof QueryError) {
+          err = error;
+        }
+      }
+
+      expect(err?.isUnique).toBe(true);
+      expect(err?.columns).toEqual({
+        one: true,
+      });
+    });
+
+    it('should have isUnique and column names map when violating unique error over multiple columns', async () => {
+      await UniqueTable.insert({
+        one: 'one',
+        two: 1,
+        thirdColumn: 'three',
+        fourthColumn: 1,
+      });
+
+      let err: QueryError | undefined;
+
+      try {
+        await UniqueTable.insert({
+          one: 'two',
+          two: 2,
+          thirdColumn: 'three',
+          fourthColumn: 1,
+        });
+      } catch (error) {
+        if (error instanceof QueryError) {
+          err = error;
+        }
+      }
+
+      expect(err?.isUnique).toBe(true);
+      expect(err?.columns).toEqual({
+        thirdColumn: true,
+        fourthColumn: true,
+      });
     });
   });
 });

package/src/queryMethods/then.ts

@@ -1,10 +1,11 @@
 import { ColumnsParsers, Query, QueryReturnType } from '../query';
 import { getQueryParsers } from '../common';
-import { NotFoundError } from '../errors';
+import { NotFoundError, QueryError } from '../errors';
 import { QueryArraysResult, QueryResult } from '../adapter';
 import { CommonQueryData, Sql } from '../sql';
 import { AfterCallback, BeforeCallback } from './callbacks';
 import { getValueKey } from './get';
+import { DatabaseError } from 'pg';
 
 export type ThenResult<Res> = (
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -28,27 +29,24 @@ export const queryMethodByReturnType: Record<
   void: 'arrays',
 };
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Resolve = (result: any) => any;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Reject = (error: any) => any;
+
+let queryError: QueryError = undefined as unknown as QueryError;
+
 export class Then {
-  then(
-    this: Query,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    resolve?: (result: any) => any,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    reject?: (error: any) => any,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  ): Promise<any> {
-    if (this.query.wrapInTransaction && !this.query.inTransaction) {
-      return this.transaction((q) => then(q, resolve, reject));
-    } else {
-      return then(this, resolve, reject);
-    }
+  get then() {
+    queryError = new (QueryError as unknown as new () => QueryError)();
+    return maybeWrappedThen;
   }
 
-  async catch<Result>(
-    this: Query,
+  async catch<T extends Query, Result>(
+    this: T,
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     fn: (reason: any) => Result | PromiseLike<Result>,
-  ): Promise<Result> {
+  ): Promise<ReturnType<T['then']> | Result> {
     return this.then(undefined, fn);
   }
 }
@@ -60,6 +58,14 @@ export const handleResult: CommonQueryData['handleResult'] = async (
   return parseResult(q, q.query.returnType || 'all', result);
 };
 
+function maybeWrappedThen(this: Query, resolve?: Resolve, reject?: Reject) {
+  if (this.query.wrapInTransaction && !this.query.inTransaction) {
+    return this.transaction((q) => then(q, resolve, reject));
+  } else {
+    return then(this, resolve, reject);
+  }
+}
+
 const then = async (
   q: Query,
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -117,7 +123,10 @@ const then = async (
     }
 
     resolve?.(result);
-  } catch (error) {
+  } catch (err) {
+    const error =
+      err instanceof DatabaseError ? assignError(queryError, err) : err;
+
     if (q.query.log && sql && logData) {
       q.query.log.onError(error as Error, sql, logData);
     }
@@ -125,6 +134,30 @@ const then = async (
   }
 };
 
+const assignError = (to: QueryError, from: DatabaseError) => {
+  to.message = from.message;
+  (to as { length?: number }).length = from.length;
+  (to as { name?: string }).name = from.name;
+  to.severity = from.severity;
+  to.code = from.code;
+  to.detail = from.detail;
+  to.hint = from.hint;
+  to.position = from.position;
+  to.internalPosition = from.internalPosition;
+  to.internalQuery = from.internalQuery;
+  to.where = from.where;
+  to.schema = from.schema;
+  to.table = from.table;
+  to.column = from.column;
+  to.dataType = from.dataType;
+  to.constraint = from.constraint;
+  to.file = from.file;
+  to.line = from.line;
+  to.routine = from.routine;
+
+  return to;
+};
+
 export const parseResult = (
   q: Query,
   returnType: QueryReturnType | undefined = 'all',

package/src/test-utils.ts

@@ -60,6 +60,14 @@ export const Chat = db('chat', (t) => ({
   ...t.timestamps(),
 }));
 
+export const UniqueTable = db('uniqueTable', (t) => ({
+  one: t.text().unique(),
+  two: t.integer().unique(),
+  thirdColumn: t.text(),
+  fourthColumn: t.integer(),
+  ...t.unique(['thirdColumn', 'fourthColumn']),
+}));
+
 export type MessageRecord = typeof Message['type'];
 export const Message = db('message', (t) => ({
   id: t.serial().primaryKey(),