pqb 0.7.13 → 0.8.1

package/package.json

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

package/src/columnSchema/array.test.ts

@@ -0,0 +1,67 @@
+import { assertType, db } from '../test-utils/test-utils';
+import { ArrayColumn } from './array';
+import { IntegerColumn } from './number';
+
+describe('array column', () => {
+  describe('array', () => {
+    it('should output nested array of numbers', async () => {
+      const result = await db.get(
+        db.raw(
+          (t) => new ArrayColumn(new ArrayColumn(t.integer())),
+          `'{{1, 2, 3}, {4, 5, 6}}'::integer[][]`,
+        ),
+      );
+      expect(result).toEqual([
+        [1, 2, 3],
+        [4, 5, 6],
+      ]);
+
+      assertType<typeof result, number[][]>();
+    });
+
+    it('should output nested array of strings', async () => {
+      const result = await db.get(
+        db.raw(
+          (t) => new ArrayColumn(new ArrayColumn(t.text())),
+          `'{{"a", "b"}, {"c", "d"}}'::text[][]`,
+        ),
+      );
+      expect(result).toEqual([
+        ['a', 'b'],
+        ['c', 'd'],
+      ]);
+
+      assertType<typeof result, string[][]>();
+    });
+
+    it('should output nested array of booleans', async () => {
+      const result = await db.get(
+        db.raw(
+          (t) => new ArrayColumn(new ArrayColumn(t.boolean())),
+          `'{{true}, {false}}'::text[][]`,
+        ),
+      );
+      expect(result).toEqual([[true], [false]]);
+
+      assertType<typeof result, boolean[][]>();
+    });
+
+    it('should have toCode', async () => {
+      const column = new ArrayColumn(new IntegerColumn());
+      expect(column.toCode('t')).toEqual(['t.array(', 't.integer()', ')']);
+
+      expect(column.nonEmpty().toCode('t')).toEqual([
+        't.array(',
+        't.integer()',
+        ')',
+        '.nonEmpty()',
+      ]);
+
+      expect(column.min(1).max(10).length(15).toCode('t')).toEqual([
+        't.array(',
+        't.integer()',
+        ').min(1).max(10).length(15)',
+      ]);
+    });
+  });
+});

package/src/columnSchema/array.ts

@@ -1,13 +1,15 @@
-import { ColumnData, ColumnType } from './columnType';
+import { Code, columnCode, ColumnData, ColumnType } from './columnType';
 import { Operators } from '../columnsOperators';
 import { assignMethodsToClass } from './utils';
 import { arrayMethods } from './commonMethods';
+import { toArray } from '../utils';
 
 export type ArrayData<Item extends ColumnType> = ColumnData & {
   item: Item;
   min?: number;
   max?: number;
   length?: number;
+  isNonEmpty?: true;
 };
 
 type ArrayMethods = typeof arrayMethods;
@@ -34,18 +36,42 @@ export class ArrayColumn<Item extends ColumnType> extends ColumnType<
     return `${this.data.item.toSQL()}[]`;
   }
 
-  parseFn = (input: unknown) => {
-    const entries: unknown[] = [];
-    parseArray(
-      input as string,
-      0,
-      (input as string).length,
-      entries,
-      false,
-      this.data.item,
-    );
-    return entries;
-  };
+  toCode(this: ArrayColumn<Item>, t: string): Code {
+    let code = ')';
+
+    const { min, max, length, isNonEmpty } = this.data;
+
+    if (min !== undefined && (!isNonEmpty || (isNonEmpty && min !== 1)))
+      code += `.min(${min})`;
+
+    if (max !== undefined) code += `.max(${max})`;
+
+    if (length !== undefined) code += `.length(${length})`;
+
+    return columnCode(this, t, [
+      't.array(',
+      ...toArray(this.data.item.toCode(t)),
+      code,
+    ]);
+  }
+
+  parseFn = Object.assign(
+    (input: unknown) => {
+      const entries: unknown[] = [];
+      parseArray(
+        input as string,
+        0,
+        (input as string).length,
+        entries,
+        false,
+        this.data.item,
+      );
+      return entries;
+    },
+    {
+      hideFromCode: true,
+    },
+  );
 }
 
 const parseArray = (

package/src/columnSchema/boolean.test.ts

@@ -0,0 +1,17 @@
+import { assertType, db } from '../test-utils/test-utils';
+import { BooleanColumn } from './boolean';
+
+describe('boolean column', () => {
+  it('should output boolean', async () => {
+    const result = await db.get(db.raw(() => new BooleanColumn(), `true`));
+    expect(result).toBe(true);
+
+    assertType<typeof result, boolean>();
+  });
+
+  it('should have toCode', () => {
+    const column = new BooleanColumn();
+
+    expect(column.toCode('t')).toBe('t.boolean()');
+  });
+});

package/src/columnSchema/boolean.ts

@@ -1,4 +1,4 @@
-import { ColumnType } from './columnType';
+import { Code, columnCode, ColumnType } from './columnType';
 import { Operators } from '../columnsOperators';
 
 // 1 byte, true or false
@@ -9,5 +9,9 @@ export class BooleanColumn extends ColumnType<
   dataType = 'boolean' as const;
   operators = Operators.boolean;
 
+  toCode(t: string): Code {
+    return columnCode(this, t, `${t}.boolean()`);
+  }
+
   parseItem = (input: string) => input[0] === 't';
 }

package/src/columnSchema/columnType.test.ts

@@ -1,4 +1,4 @@
-import { ColumnType } from './columnType';
+import { Code, columnCode, ColumnType } from './columnType';
 import { Operators } from '../columnsOperators';
 import {
   adapter,
@@ -11,6 +11,7 @@ import {
 } from '../test-utils/test-utils';
 import { createDb } from '../db';
 import { columnTypes } from './columnTypes';
+import { IntegerColumn } from './number';
 
 describe('column base', () => {
   useTestDatabase();
@@ -18,6 +19,9 @@ describe('column base', () => {
   class Column extends ColumnType {
     dataType = 'test';
     operators = Operators.any;
+    toCode(t: string): Code {
+      return columnCode(this, t, `${t}.column()`);
+    }
   }
   const column = new Column();
 
@@ -26,6 +30,63 @@ describe('column base', () => {
       expect(column.isPrimaryKey).toBe(false);
       expect(column.primaryKey().isPrimaryKey).toBe(true);
     });
+
+    it('should have toCode', () => {
+      expect(column.primaryKey().toCode('t')).toEqual([
+        't.column()',
+        '.primaryKey()',
+      ]);
+    });
+  });
+
+  describe('.foreignKey', () => {
+    it('should have toCode', () => {
+      class Table {
+        table = 'table';
+        columns = { shape: { column: new IntegerColumn() } };
+      }
+
+      expect(column.foreignKey(() => Table, 'column').toCode('t')).toEqual([
+        't.column()',
+        '.foreignKey(',
+        '()=>Table',
+        `, 'column'`,
+        ')',
+      ]);
+
+      expect(column.foreignKey('table', 'column').toCode('t')).toEqual([
+        't.column()',
+        '.foreignKey(',
+        `'table'`,
+        `, 'column'`,
+        ')',
+      ]);
+
+      expect(
+        column
+          .foreignKey('table', 'column', {
+            name: 'name',
+            match: 'FULL',
+            onUpdate: 'CASCADE',
+            onDelete: 'CASCADE',
+          })
+          .toCode('t'),
+      ).toEqual([
+        't.column()',
+        '.foreignKey(',
+        `'table'`,
+        `, 'column'`,
+        ', {',
+        [
+          `name: 'name',`,
+          `match: 'FULL',`,
+          `onUpdate: 'CASCADE',`,
+          `onDelete: 'CASCADE',`,
+        ],
+        '}',
+        ')',
+      ]);
+    });
   });
 
   describe('.hidden', () => {
@@ -34,7 +95,11 @@ describe('column base', () => {
       expect(column.hidden().isHidden).toBe(true);
     });
 
-    test('model with hidden column should omit from select it by default', () => {
+    it('should have toCode', () => {
+      expect(column.hidden().toCode('t')).toEqual(['t.column()', '.hidden()']);
+    });
+
+    test('table with hidden column should omit from select it by default', () => {
       const User = db('user', (t) => ({
         id: t.serial().primaryKey(),
         name: t.text(),
@@ -53,7 +118,7 @@ describe('column base', () => {
       );
     });
 
-    test('model with hidden column still allows to select it', () => {
+    test('table with hidden column still allows to select it', () => {
       const User = db('user', (t) => ({
         id: t.serial().primaryKey(),
         name: t.text(),
@@ -79,9 +144,16 @@ describe('column base', () => {
       expect(column.isNullable).toBe(false);
       expect(column.nullable().isNullable).toBe(true);
     });
+
+    it('should have toCode', () => {
+      expect(column.nullable().toCode('t')).toEqual([
+        't.column()',
+        '.nullable()',
+      ]);
+    });
   });
 
-  describe('.encodeFn', () => {
+  describe('.encode', () => {
     it('should set a function to encode value for this column', () => {
       expect(column.encodeFn).toBe(undefined);
       const fn = (input: number) => input.toString();
@@ -89,9 +161,15 @@ describe('column base', () => {
       expect(withEncode.encodeFn).toBe(fn);
       assertType<typeof withEncode.inputType, number>();
     });
+
+    it('should have toCode', () => {
+      expect(
+        column.encode((input: number) => input.toString()).toCode('t'),
+      ).toEqual(['t.column()', '.encode((input)=>input.toString())']);
+    });
   });
 
-  describe('.parseFn', () => {
+  describe('.parse', () => {
     it('should set a function to encode value for this column', () => {
       expect(column.parseFn).toBe(undefined);
       const fn = () => 123;
@@ -100,6 +178,13 @@ describe('column base', () => {
       assertType<typeof withEncode.type, number>();
     });
 
+    it('should have toCode', () => {
+      expect(column.parse((v) => parseInt(v as string)).toCode('t')).toEqual([
+        't.column()',
+        '.parse((v)=>parseInt(v))',
+      ]);
+    });
+
     describe('parsing columns', () => {
       beforeEach(async () => {
         await User.create(userData);
@@ -156,6 +241,13 @@ describe('column base', () => {
       updatedAt: t.dateTimestamp(),
     }));
 
+    it('should have toCode', () => {
+      expect(column.as(columnTypes.integer()).toCode('t')).toEqual([
+        't.column()',
+        '.as(t.integer())',
+      ]);
+    });
+
     it('should accept only column of same type and input type', () => {
       columnTypes
         .timestamp()
@@ -233,121 +325,152 @@ describe('column base', () => {
     });
   });
 
-  describe('timestamp().asNumber()', () => {
-    it('should parse and encode timestamp as a number', async () => {
-      const UserWithNumberTimestamp = db('user', (t) => ({
-        id: t.serial().primaryKey(),
-        name: t.text(),
-        password: t.text(),
-        createdAt: t.timestamp().asNumber(),
-        updatedAt: t.timestamp().asNumber(),
-      }));
-
-      const now = Date.now();
-
-      const createQuery = UserWithNumberTimestamp.create({
-        ...userData,
-        createdAt: now,
-        updatedAt: now,
-      });
-
-      expectSql(
-        createQuery.toSql(),
-        `
-          INSERT INTO "user"("name", "password", "createdAt", "updatedAt")
-          VALUES ($1, $2, $3, $4)
-          RETURNING *
-        `,
-        [userData.name, userData.password, new Date(now), new Date(now)],
-      );
-
-      const { id } = await createQuery;
-      const user = await UserWithNumberTimestamp.select(
-        'createdAt',
-        'updatedAt',
-      ).find(id);
-
-      assertType<typeof user, { createdAt: number; updatedAt: number }>();
-
-      expect(typeof user.createdAt).toBe('number');
-      expect(typeof user.updatedAt).toBe('number');
-
-      const updateQuery = UserWithNumberTimestamp.find(id).update({
-        createdAt: now,
-        updatedAt: now,
-      });
+  describe('.default', () => {
+    it('should have toCode', () => {
+      expect(column.default(123).toCode('t')).toEqual([
+        't.column()',
+        '.default(123)',
+      ]);
+    });
+  });
 
-      expectSql(
-        updateQuery.toSql(),
-        `
-          UPDATE "user"
-          SET "createdAt" = $1, "updatedAt" = $2
-          WHERE "user"."id" = $3
-        `,
-        [new Date(now), new Date(now), id],
-      );
+  describe('.index', () => {
+    it('should have toCode', () => {
+      expect(
+        column
+          .index({
+            expression: 'expression',
+            collate: 'collate',
+            operator: 'operator',
+            order: 'order',
+            name: 'name',
+            using: 'using',
+            include: 'include',
+            with: 'with',
+            tablespace: 'tablespace',
+            where: 'where',
+          })
+          .toCode('t'),
+      ).toEqual([
+        't.column()',
+        '.index(',
+        '{',
+        [
+          `expression: 'expression',`,
+          `collate: 'collate',`,
+          `operator: 'operator',`,
+          `order: 'order',`,
+          `name: 'name',`,
+          `using: 'using',`,
+          `include: 'include',`,
+          `with: 'with',`,
+          `tablespace: 'tablespace',`,
+          `where: 'where',`,
+        ],
+        '}',
+        ')',
+      ]);
     });
   });
 
-  describe('timestamp().asDate()', () => {
-    it('should parse and encode timestamp as a number', async () => {
-      columnTypes
-        .text(0, 100)
-        .encode((input: number) => input)
-        .parse((text) => parseInt(text))
-        .as(columnTypes.integer());
+  describe('unique', () => {
+    it('should have toCode', () => {
+      expect(column.unique().toCode('t')).toEqual([
+        't.column()',
+        '.unique(',
+        ')',
+      ]);
+    });
+  });
 
-      const UserWithNumberTimestamp = db('user', (t) => ({
-        id: t.serial().primaryKey(),
-        name: t.text(),
-        password: t.text(),
-        createdAt: columnTypes.timestamp().asDate(),
-        updatedAt: columnTypes.timestamp().asDate(),
-      }));
+  describe('comment', () => {
+    it('should have toCode', () => {
+      expect(column.comment('comment').toCode('t')).toEqual([
+        't.column()',
+        `.comment('comment')`,
+      ]);
+    });
+  });
 
-      const now = new Date();
+  describe('validationDefault', () => {
+    it('should have toCode', () => {
+      expect(column.validationDefault('value').toCode('t')).toEqual([
+        't.column()',
+        `.validationDefault('value')`,
+      ]);
+
+      expect(column.validationDefault(123).toCode('t')).toEqual([
+        't.column()',
+        `.validationDefault(123)`,
+      ]);
+
+      expect(column.validationDefault(() => 'value').toCode('t')).toEqual([
+        't.column()',
+        `.validationDefault(()=>'value')`,
+      ]);
+    });
+  });
 
-      const createQuery = UserWithNumberTimestamp.create({
-        ...userData,
-        createdAt: now,
-        updatedAt: now,
-      });
+  describe('compression', () => {
+    it('should have toCode', () => {
+      expect(column.compression('compression').toCode('t')).toEqual([
+        't.column()',
+        `.compression('compression')`,
+      ]);
+    });
+  });
 
-      expectSql(
-        createQuery.toSql(),
-        `
-          INSERT INTO "user"("name", "password", "createdAt", "updatedAt")
-          VALUES ($1, $2, $3, $4)
-          RETURNING *
-        `,
-        [userData.name, userData.password, new Date(now), new Date(now)],
-      );
+  describe('collate', () => {
+    it('should have toCode', () => {
+      expect(column.collate('collate').toCode('t')).toEqual([
+        't.column()',
+        `.collate('collate')`,
+      ]);
+    });
+  });
 
-      const { id } = await createQuery;
-      const user = await UserWithNumberTimestamp.select(
-        'createdAt',
-        'updatedAt',
-      ).find(id);
+  describe('modifyQuery', () => {
+    it('should have toCode', () => {
+      expect(column.modifyQuery((table) => table).toCode('t')).toEqual([
+        't.column()',
+        `.modifyQuery((table)=>table)`,
+      ]);
+    });
+  });
 
-      assertType<typeof user, { createdAt: Date; updatedAt: Date }>();
+  describe('transform', () => {
+    it('should have toCode', () => {
+      expect(column.transform((s) => s).toCode('t')).toEqual([
+        't.column()',
+        '.transform((s)=>s)',
+      ]);
+    });
+  });
 
-      expect(user.createdAt).toBeInstanceOf(Date);
-      expect(user.updatedAt).toBeInstanceOf(Date);
+  describe('to', () => {
+    it('should have toCode', () => {
+      expect(
+        column
+          .to((s) => parseInt(s as string), new IntegerColumn())
+          .toCode('t'),
+      ).toEqual(['t.column()', '.to((s)=>parseInt(s), ', 't.integer()', ')']);
+    });
+  });
 
-      const updateQuery = UserWithNumberTimestamp.find(id).update({
-        createdAt: now,
-        updatedAt: now,
-      });
+  describe('refine', () => {
+    it('should have toCode', () => {
+      expect(
+        column.refine((s) => (s as string).length > 0).toCode('t'),
+      ).toEqual(['t.column()', '.refine((s)=>s.length > 0)']);
+    });
+  });
 
-      expectSql(
-        updateQuery.toSql(),
-        `
-          UPDATE "user"
-          SET "createdAt" = $1, "updatedAt" = $2
-          WHERE "user"."id" = $3
-        `,
-        [now, now, id],
-      );
+  describe('superRefine', () => {
+    it('should have toCode', () => {
+      expect(column.superRefine((s) => s).toCode('t')).toEqual([
+        't.column()',
+        '.superRefine((s)=>s)',
+      ]);
     });
   });
 });