pqb 0.2.0 → 0.2.2

package/package.json

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

package/src/columnSchema/columnType.ts

@@ -123,6 +123,7 @@ export abstract class ColumnType<
   isPrimaryKey = false;
   isHidden = false;
   isNullable = false;
+  hasDefault = false;
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   encodeFn?: (input: any) => unknown;
@@ -212,7 +213,10 @@ export abstract class ColumnType<
     return this.dataType;
   }
 
-  default<T extends ColumnType>(this: T, value: T['type'] | RawExpression): T {
+  default<T extends ColumnType>(
+    this: T,
+    value: T['type'] | RawExpression,
+  ): T & { hasDefault: true } {
     const cloned = Object.create(this);
     cloned.data = { ...cloned.data, default: value };
     return cloned;
@@ -221,7 +225,7 @@ export abstract class ColumnType<
   index<T extends ColumnType>(
     this: T,
     options: Omit<SingleColumnIndexOptions, 'column'> = {},
-  ) {
+  ): T {
     const cloned = Object.create(this);
     cloned.data = { ...cloned.data, index: options };
     return cloned;

package/src/columnSchema/columnTypes.ts

@@ -179,7 +179,10 @@ export const columnTypes = {
 
   timestamps<T extends ColumnType>(this: {
     timestamp(): T;
-  }): { createdAt: T; updatedAt: T } {
+  }): {
+    createdAt: T & { hasDefault: true };
+    updatedAt: T & { hasDefault: true };
+  } {
     return {
       createdAt: this.timestamp().default(raw('now()')),
       updatedAt: this.timestamp().default(raw('now()')),

package/src/db.ts

@@ -71,7 +71,12 @@ export interface Db<
   withData: Query['withData'];
   joinedTables: Query['joinedTables'];
   relations: Relations;
-  [defaultsKey]: Query[defaultsKey];
+  [defaultsKey]: Record<
+    {
+      [K in keyof Shape]: Shape[K]['hasDefault'] extends true ? K : never;
+    }[keyof Shape],
+    true
+  >;
 }
 
 export class Db<

package/src/query.ts

@@ -70,7 +70,8 @@ export type Query = QueryMethods & {
   columnsParsers?: ColumnsParsers;
   relations: RelationsBase;
   withData: WithDataBase;
-  [defaultsKey]?: string;
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  [defaultsKey]: {};
 };
 
 export type Selectable<T extends QueryBase> = StringKey<keyof T['selectable']>;

package/src/queryMethods/insert.test.ts

@@ -1,9 +1,7 @@
 import {
   AssertEqual,
-  expectMatchObjectWithTimestamps,
   expectQueryNotMutated,
   expectSql,
-  now,
   User,
   userData,
   useTestDatabase,
@@ -42,10 +40,10 @@ describe('insert', () => {
     expectSql(
       query.toSql(),
       `
-        INSERT INTO "user"("name", "password", "createdAt", "updatedAt")
-        VALUES ($1, $2, $3, $4)
+        INSERT INTO "user"("name", "password")
+        VALUES ($1, $2)
       `,
-      ['name', 'password', now, now],
+      ['name', 'password'],
     );
 
     const result = await query;
@@ -55,7 +53,7 @@ describe('insert', () => {
     expect(eq).toBe(true);
 
     const inserted = await User.take();
-    expectMatchObjectWithTimestamps(inserted, userData);
+    expect(inserted).toMatchObject(userData);
 
     expectQueryNotMutated(q);
   });
@@ -67,11 +65,11 @@ describe('insert', () => {
     expectSql(
       query.toSql(),
       `
-        INSERT INTO "user"("name", "password", "createdAt", "updatedAt")
-        VALUES ($1, $2, $3, $4)
+        INSERT INTO "user"("name", "password")
+        VALUES ($1, $2)
         RETURNING "user"."id"
       `,
-      ['name', 'password', now, now],
+      ['name', 'password'],
     );
 
     const result = await query;
@@ -86,29 +84,24 @@ describe('insert', () => {
   it('should insert one record, returning columns', async () => {
     const q = User.all();
 
-    const query = q
-      .select('id', 'name', 'createdAt', 'updatedAt')
-      .insert(userData);
+    const query = q.select('id', 'name').insert(userData);
     expectSql(
       query.toSql(),
       `
-        INSERT INTO "user"("name", "password", "createdAt", "updatedAt")
-        VALUES ($1, $2, $3, $4)
-        RETURNING "user"."id", "user"."name", "user"."createdAt", "user"."updatedAt"
+        INSERT INTO "user"("name", "password")
+        VALUES ($1, $2)
+        RETURNING "user"."id", "user"."name"
       `,
-      ['name', 'password', now, now],
+      ['name', 'password'],
     );
 
     const result = await query;
-    const eq: AssertEqual<
-      typeof result,
-      { id: number; name: string; createdAt: Date; updatedAt: Date }
-    > = true;
+    const eq: AssertEqual<typeof result, { id: number; name: string }> = true;
     expect(eq).toBe(true);
 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const { password, ...other } = userData;
-    expectMatchObjectWithTimestamps(result, other);
+    expect(result).toMatchObject(other);
 
     expectQueryNotMutated(q);
   });
@@ -120,11 +113,11 @@ describe('insert', () => {
     expectSql(
       query.toSql(),
       `
-        INSERT INTO "user"("name", "password", "createdAt", "updatedAt")
-        VALUES ($1, $2, $3, $4)
+        INSERT INTO "user"("name", "password")
+        VALUES ($1, $2)
         RETURNING *
       `,
-      ['name', 'password', now, now],
+      ['name', 'password'],
     );
 
     const result = await query;
@@ -133,7 +126,7 @@ describe('insert', () => {
 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const { password, ...other } = userData;
-    expectMatchObjectWithTimestamps(result, other);
+    expect(result).toMatchObject(other);
 
     expectQueryNotMutated(q);
   });
@@ -154,12 +147,12 @@ describe('insert', () => {
     expectSql(
       query.toSql(),
       `
-        INSERT INTO "user"("name", "password", "createdAt", "updatedAt", "picture")
+        INSERT INTO "user"("name", "password", "picture")
         VALUES
-          ($1, $2, $3, $4, $5),
-          ($6, $7, $8, $9, DEFAULT)
+          ($1, $2, $3),
+          ($4, $5, DEFAULT)
       `,
-      ['name', 'password', now, now, null, 'name', 'password', now, now],
+      ['name', 'password', null, 'name', 'password'],
     );
 
     const result = await query;
@@ -170,7 +163,7 @@ describe('insert', () => {
 
     const inserted = await User.all();
     inserted.forEach((item, i) => {
-      expectMatchObjectWithTimestamps(item, arr[i]);
+      expect(item).toMatchObject(arr[i]);
     });
 
     expectQueryNotMutated(q);
@@ -187,30 +180,27 @@ describe('insert', () => {
       userData,
     ];
 
-    const query = q.select('id', 'name', 'createdAt', 'updatedAt').insert(arr);
+    const query = q.select('id', 'name').insert(arr);
 
     expectSql(
       query.toSql(),
       `
-        INSERT INTO "user"("name", "password", "createdAt", "updatedAt", "picture")
+        INSERT INTO "user"("name", "password", "picture")
         VALUES
-          ($1, $2, $3, $4, $5),
-          ($6, $7, $8, $9, DEFAULT)
-        RETURNING "user"."id", "user"."name", "user"."createdAt", "user"."updatedAt"
+          ($1, $2, $3),
+          ($4, $5, DEFAULT)
+        RETURNING "user"."id", "user"."name"
       `,
-      ['name', 'password', now, now, null, 'name', 'password', now, now],
+      ['name', 'password', null, 'name', 'password'],
     );
 
     const result = await query;
-    const eq: AssertEqual<
-      typeof result,
-      { id: number; name: string; createdAt: Date; updatedAt: Date }[]
-    > = true;
+    const eq: AssertEqual<typeof result, { id: number; name: string }[]> = true;
     expect(eq).toBe(true);
 
     const inserted = await User.all();
     inserted.forEach((item, i) => {
-      expectMatchObjectWithTimestamps(item, arr[i]);
+      expect(item).toMatchObject(arr[i]);
     });
 
     expectQueryNotMutated(q);
@@ -232,18 +222,18 @@ describe('insert', () => {
     expectSql(
       query.toSql(),
       `
-        INSERT INTO "user"("name", "password", "createdAt", "updatedAt", "picture")
+        INSERT INTO "user"("name", "password", "picture")
         VALUES
-          ($1, $2, $3, $4, $5),
-          ($6, $7, $8, $9, DEFAULT)
+          ($1, $2, $3),
+          ($4, $5, DEFAULT)
         RETURNING *
       `,
-      ['name', 'password', now, now, null, 'name', 'password', now, now],
+      ['name', 'password', null, 'name', 'password'],
     );
 
     const result = await query;
     result.forEach((item, i) => {
-      expectMatchObjectWithTimestamps(item, arr[i]);
+      expect(item).toMatchObject(arr[i]);
     });
 
     const eq: AssertEqual<typeof result, typeof User['type'][]> = true;
@@ -251,7 +241,7 @@ describe('insert', () => {
 
     const inserted = await User.all();
     inserted.forEach((item, i) => {
-      expectMatchObjectWithTimestamps(item, arr[i]);
+      expect(item).toMatchObject(arr[i]);
     });
 
     expectQueryNotMutated(q);
@@ -263,17 +253,15 @@ describe('insert', () => {
       password: 'password',
     }).insert({
       password: 'override',
-      updatedAt: now,
-      createdAt: now,
     });
 
     expectSql(
       query.toSql(),
       `
-        INSERT INTO "user"("name", "password", "updatedAt", "createdAt")
-        VALUES ($1, $2, $3, $4)
+        INSERT INTO "user"("name", "password")
+        VALUES ($1, $2)
       `,
-      ['name', 'override', now, now],
+      ['name', 'override'],
     );
   });
 
@@ -309,14 +297,14 @@ describe('insert', () => {
       expectSql(
         query.toSql(),
         `
-            INSERT INTO "user"("name", "password", "createdAt", "updatedAt")
-            VALUES ($1, $2, $3, $4)
+            INSERT INTO "user"("name", "password")
+            VALUES ($1, $2)
             ON CONFLICT ("name")
             DO NOTHING
-            WHERE "user"."name" = $5
+            WHERE "user"."name" = $3
             RETURNING "user"."id"
           `,
-        ['name', 'password', now, now, 'where name'],
+        ['name', 'password', 'where name'],
       );
 
       expectQueryNotMutated(q);
@@ -330,12 +318,12 @@ describe('insert', () => {
         expectSql(
           query.toSql(),
           `
-            INSERT INTO "user"("name", "password", "createdAt", "updatedAt")
-            VALUES ($1, $2, $3, $4)
-            ON CONFLICT ("name", "password", "createdAt", "updatedAt")
+            INSERT INTO "user"("name", "password")
+            VALUES ($1, $2)
+            ON CONFLICT ("name", "password")
             DO NOTHING
           `,
-          ['name', 'password', now, now],
+          ['name', 'password'],
         );
 
         expectQueryNotMutated(q);
@@ -348,11 +336,11 @@ describe('insert', () => {
         expectSql(
           query.toSql(),
           `
-            INSERT INTO "user"("name", "password", "createdAt", "updatedAt")
-            VALUES ($1, $2, $3, $4)
+            INSERT INTO "user"("name", "password")
+            VALUES ($1, $2)
             ON CONFLICT ("id") DO NOTHING
           `,
-          ['name', 'password', now, now],
+          ['name', 'password'],
         );
 
         expectQueryNotMutated(q);
@@ -365,11 +353,11 @@ describe('insert', () => {
         expectSql(
           query.toSql(),
           `
-            INSERT INTO "user"("name", "password", "createdAt", "updatedAt")
-            VALUES ($1, $2, $3, $4)
+            INSERT INTO "user"("name", "password")
+            VALUES ($1, $2)
             ON CONFLICT ("id", "name") DO NOTHING
           `,
-          ['name', 'password', now, now],
+          ['name', 'password'],
         );
 
         expectQueryNotMutated(q);
@@ -382,11 +370,11 @@ describe('insert', () => {
         expectSql(
           query.toSql(),
           `
-            INSERT INTO "user"("name", "password", "createdAt", "updatedAt")
-            VALUES ($1, $2, $3, $4)
+            INSERT INTO "user"("name", "password")
+            VALUES ($1, $2)
             ON CONFLICT raw query DO NOTHING
           `,
-          ['name', 'password', now, now],
+          ['name', 'password'],
         );
 
         expectQueryNotMutated(q);
@@ -401,16 +389,14 @@ describe('insert', () => {
         expectSql(
           query.toSql(),
           `
-            INSERT INTO "user"("name", "password", "createdAt", "updatedAt")
-            VALUES ($1, $2, $3, $4)
-            ON CONFLICT ("name", "password", "createdAt", "updatedAt")
+            INSERT INTO "user"("name", "password")
+            VALUES ($1, $2)
+            ON CONFLICT ("name", "password")
             DO UPDATE SET
               "name" = excluded."name",
-              "password" = excluded."password",
-              "createdAt" = excluded."createdAt",
-              "updatedAt" = excluded."updatedAt"
+              "password" = excluded."password"
           `,
-          ['name', 'password', now, now],
+          ['name', 'password'],
         );
 
         expectQueryNotMutated(q);
@@ -423,12 +409,12 @@ describe('insert', () => {
         expectSql(
           query.toSql(),
           `
-            INSERT INTO "user"("name", "password", "createdAt", "updatedAt")
-            VALUES ($1, $2, $3, $4)
+            INSERT INTO "user"("name", "password")
+            VALUES ($1, $2)
             ON CONFLICT ("name")
             DO UPDATE SET "name" = excluded."name"
           `,
-          ['name', 'password', now, now],
+          ['name', 'password'],
         );
 
         expectQueryNotMutated(q);
@@ -445,14 +431,14 @@ describe('insert', () => {
         expectSql(
           query.toSql(),
           `
-            INSERT INTO "user"("name", "password", "createdAt", "updatedAt")
-            VALUES ($1, $2, $3, $4)
+            INSERT INTO "user"("name", "password")
+            VALUES ($1, $2)
             ON CONFLICT ("name", "password")
             DO UPDATE SET
               "name" = excluded."name",
               "password" = excluded."password"
           `,
-          ['name', 'password', now, now],
+          ['name', 'password'],
         );
 
         expectQueryNotMutated(q);
@@ -469,12 +455,12 @@ describe('insert', () => {
         expectSql(
           query.toSql(),
           `
-            INSERT INTO "user"("name", "password", "createdAt", "updatedAt")
-            VALUES ($1, $2, $3, $4)
+            INSERT INTO "user"("name", "password")
+            VALUES ($1, $2)
             ON CONFLICT ("name")
-            DO UPDATE SET "name" = $5
+            DO UPDATE SET "name" = $3
           `,
-          ['name', 'password', now, now, 'new name'],
+          ['name', 'password', 'new name'],
         );
 
         expectQueryNotMutated(q);
@@ -491,12 +477,12 @@ describe('insert', () => {
         expectSql(
           query.toSql(),
           `
-            INSERT INTO "user"("name", "password", "createdAt", "updatedAt")
-            VALUES ($1, $2, $3, $4)
+            INSERT INTO "user"("name", "password")
+            VALUES ($1, $2)
             ON CONFLICT on conflict raw
             DO UPDATE SET merge raw
           `,
-          ['name', 'password', now, now],
+          ['name', 'password'],
         );
 
         expectQueryNotMutated(q);
@@ -507,7 +493,7 @@ describe('insert', () => {
   describe('create', () => {
     it('should return full record', async () => {
       const result = await User.create(userData);
-      expectMatchObjectWithTimestamps(result, userData);
+      expect(result).toMatchObject(userData);
 
       const eq: AssertEqual<typeof result, typeof User.type> = true;
       expect(eq).toBe(true);
@@ -526,8 +512,8 @@ describe('insert', () => {
 
     it('should return full records when creating many', async () => {
       const result = await User.create([userData, userData]);
-      expectMatchObjectWithTimestamps(result[0], userData);
-      expectMatchObjectWithTimestamps(result[1], userData);
+      expect(result[0]).toMatchObject(userData);
+      expect(result[1]).toMatchObject(userData);
 
       const eq: AssertEqual<typeof result, typeof User.type[]> = true;
       expect(eq).toBe(true);

package/src/queryMethods/insert.ts

@@ -31,9 +31,7 @@ export type OptionalKeys<T extends Query> = {
 
 export type InsertData<
   T extends Query,
-  DefaultKeys extends string = T[defaultsKey] extends string
-    ? T[defaultsKey]
-    : never,
+  DefaultKeys extends PropertyKey = keyof T[defaultsKey],
   Data = SetOptional<SetOptional<T['inputType'], OptionalKeys<T>>, DefaultKeys>,
 > = [keyof T['relations']] extends [never]
   ? Data
@@ -397,15 +395,17 @@ export class Insert {
   defaults<T extends Query, Data extends Partial<InsertData<T>>>(
     this: T,
     data: Data,
-  ): T & { [defaultsKey]: keyof Data } {
+  ): T & {
+    [defaultsKey]: Record<keyof Data, true>;
+  } {
     return (this.clone() as T)._defaults(data);
   }
   _defaults<T extends Query, Data extends Partial<InsertData<T>>>(
     this: T,
     data: Data,
-  ): T & { [defaultsKey]: keyof Data } {
+  ): T & { [defaultsKey]: Record<keyof Data, true> } {
     this.query.defaults = data;
-    return this as T & { [defaultsKey]: keyof Data };
+    return this as T & { [defaultsKey]: Record<keyof Data, true> };
   }
 
   onConflict<T extends Query, Arg extends OnConflictArg<T>>(

package/src/queryMethods/queryMethods.test.ts

@@ -133,7 +133,7 @@ describe('queryMethods', () => {
   describe('pluck', () => {
     beforeEach(async () => {
       for (let i = 0; i < 3; i++) {
-        await User.insert(userData);
+        await User.insert({ ...userData, createdAt: now });
       }
     });
 

package/src/queryMethods/select.test.ts

@@ -274,6 +274,8 @@ describe('selectMethods', () => {
           authorId,
           chatId,
           ...messageData,
+          createdAt: now,
+          updatedAt: now,
         });
 
         const [record] = await User.select('id', {

package/src/queryMethods/update.test.ts

@@ -1,6 +1,5 @@
 import {
   AssertEqual,
-  expectMatchObjectWithTimestamps,
   expectQueryNotMutated,
   expectSql,
   User,
@@ -83,7 +82,7 @@ describe('update', () => {
     expect(result).toBe(1);
 
     const updated = await User.take();
-    expectMatchObjectWithTimestamps(updated, { ...userData, ...update });
+    expect(updated).toMatchObject({ ...userData, ...update });
   });
 
   it('should update record, returning value', async () => {
@@ -114,7 +113,7 @@ describe('update', () => {
     expect(typeof result).toBe('number');
 
     const updated = await User.take();
-    expectMatchObjectWithTimestamps(updated, { ...userData, ...update });
+    expect(updated).toMatchObject({ ...userData, ...update });
   });
 
   it('should update one record, return selected columns', async () => {
@@ -139,7 +138,7 @@ describe('update', () => {
     expect(eq).toBe(true);
 
     const updated = await User.take();
-    expectMatchObjectWithTimestamps(updated, { ...userData, ...update });
+    expect(updated).toMatchObject({ ...userData, ...update });
   });
 
   it('should update one record, return all columns', async () => {
@@ -164,7 +163,7 @@ describe('update', () => {
     expect(eq).toBe(true);
 
     const updated = await User.take();
-    expectMatchObjectWithTimestamps(updated, { ...userData, ...update });
+    expect(updated).toMatchObject({ ...userData, ...update });
   });
 
   it('should update multiple records, returning selected columns', async () => {
@@ -196,7 +195,7 @@ describe('update', () => {
     expect(eq).toBe(true);
 
     const updated = await User.take();
-    expectMatchObjectWithTimestamps(updated, { ...userData, ...update });
+    expect(updated).toMatchObject({ ...userData, ...update });
   });
 
   it('should update multiple records, returning all columns', async () => {
@@ -224,13 +223,13 @@ describe('update', () => {
     );
 
     const result = await query;
-    expectMatchObjectWithTimestamps(result[0], { ...userData, ...update });
+    expect(result[0]).toMatchObject({ ...userData, ...update });
 
     const eq: AssertEqual<typeof result, typeof User['type'][]> = true;
     expect(eq).toBe(true);
 
     const updated = await User.take();
-    expectMatchObjectWithTimestamps(updated, { ...userData, ...update });
+    expect(updated).toMatchObject({ ...userData, ...update });
   });
 
   it('should ignore undefined values, and should not ignore null', () => {
@@ -297,7 +296,7 @@ describe('update', () => {
     const eq: AssertEqual<typeof result, typeof User.type> = true;
     expect(eq).toBe(true);
 
-    expectMatchObjectWithTimestamps(result, { ...userData, ...update });
+    expect(result).toMatchObject({ ...userData, ...update });
   });
 
   it('should throw when searching for one to update and it is not found', async () => {

package/src/queryMethods/upsert.ts

@@ -29,7 +29,7 @@ export class QueryUpsert {
     const { handleResult } = this.query;
     this.query.handleResult = async (q, queryResult) => {
       if (queryResult.rowCount === 0) {
-        return q.insert(data.create);
+        return (q as Query).insert(data.create as InsertData<Query>);
       } else if (queryResult.rowCount > 1) {
         throw new MoreThanOneRowError(
           `Only one row was expected to find for upsert, found ${queryResult.rowCount} rows.`,