pqb 0.3.6 → 0.3.7

package/src/queryMethods/aggregate.test.ts

@@ -2,9 +2,9 @@ import {
   User,
   expectQueryNotMutated,
   expectSql,
-  AssertEqual,
   useTestDatabase,
   userData,
+  assertType,
 } from '../test-utils';
 import { raw } from '../common';
 
@@ -126,8 +126,7 @@ describe('aggregate', () => {
     it('should return a number', async () => {
       const count = await User.count();
 
-      const eq: AssertEqual<typeof count, number> = true;
-      expect(eq).toBe(true);
+      assertType<typeof count, number>();
 
       expect(typeof count).toBe('number');
     });
@@ -139,8 +138,7 @@ describe('aggregate', () => {
         const user = await User.selectCount().take();
         expect(user.count).toBe(1);
 
-        const eq: AssertEqual<typeof user.count, number> = true;
-        expect(eq).toBe(true);
+        assertType<typeof user.count, number>();
       });
     });
   });
@@ -157,8 +155,7 @@ describe('aggregate', () => {
     it('should return null when no records', async () => {
       const value = await User[method as 'avg']('id');
 
-      const eq: AssertEqual<typeof value, number | null> = true;
-      expect(eq).toBe(true);
+      assertType<typeof value, number | null>();
 
       expect(value).toBe(null);
     });
@@ -168,8 +165,7 @@ describe('aggregate', () => {
 
       const value = await User[method as 'avg']('id');
 
-      const eq: AssertEqual<typeof value, number | null> = true;
-      expect(eq).toBe(true);
+      assertType<typeof value, number | null>();
 
       expect(typeof value).toBe('number');
     });
@@ -181,8 +177,7 @@ describe('aggregate', () => {
       it('should select null when no record', async () => {
         const value = await User[selectMethod]('id').take();
 
-        const eq: AssertEqual<typeof value, { avg: number | null }> = true;
-        expect(eq).toBe(true);
+        assertType<typeof value, { avg: number | null }>();
 
         expect(value).toEqual({ [functionName]: null });
       });
@@ -192,8 +187,7 @@ describe('aggregate', () => {
 
         const value = await User[selectMethod]('id').take();
 
-        const eq: AssertEqual<typeof value, { avg: number | null }> = true;
-        expect(eq).toBe(true);
+        assertType<typeof value, { avg: number | null }>();
 
         expect(value).toEqual({ [functionName]: id });
       });
@@ -209,8 +203,7 @@ describe('aggregate', () => {
     it('should return null when no records', async () => {
       const value = await User[method as 'boolAnd']('active');
 
-      const eq: AssertEqual<typeof value, boolean | null> = true;
-      expect(eq).toBe(true);
+      assertType<typeof value, boolean | null>();
 
       expect(value).toBe(null);
     });
@@ -220,8 +213,7 @@ describe('aggregate', () => {
 
       const value = await User[method as 'boolAnd']('active');
 
-      const eq: AssertEqual<typeof value, boolean | null> = true;
-      expect(eq).toBe(true);
+      assertType<typeof value, boolean | null>();
 
       expect(typeof value).toBe('boolean');
     });
@@ -233,9 +225,7 @@ describe('aggregate', () => {
       it('should select null when no record', async () => {
         const value = await User[selectMethod]('active').take();
 
-        const eq: AssertEqual<typeof value, { bool_and: boolean | null }> =
-          true;
-        expect(eq).toBe(true);
+        assertType<typeof value, { bool_and: boolean | null }>();
 
         expect(value).toEqual({ [functionName]: null });
       });
@@ -245,9 +235,7 @@ describe('aggregate', () => {
 
         const value = await User[selectMethod]('active').take();
 
-        const eq: AssertEqual<typeof value, { bool_and: boolean | null }> =
-          true;
-        expect(eq).toBe(true);
+        assertType<typeof value, { bool_and: boolean | null }>();
 
         expect(value).toEqual({ [functionName]: true });
       });
@@ -264,11 +252,10 @@ describe('aggregate', () => {
     it('should return null when no records', async () => {
       const value = await User[method as 'jsonAgg']('data');
 
-      const eq: AssertEqual<
+      assertType<
         typeof value,
         ({ name: string; tags: string[] } | null)[] | null
-      > = true;
-      expect(eq).toBe(true);
+      >();
 
       expect(value).toBe(null);
     });
@@ -278,11 +265,10 @@ describe('aggregate', () => {
 
       const value = await User[method as 'jsonAgg']('data');
 
-      const eq: AssertEqual<
+      assertType<
         typeof value,
         ({ name: string; tags: string[] } | null)[] | null
-      > = true;
-      expect(eq).toBe(true);
+      >();
 
       expect(value).toEqual([data]);
     });
@@ -294,11 +280,10 @@ describe('aggregate', () => {
       it('should select null when no record', async () => {
         const value = await User[selectMethod]('data').take();
 
-        const eq: AssertEqual<
+        assertType<
           typeof value,
           { json_agg: ({ name: string; tags: string[] } | null)[] | null }
-        > = true;
-        expect(eq).toBe(true);
+        >();
 
         expect(value).toEqual({ [functionName]: null });
       });
@@ -308,11 +293,10 @@ describe('aggregate', () => {
 
         const value = await User[selectMethod]('data').take();
 
-        const eq: AssertEqual<
+        assertType<
           typeof value,
           { json_agg: ({ name: string; tags: string[] } | null)[] | null }
-        > = true;
-        expect(eq).toBe(true);
+        >();
 
         expect(value).toEqual({ [functionName]: [data] });
       });
@@ -390,8 +374,7 @@ describe('aggregate', () => {
     it('should return null when no records', async () => {
       const value = await User[method as 'jsonObjectAgg']({ alias: 'name' });
 
-      const eq: AssertEqual<typeof value, { alias: string } | null> = true;
-      expect(eq).toBe(true);
+      assertType<typeof value, { alias: string } | null>();
 
       expect(value).toBe(null);
     });
@@ -401,8 +384,7 @@ describe('aggregate', () => {
 
       const value = await User[method as 'jsonObjectAgg']({ alias: 'name' });
 
-      const eq: AssertEqual<typeof value, { alias: string } | null> = true;
-      expect(eq).toBe(true);
+      assertType<typeof value, { alias: string } | null>();
 
       expect(value).toEqual({ alias: 'name' });
     });
@@ -414,11 +396,10 @@ describe('aggregate', () => {
       it('should select null when no record', async () => {
         const value = await User[selectMethod]({ alias: 'name' }).take();
 
-        const eq: AssertEqual<
+        assertType<
           typeof value,
           { json_object_agg: { alias: string } | null }
-        > = true;
-        expect(eq).toBe(true);
+        >();
 
         expect(value).toEqual({ [functionName]: null });
       });
@@ -428,11 +409,10 @@ describe('aggregate', () => {
 
         const value = await User[selectMethod]({ alias: 'name' }).take();
 
-        const eq: AssertEqual<
+        assertType<
           typeof value,
           { json_object_agg: { alias: string } | null }
-        > = true;
-        expect(eq).toBe(true);
+        >();
 
         expect(value).toEqual({ [functionName]: { alias: 'name' } });
       });
@@ -497,8 +477,7 @@ describe('aggregate', () => {
     it('should return null when no records', async () => {
       const value = await User.stringAgg('name', ', ');
 
-      const eq: AssertEqual<typeof value, string | null> = true;
-      expect(eq).toBe(true);
+      assertType<typeof value, string | null>();
 
       expect(value).toBe(null);
     });
@@ -508,8 +487,7 @@ describe('aggregate', () => {
 
       const value = await User.stringAgg('name', ', ');
 
-      const eq: AssertEqual<typeof value, string | null> = true;
-      expect(eq).toBe(true);
+      assertType<typeof value, string | null>();
 
       expect(value).toEqual('name, name');
     });
@@ -518,9 +496,7 @@ describe('aggregate', () => {
       it('should select null when no record', async () => {
         const value = await User.selectStringAgg('name', ', ').take();
 
-        const eq: AssertEqual<typeof value, { string_agg: string | null }> =
-          true;
-        expect(eq).toBe(true);
+        assertType<typeof value, { string_agg: string | null }>();
 
         expect(value).toEqual({ string_agg: null });
       });
@@ -530,9 +506,7 @@ describe('aggregate', () => {
 
         const value = await User.selectStringAgg('name', ', ').take();
 
-        const eq: AssertEqual<typeof value, { string_agg: string | null }> =
-          true;
-        expect(eq).toBe(true);
+        assertType<typeof value, { string_agg: string | null }>();
 
         expect(value).toEqual({ string_agg: 'name, name' });
       });

package/src/queryMethods/delete.test.ts

@@ -1,5 +1,5 @@
 import {
-  AssertEqual,
+  assertType,
   expectQueryNotMutated,
   expectSql,
   Profile,
@@ -45,8 +45,7 @@ describe('delete', () => {
     const result = await query;
     expect(result).toBe(id);
 
-    const eq: AssertEqual<typeof result, number> = true;
-    expect(eq).toBe(true);
+    assertType<typeof result, number>();
 
     expectQueryNotMutated(q);
   });
@@ -66,8 +65,7 @@ describe('delete', () => {
     const result = await query;
     expect(result).toBe(rowsCount);
 
-    const eq: AssertEqual<typeof result, number> = true;
-    expect(eq).toBe(true);
+    assertType<typeof result, number>();
 
     expectQueryNotMutated(q);
   });
@@ -82,8 +80,7 @@ describe('delete', () => {
       [1],
     );
 
-    const eq: AssertEqual<Awaited<typeof query>, typeof User['type'][]> = true;
-    expect(eq).toBe(true);
+    assertType<Awaited<typeof query>, typeof User['type'][]>();
 
     expectQueryNotMutated(q);
   });
@@ -98,11 +95,7 @@ describe('delete', () => {
       [1],
     );
 
-    const eq: AssertEqual<
-      Awaited<typeof query>,
-      { id: number; name: string }[]
-    > = true;
-    expect(eq).toBe(true);
+    assertType<Awaited<typeof query>, { id: number; name: string }[]>();
 
     expectQueryNotMutated(q);
   });
@@ -127,8 +120,7 @@ describe('delete', () => {
       [1],
     );
 
-    const eq: AssertEqual<Awaited<typeof query>, typeof User['type'][]> = true;
-    expect(eq).toBe(true);
+    assertType<Awaited<typeof query>, typeof User['type'][]>();
 
     expectQueryNotMutated(q);
   });

package/src/queryMethods/get.test.ts

@@ -1,4 +1,4 @@
-import { AssertEqual, User, userData, useTestDatabase } from '../test-utils';
+import { assertType, User, userData, useTestDatabase } from '../test-utils';
 import { NumberColumn } from '../columnSchema';
 import { NotFoundError } from '../errors';
 import { raw } from '../common';
@@ -12,8 +12,7 @@ describe('get', () => {
 
       const received = await User.get('id');
 
-      const eq: AssertEqual<typeof received, number> = true;
-      expect(eq).toBe(true);
+      assertType<typeof received, number>();
 
       expect(received).toBe(id);
     });
@@ -21,8 +20,7 @@ describe('get', () => {
     it('should select raw and return a single value', async () => {
       const received = await User.get(raw<NumberColumn>('count(*)::int'));
 
-      const eq: AssertEqual<typeof received, number> = true;
-      expect(eq).toBe(true);
+      assertType<typeof received, number>();
 
       expect(received).toBe(0);
     });
@@ -38,8 +36,7 @@ describe('get', () => {
 
       const received = await User.getOptional('id');
 
-      const eq: AssertEqual<typeof received, number | undefined> = true;
-      expect(eq).toBe(true);
+      assertType<typeof received, number | undefined>();
 
       expect(received).toBe(id);
     });
@@ -49,16 +46,14 @@ describe('get', () => {
         raw<NumberColumn>('count(*)::int'),
       );
 
-      const eq: AssertEqual<typeof received, number | undefined> = true;
-      expect(eq).toBe(true);
+      assertType<typeof received, number | undefined>();
 
       expect(received).toBe(0);
     });
 
     it('should return undefined if not found', async () => {
       const value = await User.getOptional('id');
-      const eq: AssertEqual<typeof value, number | undefined> = true;
-      expect(eq).toBe(true);
+      assertType<typeof value, number | undefined>();
 
       expect(value).toBe(undefined);
     });

package/src/queryMethods/insert.test.ts

@@ -1,5 +1,5 @@
 import {
-  AssertEqual,
+  assertType,
   expectQueryNotMutated,
   expectSql,
   User,
@@ -28,8 +28,7 @@ describe('insert functions', () => {
       `,
       );
 
-      const eq: AssertEqual<Awaited<typeof query>, number> = true;
-      expect(eq).toBe(true);
+      assertType<Awaited<typeof query>, number>();
 
       expectQueryNotMutated(q);
     });
@@ -52,8 +51,7 @@ describe('insert functions', () => {
       const result = await query;
       expect(result).toBe(1);
 
-      const eq: AssertEqual<typeof result, number> = true;
-      expect(eq).toBe(true);
+      assertType<typeof result, number>();
 
       const inserted = await User.take();
       expect(inserted).toMatchObject(userData);
@@ -76,8 +74,7 @@ describe('insert functions', () => {
       );
 
       const result = await query;
-      const eq: AssertEqual<typeof result, number> = true;
-      expect(eq).toBe(true);
+      assertType<typeof result, number>();
 
       expect(typeof result).toBe('number');
 
@@ -99,8 +96,7 @@ describe('insert functions', () => {
       );
 
       const result = await query;
-      const eq: AssertEqual<typeof result, { id: number; name: string }> = true;
-      expect(eq).toBe(true);
+      assertType<typeof result, { id: number; name: string }>();
 
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
       const { password, ...other } = userData;
@@ -124,8 +120,7 @@ describe('insert functions', () => {
       );
 
       const result = await query;
-      const eq: AssertEqual<typeof result, typeof User['type']> = true;
-      expect(eq).toBe(true);
+      assertType<typeof result, typeof User['type']>();
 
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
       const { password, ...other } = userData;
@@ -181,8 +176,7 @@ describe('insert functions', () => {
       const result = await query;
       expect(result).toBe(2);
 
-      const eq: AssertEqual<typeof result, number> = true;
-      expect(eq).toBe(true);
+      assertType<typeof result, number>();
 
       const inserted = await User.all();
       inserted.forEach((item, i) => {
@@ -218,9 +212,7 @@ describe('insert functions', () => {
       );
 
       const result = await query;
-      const eq: AssertEqual<typeof result, { id: number; name: string }[]> =
-        true;
-      expect(eq).toBe(true);
+      assertType<typeof result, { id: number; name: string }[]>();
 
       const inserted = await User.all();
       inserted.forEach((item, i) => {
@@ -260,8 +252,7 @@ describe('insert functions', () => {
         expect(item).toMatchObject(arr[i]);
       });
 
-      const eq: AssertEqual<typeof result, typeof User['type'][]> = true;
-      expect(eq).toBe(true);
+      assertType<typeof result, typeof User['type'][]>();
 
       const inserted = await User.all();
       inserted.forEach((item, i) => {
@@ -503,8 +494,7 @@ describe('insert functions', () => {
         const result = await User.create(userData);
         expect(result).toMatchObject(userData);
 
-        const eq: AssertEqual<typeof result, typeof User.type> = true;
-        expect(eq).toBe(true);
+        assertType<typeof result, typeof User.type>();
       });
 
       it('should return columns from select', async () => {
@@ -514,9 +504,7 @@ describe('insert functions', () => {
           name: userData.name,
         });
 
-        const eq: AssertEqual<typeof result, { id: number; name: string }> =
-          true;
-        expect(eq).toBe(true);
+        assertType<typeof result, { id: number; name: string }>();
       });
     });
 
@@ -526,8 +514,7 @@ describe('insert functions', () => {
         expect(result[0]).toMatchObject(userData);
         expect(result[1]).toMatchObject(userData);
 
-        const eq: AssertEqual<typeof result, typeof User.type[]> = true;
-        expect(eq).toBe(true);
+        assertType<typeof result, typeof User.type[]>();
       });
 
       it('should return columns from select', async () => {
@@ -544,9 +531,7 @@ describe('insert functions', () => {
           name: userData.name,
         });
 
-        const eq: AssertEqual<typeof result, { id: number; name: string }[]> =
-          true;
-        expect(eq).toBe(true);
+        assertType<typeof result, { id: number; name: string }[]>();
       });
     });
   });

package/src/queryMethods/json.test.ts

@@ -1,5 +1,5 @@
 import {
-  AssertEqual,
+  assertType,
   expectQueryNotMutated,
   expectSql,
   User,
@@ -71,11 +71,10 @@ describe('json methods', () => {
         const result = await query.take();
         expect(result.data).toEqual({ name: 'new value', tags: ['one'] });
 
-        const eq: AssertEqual<
+        assertType<
           typeof result.data,
           { name: string; tags: string[] } | null
-        > = true;
-        expect(eq).toBe(true);
+        >();
 
         expectQueryNotMutated(q);
       });
@@ -99,11 +98,10 @@ describe('json methods', () => {
         const result = await query.take();
         expect(result.alias).toEqual({ name: 'new value', tags: ['one'] });
 
-        const eq: AssertEqual<
+        assertType<
           typeof result.alias,
           { name: string; tags: string[] } | null
-        > = true;
-        expect(eq).toBe(true);
+        >();
 
         expectQueryNotMutated(q);
       });
@@ -134,11 +132,10 @@ describe('json methods', () => {
           tags: ['two', 'one'],
         });
 
-        const eq: AssertEqual<
+        assertType<
           typeof result.data,
           { name: string; tags: string[] } | null
-        > = true;
-        expect(eq).toBe(true);
+        >();
 
         expectQueryNotMutated(q);
       });
@@ -161,11 +158,10 @@ describe('json methods', () => {
         const result = await query.take();
         expect(result.data).toEqual({ name: 'value', tags: ['two', 'one'] });
 
-        const eq: AssertEqual<
+        assertType<
           typeof result.data,
           { name: string; tags: string[] } | null
-        > = true;
-        expect(eq).toBe(true);
+        >();
 
         expectQueryNotMutated(q);
       });
@@ -189,11 +185,10 @@ describe('json methods', () => {
         const result = await query.take();
         expect(result.alias).toEqual({ name: 'value', tags: ['one', 'two'] });
 
-        const eq: AssertEqual<
+        assertType<
           typeof result.alias,
           { name: string; tags: string[] } | null
-        > = true;
-        expect(eq).toBe(true);
+        >();
 
         expectQueryNotMutated(q);
       });
@@ -221,11 +216,10 @@ describe('json methods', () => {
         const result = await query.take();
         expect(result.data).toEqual({ name: 'value', tags: ['tag'] });
 
-        const eq: AssertEqual<
+        assertType<
           typeof result.data,
           { name: string; tags: string[] } | null
-        > = true;
-        expect(eq).toBe(true);
+        >();
 
         expectQueryNotMutated(q);
       });
@@ -247,11 +241,10 @@ describe('json methods', () => {
         const result = await query.take();
         expect(result.data).toEqual({ name: 'value', tags: [] });
 
-        const eq: AssertEqual<
+        assertType<
           typeof result.data,
           { name: string; tags: string[] } | null
-        > = true;
-        expect(eq).toBe(true);
+        >();
 
         expectQueryNotMutated(q);
       });
@@ -271,11 +264,10 @@ describe('json methods', () => {
         const result = await query.take();
         expect(result.alias).toEqual({ name: 'value', tags: [] });
 
-        const eq: AssertEqual<
+        assertType<
           typeof result.alias,
           { name: string; tags: string[] } | null
-        > = true;
-        expect(eq).toBe(true);
+        >();
 
         expectQueryNotMutated(q);
       });
@@ -300,11 +292,10 @@ describe('json methods', () => {
         const result = await query.take();
         expect(result.data).toEqual({ name: 'value', tags: [] });
 
-        const eq: AssertEqual<
+        assertType<
           typeof result.data,
           { name: string; tags: string[] } | null
-        > = true;
-        expect(eq).toBe(true);
+        >();
 
         expectQueryNotMutated(q);
       });
@@ -332,8 +323,7 @@ describe('json methods', () => {
         const result = await query.take();
         expect(result.name).toBe('value');
 
-        const eq: AssertEqual<typeof result.name, string> = true;
-        expect(eq).toBe(true);
+        assertType<typeof result.name, string>();
 
         expectQueryNotMutated(q);
       });
@@ -388,8 +378,7 @@ describe('json methods', () => {
         const result = await query.take();
         expect(result.tags).toEqual(['tag']);
 
-        const eq: AssertEqual<typeof result.tags, string[]> = true;
-        expect(eq).toBe(true);
+        assertType<typeof result.tags, string[]>();
 
         expectQueryNotMutated(q);
       });

package/src/queryMethods/then.test.ts

@@ -0,0 +1,12 @@
+import { db } from '../test-utils';
+
+describe('then', () => {
+  describe('catch', () => {
+    it.only('should catch error', (done) => {
+      db('kokoko').catch((err) => {
+        expect(err.message).toBe(`relation "kokoko" does not exist`);
+        done();
+      });
+    });
+  });
+});

package/src/queryMethods/then.ts

@@ -43,6 +43,14 @@ export class Then {
       return then(this, resolve, reject);
     }
   }
+
+  async catch<Result>(
+    this: Query,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    fn: (reason: any) => Result | PromiseLike<Result>,
+  ): Promise<Result> {
+    return this.then(undefined, fn);
+  }
 }
 
 export const handleResult: CommonQueryData['handleResult'] = async (