pqb 0.2.2 → 0.2.3

package/package.json

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

package/src/columnSchema/columnsSchema.ts

@@ -1,6 +1,6 @@
 import { ColumnInput, ColumnOutput, ColumnType } from './columnType';
 import { Operators } from '../columnsOperators';
-import { UnionToIntersection } from '../utils';
+import { SetOptional, SomeIsTrue, UnionToIntersection } from '../utils';
 
 export type ColumnsShape = Record<string, ColumnType>;
 
@@ -8,9 +8,20 @@ export type ColumnShapeOutput<Shape extends ColumnsShape> = {
   [K in keyof Shape]: ColumnOutput<Shape[K]>;
 };
 
-export type ColumnShapeInput<Shape extends ColumnsShape> = {
-  [K in keyof Shape]: ColumnInput<Shape[K]>;
-};
+type OptionalColumnsForInput<Shape extends ColumnsShape> = {
+  [K in keyof Shape]: SomeIsTrue<
+    [Shape[K]['isNullable'], Shape[K]['hasDefault']]
+  > extends true
+    ? K
+    : never;
+}[keyof Shape];
+
+export type ColumnShapeInput<Shape extends ColumnsShape> = SetOptional<
+  {
+    [K in keyof Shape]: ColumnInput<Shape[K]>;
+  },
+  OptionalColumnsForInput<Shape>
+>;
 
 export class ColumnsObject<Shape extends ColumnsShape> extends ColumnType<
   { [K in keyof Shape]: Shape[K]['type'] },

package/src/columnSchema/number.ts

@@ -119,15 +119,18 @@ export class DoublePrecisionColumn extends NumberAsStringBaseColumn {
 export class SmallSerialColumn extends IntegerBaseColumn {
   dataType = 'smallserial' as const;
   parseItem = parseInt;
+  hasDefault = true as const;
 }
 
 // autoincrementing four-byte integer
 export class SerialColumn extends IntegerBaseColumn {
   dataType = 'serial' as const;
   parseItem = parseInt;
+  hasDefault = true as const;
 }
 
 // autoincrementing eight-byte integer
 export class BigSerialColumn extends NumberAsStringBaseColumn {
   dataType = 'bigserial' as const;
+  hasDefault = true as const;
 }

package/src/queryMethods/aggregate.test.ts

@@ -504,7 +504,7 @@ describe('aggregate', () => {
     });
 
     it('should return json object when have records', async () => {
-      await User.insert([userData, userData]);
+      await User.insertMany([userData, userData]);
 
       const value = await User.stringAgg('name', ', ');
 
@@ -526,7 +526,7 @@ describe('aggregate', () => {
       });
 
       it('should return json object when have records', async () => {
-        await User.insert([userData, userData]);
+        await User.insertMany([userData, userData]);
 
         const value = await User.selectStringAgg('name', ', ').take();
 

package/src/queryMethods/insert.test.ts

@@ -9,260 +9,267 @@ import {
 import { raw } from '../common';
 import { OnConflictQueryBuilder } from './insert';
 
-describe('insert', () => {
+describe('insert functions', () => {
   useTestDatabase();
 
-  it('should insert with raw sql and list of columns', () => {
-    const q = User.all();
+  describe('insertRaw', () => {
+    it('should insert with raw sql and list of columns', () => {
+      const q = User.all();
 
-    const query = q.insert({
-      columns: ['name', 'password'],
-      values: raw('raw sql'),
-    });
-    expectSql(
-      query.toSql(),
-      `
+      const query = q.insertRaw({
+        columns: ['name', 'password'],
+        values: raw('raw sql'),
+      });
+      expectSql(
+        query.toSql(),
+        `
         INSERT INTO "user"("name", "password")
         VALUES raw sql
       `,
-    );
+      );
 
-    const eq: AssertEqual<Awaited<typeof query>, number> = true;
-    expect(eq).toBe(true);
+      const eq: AssertEqual<Awaited<typeof query>, number> = true;
+      expect(eq).toBe(true);
 
-    expectQueryNotMutated(q);
+      expectQueryNotMutated(q);
+    });
   });
 
-  it('should insert one record, returning rows count', async () => {
-    const q = User.all();
+  describe('insert', () => {
+    it('should insert one record, returning rows count', async () => {
+      const q = User.all();
 
-    const query = q.insert(userData);
-    expectSql(
-      query.toSql(),
-      `
+      const query = q.insert(userData);
+      expectSql(
+        query.toSql(),
+        `
         INSERT INTO "user"("name", "password")
         VALUES ($1, $2)
       `,
-      ['name', 'password'],
-    );
+        ['name', 'password'],
+      );
 
-    const result = await query;
-    expect(result).toBe(1);
+      const result = await query;
+      expect(result).toBe(1);
 
-    const eq: AssertEqual<typeof result, number> = true;
-    expect(eq).toBe(true);
+      const eq: AssertEqual<typeof result, number> = true;
+      expect(eq).toBe(true);
 
-    const inserted = await User.take();
-    expect(inserted).toMatchObject(userData);
+      const inserted = await User.take();
+      expect(inserted).toMatchObject(userData);
 
-    expectQueryNotMutated(q);
-  });
+      expectQueryNotMutated(q);
+    });
 
-  it('should insert one record, returning value', async () => {
-    const q = User.all();
+    it('should insert one record, returning value', async () => {
+      const q = User.all();
 
-    const query = q.get('id').insert(userData);
-    expectSql(
-      query.toSql(),
-      `
+      const query = q.get('id').insert(userData);
+      expectSql(
+        query.toSql(),
+        `
         INSERT INTO "user"("name", "password")
         VALUES ($1, $2)
         RETURNING "user"."id"
       `,
-      ['name', 'password'],
-    );
+        ['name', 'password'],
+      );
 
-    const result = await query;
-    const eq: AssertEqual<typeof result, number> = true;
-    expect(eq).toBe(true);
+      const result = await query;
+      const eq: AssertEqual<typeof result, number> = true;
+      expect(eq).toBe(true);
 
-    expect(typeof result).toBe('number');
+      expect(typeof result).toBe('number');
 
-    expectQueryNotMutated(q);
-  });
+      expectQueryNotMutated(q);
+    });
 
-  it('should insert one record, returning columns', async () => {
-    const q = User.all();
+    it('should insert one record, returning columns', async () => {
+      const q = User.all();
 
-    const query = q.select('id', 'name').insert(userData);
-    expectSql(
-      query.toSql(),
-      `
+      const query = q.select('id', 'name').insert(userData);
+      expectSql(
+        query.toSql(),
+        `
         INSERT INTO "user"("name", "password")
         VALUES ($1, $2)
         RETURNING "user"."id", "user"."name"
       `,
-      ['name', 'password'],
-    );
+        ['name', 'password'],
+      );
 
-    const result = await query;
-    const eq: AssertEqual<typeof result, { id: number; name: string }> = true;
-    expect(eq).toBe(true);
+      const result = await query;
+      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;
-    expect(result).toMatchObject(other);
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { password, ...other } = userData;
+      expect(result).toMatchObject(other);
 
-    expectQueryNotMutated(q);
-  });
+      expectQueryNotMutated(q);
+    });
 
-  it('should insert one record, returning all columns', async () => {
-    const q = User.all();
+    it('should insert one record, returning all columns', async () => {
+      const q = User.all();
 
-    const query = q.selectAll().insert(userData);
-    expectSql(
-      query.toSql(),
-      `
+      const query = q.selectAll().insert(userData);
+      expectSql(
+        query.toSql(),
+        `
         INSERT INTO "user"("name", "password")
         VALUES ($1, $2)
         RETURNING *
       `,
-      ['name', 'password'],
-    );
+        ['name', 'password'],
+      );
 
-    const result = await query;
-    const eq: AssertEqual<typeof result, typeof User['type']> = true;
-    expect(eq).toBe(true);
+      const result = await query;
+      const eq: AssertEqual<typeof result, typeof User['type']> = true;
+      expect(eq).toBe(true);
 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const { password, ...other } = userData;
-    expect(result).toMatchObject(other);
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { password, ...other } = userData;
+      expect(result).toMatchObject(other);
 
-    expectQueryNotMutated(q);
+      expectQueryNotMutated(q);
+    });
+
+    it('should insert record with provided defaults', () => {
+      const query = User.defaults({
+        name: 'name',
+        password: 'password',
+      }).insert({
+        password: 'override',
+      });
+
+      expectSql(
+        query.toSql(),
+        `
+        INSERT INTO "user"("name", "password")
+        VALUES ($1, $2)
+      `,
+        ['name', 'override'],
+      );
+    });
   });
 
-  it('should insert many records, returning void', async () => {
-    const q = User.all();
+  describe('insertMany', () => {
+    it('should insert many records, returning void', async () => {
+      const q = User.all();
 
-    const arr = [
-      {
-        ...userData,
-        picture: null,
-      },
-      userData,
-    ];
+      const arr = [
+        {
+          ...userData,
+          picture: null,
+        },
+        userData,
+      ];
 
-    const query = q.insert(arr);
+      const query = q.insertMany(arr);
 
-    expectSql(
-      query.toSql(),
-      `
+      expectSql(
+        query.toSql(),
+        `
         INSERT INTO "user"("name", "password", "picture")
         VALUES
           ($1, $2, $3),
           ($4, $5, DEFAULT)
       `,
-      ['name', 'password', null, 'name', 'password'],
-    );
+        ['name', 'password', null, 'name', 'password'],
+      );
 
-    const result = await query;
-    expect(result).toBe(2);
+      const result = await query;
+      expect(result).toBe(2);
 
-    const eq: AssertEqual<typeof result, number> = true;
-    expect(eq).toBe(true);
+      const eq: AssertEqual<typeof result, number> = true;
+      expect(eq).toBe(true);
 
-    const inserted = await User.all();
-    inserted.forEach((item, i) => {
-      expect(item).toMatchObject(arr[i]);
-    });
+      const inserted = await User.all();
+      inserted.forEach((item, i) => {
+        expect(item).toMatchObject(arr[i]);
+      });
 
-    expectQueryNotMutated(q);
-  });
+      expectQueryNotMutated(q);
+    });
 
-  it('should insert many records, returning columns', async () => {
-    const q = User.all();
+    it('should insert many records, returning columns', async () => {
+      const q = User.all();
 
-    const arr = [
-      {
-        ...userData,
-        picture: null,
-      },
-      userData,
-    ];
+      const arr = [
+        {
+          ...userData,
+          picture: null,
+        },
+        userData,
+      ];
 
-    const query = q.select('id', 'name').insert(arr);
+      const query = q.select('id', 'name').insertMany(arr);
 
-    expectSql(
-      query.toSql(),
-      `
+      expectSql(
+        query.toSql(),
+        `
         INSERT INTO "user"("name", "password", "picture")
         VALUES
           ($1, $2, $3),
           ($4, $5, DEFAULT)
         RETURNING "user"."id", "user"."name"
       `,
-      ['name', 'password', null, 'name', 'password'],
-    );
+        ['name', 'password', null, 'name', 'password'],
+      );
 
-    const result = await query;
-    const eq: AssertEqual<typeof result, { id: number; name: string }[]> = true;
-    expect(eq).toBe(true);
+      const result = await query;
+      const eq: AssertEqual<typeof result, { id: number; name: string }[]> =
+        true;
+      expect(eq).toBe(true);
 
-    const inserted = await User.all();
-    inserted.forEach((item, i) => {
-      expect(item).toMatchObject(arr[i]);
-    });
+      const inserted = await User.all();
+      inserted.forEach((item, i) => {
+        expect(item).toMatchObject(arr[i]);
+      });
 
-    expectQueryNotMutated(q);
-  });
+      expectQueryNotMutated(q);
+    });
 
-  it('should insert many records, returning all columns', async () => {
-    const q = User.all();
+    it('should insert many records, returning all columns', async () => {
+      const q = User.all();
 
-    const arr = [
-      {
-        ...userData,
-        picture: null,
-      },
-      userData,
-    ];
+      const arr = [
+        {
+          ...userData,
+          picture: null,
+        },
+        userData,
+      ];
 
-    const query = q.selectAll().insert(arr);
+      const query = q.selectAll().insertMany(arr);
 
-    expectSql(
-      query.toSql(),
-      `
+      expectSql(
+        query.toSql(),
+        `
         INSERT INTO "user"("name", "password", "picture")
         VALUES
           ($1, $2, $3),
           ($4, $5, DEFAULT)
         RETURNING *
       `,
-      ['name', 'password', null, 'name', 'password'],
-    );
-
-    const result = await query;
-    result.forEach((item, i) => {
-      expect(item).toMatchObject(arr[i]);
-    });
+        ['name', 'password', null, 'name', 'password'],
+      );
 
-    const eq: AssertEqual<typeof result, typeof User['type'][]> = true;
-    expect(eq).toBe(true);
+      const result = await query;
+      result.forEach((item, i) => {
+        expect(item).toMatchObject(arr[i]);
+      });
 
-    const inserted = await User.all();
-    inserted.forEach((item, i) => {
-      expect(item).toMatchObject(arr[i]);
-    });
+      const eq: AssertEqual<typeof result, typeof User['type'][]> = true;
+      expect(eq).toBe(true);
 
-    expectQueryNotMutated(q);
-  });
+      const inserted = await User.all();
+      inserted.forEach((item, i) => {
+        expect(item).toMatchObject(arr[i]);
+      });
 
-  it('should insert record with provided defaults', () => {
-    const query = User.defaults({
-      name: 'name',
-      password: 'password',
-    }).insert({
-      password: 'override',
+      expectQueryNotMutated(q);
     });
-
-    expectSql(
-      query.toSql(),
-      `
-        INSERT INTO "user"("name", "password")
-        VALUES ($1, $2)
-      `,
-      ['name', 'override'],
-    );
   });
 
   describe('onConflict', () => {
@@ -490,52 +497,57 @@ describe('insert', () => {
     });
   });
 
-  describe('create', () => {
-    it('should return full record', async () => {
-      const result = await User.create(userData);
-      expect(result).toMatchObject(userData);
-
-      const eq: AssertEqual<typeof result, typeof User.type> = true;
-      expect(eq).toBe(true);
-    });
+  describe('create functions', () => {
+    describe('create', () => {
+      it('should return full record', async () => {
+        const result = await User.create(userData);
+        expect(result).toMatchObject(userData);
 
-    it('should return columns from select', async () => {
-      const result = await User.select('id', 'name').create(userData);
-      expect(result).toEqual({
-        id: result.id,
-        name: userData.name,
+        const eq: AssertEqual<typeof result, typeof User.type> = true;
+        expect(eq).toBe(true);
       });
 
-      const eq: AssertEqual<typeof result, { id: number; name: string }> = true;
-      expect(eq).toBe(true);
-    });
-
-    it('should return full records when creating many', async () => {
-      const result = await User.create([userData, userData]);
-      expect(result[0]).toMatchObject(userData);
-      expect(result[1]).toMatchObject(userData);
+      it('should return columns from select', async () => {
+        const result = await User.select('id', 'name').create(userData);
+        expect(result).toEqual({
+          id: result.id,
+          name: userData.name,
+        });
 
-      const eq: AssertEqual<typeof result, typeof User.type[]> = true;
-      expect(eq).toBe(true);
+        const eq: AssertEqual<typeof result, { id: number; name: string }> =
+          true;
+        expect(eq).toBe(true);
+      });
     });
 
-    it('should return columns from select when creating many', async () => {
-      const result = await User.select('id', 'name').create([
-        userData,
-        userData,
-      ]);
-      expect(result[0]).toEqual({
-        id: result[0].id,
-        name: userData.name,
-      });
-      expect(result[1]).toEqual({
-        id: result[1].id,
-        name: userData.name,
+    describe('createMany', () => {
+      it('should return full records', async () => {
+        const result = await User.createMany([userData, userData]);
+        expect(result[0]).toMatchObject(userData);
+        expect(result[1]).toMatchObject(userData);
+
+        const eq: AssertEqual<typeof result, typeof User.type[]> = true;
+        expect(eq).toBe(true);
       });
 
-      const eq: AssertEqual<typeof result, { id: number; name: string }[]> =
-        true;
-      expect(eq).toBe(true);
+      it('should return columns from select', async () => {
+        const result = await User.select('id', 'name').createMany([
+          userData,
+          userData,
+        ]);
+        expect(result[0]).toEqual({
+          id: result[0].id,
+          name: userData.name,
+        });
+        expect(result[1]).toEqual({
+          id: result[1].id,
+          name: userData.name,
+        });
+
+        const eq: AssertEqual<typeof result, { id: number; name: string }[]> =
+          true;
+        expect(eq).toBe(true);
+      });
     });
   });
 });