pqb 0.7.7 → 0.7.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pqb",
-  "version": "0.7.7",
+  "version": "0.7.9",
   "description": "Postgres query builder",
   "homepage": "https://orchid-orm.netlify.app/guide/query-builder-setup.html",
   "repository": {

package/src/adapter.ts

@@ -41,8 +41,9 @@ for (const key in types.builtins) {
 
 const returnArg = (arg: unknown) => arg;
 
-export type AdapterOptions = Omit<PoolConfig, 'types'> & {
+export type AdapterOptions = Omit<PoolConfig, 'types' | 'connectionString'> & {
   types?: TypeParsers;
+  databaseURL?: string;
 };
 
 export class Adapter {
@@ -51,6 +52,13 @@ export class Adapter {
 
   constructor({ types = defaultTypeParsers, ...config }: AdapterOptions) {
     this.types = types;
+    if (config.databaseURL) {
+      (config as PoolConfig).connectionString = config.databaseURL;
+      const url = new URL(config.databaseURL);
+      if (url.searchParams.get('ssl') === 'true') {
+        config.ssl = true;
+      }
+    }
     this.pool = new Pool(config);
   }
 

package/src/db.test.ts

@@ -2,6 +2,7 @@ import {
   adapter,
   assertType,
   db,
+  dbOptions,
   expectSql,
   User,
   userData,
@@ -153,4 +154,16 @@ describe('db', () => {
       expect(logger.warn).not.toBeCalled();
     });
   });
+
+  it('should use ssl when ssl=true query parameter provided on a databaseUrl option', () => {
+    const db = createDb({
+      ...dbOptions,
+      databaseURL: dbOptions.databaseURL + '?ssl=true',
+    });
+
+    expect(
+      (db.adapter.pool as unknown as { options: Record<string, unknown> })
+        .options.ssl,
+    ).toBe(true);
+  });
 });

package/src/queryMethods/then.test.ts

@@ -14,10 +14,22 @@ describe('then', () => {
         column: db.raw((t) => t.boolean(), 'koko'),
       }).catch((err) => {
         expect(err.message).toBe(`column "koko" does not exist`);
+        expect(err.stack).toContain('then.test.ts');
         done();
       });
 
       assertType<Awaited<typeof query>, { column: boolean }[] | void>();
     });
   });
+
+  it('should throw NotFoundError with proper stack trace', async () => {
+    let error: unknown | undefined;
+    try {
+      await User.take();
+    } catch (err) {
+      error = err;
+    }
+
+    expect((error as { stack: string }).stack).toContain('then.test.ts');
+  });
 });

package/src/queryMethods/then.ts

@@ -133,7 +133,15 @@ const then = async (
 
     resolve?.(result);
   } catch (err) {
-    const error = err instanceof DatabaseError ? assignError(q, err) : err;
+    let error;
+    if (err instanceof DatabaseError) {
+      error = new (q.error as unknown as new () => QueryError)();
+      assignError(error, err);
+    } else {
+      error = err;
+    }
+
+    (error as Error).stack = queryError.stack;
 
     if (q.query.log && sql && logData) {
       q.query.log.onError(error as Error, sql, logData);
@@ -142,9 +150,7 @@ const then = async (
   }
 };
 
-const assignError = (q: Query, from: DatabaseError) => {
-  const to = new (q.error as unknown as new () => QueryError)();
-  to.stack = queryError.stack;
+const assignError = (to: QueryError, from: DatabaseError) => {
   to.message = from.message;
   (to as { length?: number }).length = from.length;
   (to as { name?: string }).name = from.name;

package/src/test-utils/test-utils.ts

@@ -12,11 +12,11 @@ import { MaybeArray, toArray } from '../utils';
 import { Adapter } from '../adapter';
 
 export const dbOptions = {
-  connectionString: process.env.DATABASE_URL,
+  databaseURL: process.env.DATABASE_URL,
   columnTypes,
 };
 
-export const dbClient = new Client(dbOptions);
+export const dbClient = new Client({ connectionString: dbOptions.databaseURL });
 
 export const adapter = new Adapter(dbOptions);