pqb 0.4.0 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pqb",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Postgres query builder",
   "homepage": "https://porm.netlify.app/guide/query-builder.html",
   "repository": {

package/src/columnSchema/columnType.test.ts

@@ -102,7 +102,7 @@ describe('column base', () => {
 
     describe('parsing columns', () => {
       beforeEach(async () => {
-        await User.insert(userData);
+        await User.create(userData);
       });
 
       it('should return column data as returned from db if not set', async () => {

package/src/db.test.ts

@@ -28,7 +28,7 @@ describe('db', () => {
 
   describe('overriding column types', () => {
     it('should return date as string by default', async () => {
-      await User.insert(userData);
+      await User.create(userData);
 
       const db = createDb({ adapter, columnTypes });
       const table = db('user', (t) => ({
@@ -42,7 +42,7 @@ describe('db', () => {
     });
 
     it('should return date as Date when overridden', async () => {
-      await User.insert(userData);
+      await User.create(userData);
 
       const db = createDb({
         adapter,

package/src/errors.test.ts

@@ -19,7 +19,7 @@ describe('errors', () => {
   });
 
   it('should have isUnique and column names map when violating unique error over single column', async () => {
-    await UniqueTable.insert({
+    await UniqueTable.create({
       one: 'one',
       two: 1,
       thirdColumn: 'three',
@@ -29,7 +29,7 @@ describe('errors', () => {
     let err: InstanceType<typeof UniqueTable.error> | undefined;
 
     try {
-      await UniqueTable.insert({
+      await UniqueTable.create({
         one: 'one',
         two: 2,
         thirdColumn: 'three',
@@ -48,7 +48,7 @@ describe('errors', () => {
   });
 
   it('should have isUnique and column names map when violating unique error over multiple columns', async () => {
-    await UniqueTable.insert({
+    await UniqueTable.create({
       one: 'one',
       two: 1,
       thirdColumn: 'three',
@@ -58,7 +58,7 @@ describe('errors', () => {
     let err: QueryError | undefined;
 
     try {
-      await UniqueTable.insert({
+      await UniqueTable.create({
         one: 'two',
         two: 2,
         thirdColumn: 'three',

package/src/queryMethods/aggregate.test.ts

@@ -133,7 +133,7 @@ describe('aggregate', () => {
 
     describe('selectCount', () => {
       it('should select number', async () => {
-        await User.insert(userData);
+        await User.create(userData);
 
         const user = await User.selectCount().take();
         expect(user.count).toBe(1);
@@ -161,7 +161,7 @@ describe('aggregate', () => {
     });
 
     it('should return number when have records', async () => {
-      await User.insert(userData);
+      await User.create(userData);
 
       const value = await User[method as 'avg']('id');
 
@@ -183,7 +183,7 @@ describe('aggregate', () => {
       });
 
       it('should return number when have records', async () => {
-        const id = await User.get('id').insert(userData);
+        const id = await User.get('id').create(userData);
 
         const value = await User[selectMethod]('id').take();
 
@@ -209,7 +209,7 @@ describe('aggregate', () => {
     });
 
     it('should return boolean when have records', async () => {
-      await User.insert({ ...userData, active: true });
+      await User.create({ ...userData, active: true });
 
       const value = await User[method as 'boolAnd']('active');
 
@@ -231,7 +231,7 @@ describe('aggregate', () => {
       });
 
       it('should return boolean when have records', async () => {
-        await User.insert({ ...userData, active: true });
+        await User.create({ ...userData, active: true });
 
         const value = await User[selectMethod]('active').take();
 
@@ -261,7 +261,7 @@ describe('aggregate', () => {
     });
 
     it('should return json array when have records', async () => {
-      await User.insert({ ...userData, data });
+      await User.create({ ...userData, data });
 
       const value = await User[method as 'jsonAgg']('data');
 
@@ -289,7 +289,7 @@ describe('aggregate', () => {
       });
 
       it('should return json array when have records', async () => {
-        await User.insert({ ...userData, data });
+        await User.create({ ...userData, data });
 
         const value = await User[selectMethod]('data').take();
 
@@ -380,7 +380,7 @@ describe('aggregate', () => {
     });
 
     it('should return json object when have records', async () => {
-      await User.insert(userData);
+      await User.create(userData);
 
       const value = await User[method as 'jsonObjectAgg']({ alias: 'name' });
 
@@ -405,7 +405,7 @@ describe('aggregate', () => {
       });
 
       it('should return json object when have records', async () => {
-        await User.insert(userData);
+        await User.create(userData);
 
         const value = await User[selectMethod]({ alias: 'name' }).take();
 
@@ -483,7 +483,7 @@ describe('aggregate', () => {
     });
 
     it('should return json object when have records', async () => {
-      await User.insertMany([userData, userData]);
+      await User.createMany([userData, userData]);
 
       const value = await User.stringAgg('name', ', ');
 
@@ -502,7 +502,7 @@ describe('aggregate', () => {
       });
 
       it('should return json object when have records', async () => {
-        await User.insertMany([userData, userData]);
+        await User.createMany([userData, userData]);
 
         const value = await User.selectStringAgg('name', ', ').take();
 

package/src/queryMethods/aggregate.ts

@@ -195,7 +195,7 @@ export class Aggregate {
     this: T,
     arg?: AT1<T>['count'] | '*',
     options?: AggregateOptions<T>,
-  ): SetQueryReturnsValue<T, NumberColumn> {
+  ): SetQueryReturnsValue<T, NumberColumn> & { isCount: true } {
     return this.clone()._count(arg, options);
   }
 
@@ -203,8 +203,10 @@ export class Aggregate {
     this: T,
     arg: AT1<T>['count'] | '*' = '*',
     options?: AggregateOptions<T>,
-  ): SetQueryReturnsValue<T, NumberColumn> {
-    return get<T, NumberColumn>(this._selectCount(arg, options));
+  ): SetQueryReturnsValue<T, NumberColumn> & { isCount: true } {
+    return get<T, NumberColumn>(
+      this._selectCount(arg, options),
+    ) as unknown as SetQueryReturnsValue<T, NumberColumn> & { isCount: true };
   }
 
   selectCount<T extends Query, As extends string | undefined = undefined>(

package/src/queryMethods/callbacks.test.ts

@@ -23,20 +23,20 @@ describe('callbacks', () => {
     });
   });
 
-  describe('beforeInsert', () => {
-    it('should run callback before insert', async () => {
+  describe('beforeCreate', () => {
+    it('should run callback before create', async () => {
       const fn = jest.fn();
-      const query = User.beforeInsert(fn).insert(userData);
+      const query = User.beforeCreate(fn).create(userData);
       await query;
 
       expect(fn.mock.calls[0]).toEqual([query]);
     });
   });
 
-  describe('afterInsert', () => {
-    it('should run callback after insert', async () => {
+  describe('afterCreate', () => {
+    it('should run callback after create', async () => {
       const fn = jest.fn();
-      const query = User.afterInsert(fn).select('id').insert(userData);
+      const query = User.afterCreate(fn).select('id').create(userData);
       const result = await query;
 
       expect(fn.mock.calls[0]).toEqual([query, result]);

package/src/queryMethods/callbacks.ts

@@ -25,18 +25,18 @@ export class QueryCallbacks {
     return pushQueryValue(this, 'afterQuery', cb);
   }
 
-  beforeInsert<T extends Query>(this: T, cb: BeforeCallback<T>): T {
-    return this.clone()._beforeInsert(cb);
+  beforeCreate<T extends Query>(this: T, cb: BeforeCallback<T>): T {
+    return this.clone()._beforeCreate(cb);
   }
-  _beforeInsert<T extends Query>(this: T, cb: BeforeCallback<T>): T {
-    return pushQueryValue(this, 'beforeInsert', cb);
+  _beforeCreate<T extends Query>(this: T, cb: BeforeCallback<T>): T {
+    return pushQueryValue(this, 'beforeCreate', cb);
   }
 
-  afterInsert<T extends Query>(this: T, cb: AfterCallback<T>): T {
-    return this.clone()._afterInsert(cb);
+  afterCreate<T extends Query>(this: T, cb: AfterCallback<T>): T {
+    return this.clone()._afterCreate(cb);
   }
-  _afterInsert<T extends Query>(this: T, cb: AfterCallback<T>): T {
-    return pushQueryValue(this, 'afterInsert', cb);
+  _afterCreate<T extends Query>(this: T, cb: AfterCallback<T>): T {
+    return pushQueryValue(this, 'afterCreate', cb);
   }
 
   beforeUpdate<T extends Query>(this: T, cb: BeforeCallback<T>): T {

package/src/queryMethods/columnInfo.ts

@@ -1,5 +1,4 @@
 import { Query, SetQueryReturnsColumnInfo } from '../query';
-import { ThenResult, Then } from './then';
 import { ColumnInfoQueryData } from '../sql';
 
 export type ColumnInfo = {
@@ -44,24 +43,19 @@ export class ColumnInfoMethods {
       (this.query as ColumnInfoQueryData).column = column as string;
     }
 
-    this.then = function (this: Query, resolve, reject) {
-      new Then().then.call(
-        this,
-        (rows) => {
-          if (column) {
-            resolve?.(rowToColumnInfo(rows[0]));
-          } else {
-            const info: Record<string, ColumnInfo> = {};
-            (rows as unknown[]).forEach((row) => {
-              info[(row as { column_name: string }).column_name] =
-                rowToColumnInfo(row);
-            });
-            resolve?.(info);
-          }
-        },
-        reject,
-      );
-    } as ThenResult<unknown>;
+    this.query.handleResult = async (_, result) => {
+      if (column) {
+        return rowToColumnInfo(result.rows[0]);
+      } else {
+        const info: Record<string, ColumnInfo> = {};
+        result.rows.forEach((row) => {
+          info[(row as { column_name: string }).column_name] =
+            rowToColumnInfo(row);
+        });
+        return info;
+      }
+    };
+
     return this as unknown as SetQueryReturnsColumnInfo<T, Column>;
   }
 }