pqb 0.3.8 → 0.4.0

package/src/db.ts

@@ -25,6 +25,7 @@ import {
 } from './columnSchema';
 import { applyMixins, pushOrNewArray } from './utils';
 import { StringKey } from './common';
+import { QueryError, QueryErrorName } from './errors';
 
 export type DbTableOptions = {
   schema?: string;
@@ -76,6 +77,11 @@ export interface Db<
   columnsParsers?: ColumnsParsers;
   relations: Relations;
   withData: Query['withData'];
+  error: new (
+    message: string,
+    length: number,
+    name: QueryErrorName,
+  ) => QueryError<this>;
   [defaultsKey]: Record<
     {
       [K in keyof Shape]: Shape[K]['hasDefault'] extends true ? K : never;
@@ -139,7 +145,7 @@ export class Db<
 
     const columnsParsers = {} as ColumnsParsers;
     let hasParsers = false;
-    let modifyQuery: ((q: Query) => void)[] | undefined;
+    let modifyQuery: ((q: Query) => void)[] | undefined = undefined;
     for (const key in shape) {
       const column = shape[key];
       if (column.parseFn) {
@@ -166,6 +172,8 @@ export class Db<
     this.relations = {} as Relations;
 
     modifyQuery?.forEach((cb) => cb(this));
+
+    this.error = class extends QueryError {};
   }
 }
 

package/src/errors.test.ts

@@ -0,0 +1,79 @@
+import { UniqueTable, User, useTestDatabase } from './test-utils';
+import { raw } from './common';
+import { columnTypes } from './columnSchema';
+import { QueryError } from './errors';
+
+describe('errors', () => {
+  useTestDatabase();
+
+  it('should capture stack trace properly', async () => {
+    let err: Error | undefined;
+
+    try {
+      await User.select({ column: raw(columnTypes.boolean(), 'koko') });
+    } catch (error) {
+      err = error as Error;
+    }
+
+    expect(err?.stack).toContain('errors.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: InstanceType<typeof UniqueTable.error> | undefined;
+
+    try {
+      await UniqueTable.insert({
+        one: 'one',
+        two: 2,
+        thirdColumn: 'three',
+        fourthColumn: 2,
+      });
+    } catch (error) {
+      if (error instanceof UniqueTable.error) {
+        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/errors.ts

@@ -1,5 +1,87 @@
+import { DatabaseError } from 'pg';
+import { ColumnsShape } from './columnSchema';
+
 export class PormError extends Error {}
 
+export type QueryErrorName =
+  | 'parseComplete'
+  | 'bindComplete'
+  | 'closeComplete'
+  | 'noData'
+  | 'portalSuspended'
+  | 'replicationStart'
+  | 'emptyQuery'
+  | 'copyDone'
+  | 'copyData'
+  | 'rowDescription'
+  | 'parameterDescription'
+  | 'parameterStatus'
+  | 'backendKeyData'
+  | 'notification'
+  | 'readyForQuery'
+  | 'commandComplete'
+  | 'dataRow'
+  | 'copyInResponse'
+  | 'copyOutResponse'
+  | 'authenticationOk'
+  | 'authenticationMD5Password'
+  | 'authenticationCleartextPassword'
+  | 'authenticationSASL'
+  | 'authenticationSASLContinue'
+  | 'authenticationSASLFinal'
+  | 'error'
+  | 'notice';
+
+export class QueryError<
+  T extends { shape: ColumnsShape } = { shape: ColumnsShape },
+> extends DatabaseError {
+  message!: string;
+  name!: QueryErrorName;
+  stack: string | undefined;
+  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?: { [K in keyof T['shape']]?: true };
+  get columns() {
+    if (this.columnsCache) return this.columnsCache;
+
+    const columns: { [K in keyof T['shape']]?: true } = {};
+
+    if (this.detail) {
+      const list = this.detail.match(/\((.*)\)=/)?.[1];
+      if (list) {
+        list.split(', ').forEach((item) => {
+          const column = (
+            item.startsWith('"') ? item.slice(1, -1) : item
+          ) as keyof T['shape'];
+
+          columns[column] = true;
+        });
+      }
+    }
+
+    return (this.columnsCache = columns);
+  }
+}
+
 export class NotFoundError extends PormError {
   constructor(message = 'Record is not found') {
     super(message);

package/src/query.ts

@@ -13,6 +13,7 @@ import { EmptyObject, Spread } from './utils';
 import { AliasOrTable, RawExpression, StringKey } from './common';
 import { Db } from './db';
 import { RelationQueryBase, RelationsBase } from './relations';
+import { QueryError, QueryErrorName } from './errors';
 
 export type ColumnParser = (input: unknown) => unknown;
 export type ColumnsParsers = Record<string | getValueKey, ColumnParser>;
@@ -64,6 +65,11 @@ export type Query = QueryMethods & {
   columnsParsers?: ColumnsParsers;
   relations: RelationsBase;
   withData: WithDataBase;
+  error: new (
+    message: string,
+    length: number,
+    name: QueryErrorName,
+  ) => QueryError;
   // eslint-disable-next-line @typescript-eslint/ban-types
   [defaultsKey]: {};
 };

package/src/queryMethods/then.test.ts

@@ -1,8 +1,10 @@
-import { assertType, User } from '../test-utils';
+import { assertType, User, useTestDatabase } from '../test-utils';
 import { raw } from '../common';
 import { columnTypes } from '../columnSchema';
 
 describe('then', () => {
+  useTestDatabase();
+
   describe('catch', () => {
     it('should catch error', (done) => {
       const query = User.select({

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,20 +29,17 @@ 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: Error = undefined as unknown as Error;
+
 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 Error();
+    return maybeWrappedThen;
   }
 
   async catch<T extends Query, Result>(
@@ -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,9 @@ const then = async (
     }
 
     resolve?.(result);
-  } catch (error) {
+  } catch (err) {
+    const error = err instanceof DatabaseError ? assignError(q, err) : err;
+
     if (q.query.log && sql && logData) {
       q.query.log.onError(error as Error, sql, logData);
     }
@@ -125,6 +133,32 @@ const then = async (
   }
 };
 
+const assignError = (q: Query, from: DatabaseError) => {
+  const to = new (q.error as unknown as new () => QueryError)();
+  to.stack = queryError.stack;
+  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(),