pqb 0.7.0 → 0.7.2

package/package.json

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

package/src/adapter.test.ts

@@ -1,4 +1,4 @@
-import { adapter } from './test-utils';
+import { adapter } from './test-utils/test-utils';
 
 describe('adapter', () => {
   it('should run query and close connection by calling .close()', async () => {

package/src/columnSchema/columnType.test.ts

@@ -8,7 +8,7 @@ import {
   User,
   userData,
   useTestDatabase,
-} from '../test-utils';
+} from '../test-utils/test-utils';
 import { createDb } from '../db';
 import { columnTypes } from './columnTypes';
 
@@ -109,6 +109,7 @@ describe('column base', () => {
         const db = createDb({ adapter, columnTypes });
 
         const UserWithPlainTimestamp = db('user', (t) => ({
+          id: t.serial().primaryKey(),
           createdAt: t.timestamp(),
         }));
 

package/src/columnSchema/columnTypes.test.ts

@@ -1,4 +1,4 @@
-import { assertType, db } from '../test-utils';
+import { assertType, db } from '../test-utils/test-utils';
 import { columnTypes } from './columnTypes';
 import { TimeInterval } from './dateTime';
 

package/src/columnSchema/timestamps.test.ts

@@ -1,10 +1,10 @@
-import { db, expectSql, now, useTestDatabase } from '../test-utils';
+import { db, expectSql, now, useTestDatabase } from '../test-utils/test-utils';
 
 describe('timestamps', () => {
   useTestDatabase();
 
   const model = db('user', (t) => ({
-    name: t.string(),
+    name: t.string().primaryKey(),
     ...t.timestamps(),
   }));
 

package/src/columnSchema/utils.ts

@@ -18,7 +18,7 @@ export const assignMethodsToClass = <Methods extends Record<string, unknown>>(
         const cloned = cloneInstance(this);
         return (
           methods as unknown as Record<string, (...args: unknown[]) => unknown>
-        )[name].call(cloned, args);
+        )[name].apply(cloned, args);
       },
     });
   }

package/src/columnsOperators.test.ts

@@ -1,4 +1,4 @@
-import { db, expectSql, User } from './test-utils';
+import { db, expectSql, User } from './test-utils/test-utils';
 
 describe('operators', () => {
   describe('equals', () => {

package/src/db.test.ts

@@ -6,9 +6,10 @@ import {
   User,
   userData,
   useTestDatabase,
-} from './test-utils';
+} from './test-utils/test-utils';
 import { createDb } from './db';
 import { columnTypes } from './columnSchema';
+import { QueryLogger } from './queryMethods';
 
 describe('db', () => {
   useTestDatabase();
@@ -26,12 +27,30 @@ describe('db', () => {
     );
   });
 
+  describe('primaryKeys', () => {
+    it('should collect primary keys from schema', () => {
+      const table = db('table', (t) => ({
+        id: t.serial().primaryKey(),
+        name: t.text().primaryKey(),
+      }));
+      expect(table.primaryKeys).toEqual(['id', 'name']);
+    });
+
+    it('should set primary keys from primaryKey in schema', () => {
+      const table = db('table', (t) => ({
+        ...t.primaryKey(['id', 'name']),
+      }));
+      expect(table.primaryKeys).toEqual(['id', 'name']);
+    });
+  });
+
   describe('overriding column types', () => {
     it('should return date as string by default', async () => {
       await User.create(userData);
 
       const db = createDb({ adapter, columnTypes });
       const table = db('user', (t) => ({
+        id: t.serial().primaryKey(),
         createdAt: t.timestamp(),
       }));
 
@@ -47,12 +66,15 @@ describe('db', () => {
       const db = createDb({
         adapter,
         columnTypes: {
+          serial: columnTypes.serial,
           timestamp() {
             return columnTypes.timestamp().parse((input) => new Date(input));
           },
         },
       });
+
       const table = db('user', (t) => ({
+        id: t.serial().primaryKey(),
         createdAt: t.timestamp(),
       }));
 
@@ -71,4 +93,64 @@ describe('db', () => {
       expect(table.query.autoPreparedStatements).toBe(false);
     });
   });
+
+  describe('noPrimaryKey', () => {
+    it('should throw error when no primary key by default', () => {
+      const db = createDb({ adapter, columnTypes });
+
+      expect(() =>
+        db('table', (t) => ({
+          name: t.text(),
+        })),
+      ).toThrow(`Table table has no primary key`);
+    });
+
+    it('should throw error when no primary key when noPrimaryKey is set to `error`', () => {
+      const db = createDb({ adapter, columnTypes, noPrimaryKey: 'error' });
+
+      expect(() =>
+        db('table', (t) => ({
+          name: t.text(),
+        })),
+      ).toThrow(`Table table has no primary key`);
+    });
+
+    it('should not throw when no column shape is provided', () => {
+      const db = createDb({ adapter, columnTypes });
+
+      expect(() => db('table')).not.toThrow();
+    });
+
+    it('should warn when no primary key and noPrimaryKey is set to `warning`', () => {
+      const logger = { warn: jest.fn() };
+      const db = createDb({
+        adapter,
+        columnTypes,
+        noPrimaryKey: 'warning',
+        logger: logger as unknown as QueryLogger,
+      });
+
+      db('table', (t) => ({
+        name: t.text(),
+      }));
+
+      expect(logger.warn).toBeCalledWith('Table table has no primary key');
+    });
+
+    it('should do nothing when no primary key and noPrimaryKey is set to `ignore`', () => {
+      const logger = { warn: jest.fn() };
+      const db = createDb({
+        adapter,
+        columnTypes,
+        noPrimaryKey: 'ignore',
+        logger: logger as unknown as QueryLogger,
+      });
+
+      db('table', (t) => ({
+        name: t.text(),
+      }));
+
+      expect(logger.warn).not.toBeCalled();
+    });
+  });
 });

package/src/db.ts

@@ -23,16 +23,30 @@ import {
   getColumnTypes,
   SinglePrimaryKey,
   ColumnType,
+  getTableData,
 } from './columnSchema';
 import { applyMixins, pushOrNewArray } from './utils';
 import { StringKey } from './common';
 import { QueryError, QueryErrorName } from './errors';
 
+export type NoPrimaryKeyOption = 'error' | 'warning' | 'ignore';
+
+export type DbOptions<CT extends ColumnTypesBase> = (
+  | { adapter: Adapter }
+  | Omit<AdapterOptions, 'log'>
+) &
+  QueryLogOptions & {
+    columnTypes: CT;
+    autoPreparedStatements?: boolean;
+    noPrimaryKey?: NoPrimaryKeyOption;
+  };
+
 export type DbTableOptions = {
   schema?: string;
   // prepare all SQL queries before executing
   // true by default
   autoPreparedStatements?: boolean;
+  noPrimaryKey?: NoPrimaryKeyOption;
 } & QueryLogOptions;
 
 export interface Db<
@@ -136,9 +150,20 @@ export class Db<
     this.primaryKeys = Object.keys(shape).filter(
       (key) => shape[key].isPrimaryKey,
     );
+    const primaryKeysFromData = getTableData().primaryKey?.columns;
+    if (primaryKeysFromData) this.primaryKeys.push(...primaryKeysFromData);
+
     if (this.primaryKeys.length === 1) {
       this.singlePrimaryKey = this
         .primaryKeys[0] as unknown as SinglePrimaryKey<Shape>;
+    } else if (
+      this.primaryKeys.length === 0 &&
+      shape !== anyShape &&
+      options.noPrimaryKey !== 'ignore'
+    ) {
+      const message = `Table ${table} has no primary key`;
+      if (options.noPrimaryKey === 'error') throw new Error(message);
+      else logger.warn(message);
     }
 
     const columns = Object.keys(
@@ -209,15 +234,6 @@ type DbResult<CT extends ColumnTypesBase> = Db<
   close: Adapter['close'];
 };
 
-export type DbOptions<CT extends ColumnTypesBase> = (
-  | { adapter: Adapter }
-  | Omit<AdapterOptions, 'log'>
-) &
-  QueryLogOptions & {
-    columnTypes: CT;
-    autoPreparedStatements?: boolean;
-  };
-
 export const createDb = <CT extends ColumnTypesBase>({
   log,
   logger,
@@ -229,13 +245,14 @@ export const createDb = <CT extends ColumnTypesBase>({
     log,
     logger,
     autoPreparedStatements: options.autoPreparedStatements ?? false,
+    noPrimaryKey: options.noPrimaryKey ?? 'error',
   };
 
   const qb = new Db(
     adapter,
     undefined as unknown as Db,
     undefined,
-    {},
+    anyShape,
     ct,
     commonOptions,
   );

package/src/errors.test.ts

@@ -1,4 +1,9 @@
-import { db, UniqueTable, User, useTestDatabase } from './test-utils';
+import {
+  db,
+  UniqueTable,
+  User,
+  useTestDatabase,
+} from './test-utils/test-utils';
 import { QueryError } from './errors';
 
 describe('errors', () => {

package/src/queryMethods/aggregate.test.ts

@@ -6,7 +6,7 @@ import {
   userData,
   assertType,
   db,
-} from '../test-utils';
+} from '../test-utils/test-utils';
 
 describe('aggregate', () => {
   useTestDatabase();

package/src/queryMethods/callbacks.test.ts

@@ -1,4 +1,4 @@
-import { User, userData, useTestDatabase } from '../test-utils';
+import { User, userData, useTestDatabase } from '../test-utils/test-utils';
 
 describe('callbacks', () => {
   useTestDatabase();

package/src/queryMethods/clear.test.ts

@@ -1,4 +1,4 @@
-import { expectSql, line, Message, User } from '../test-utils';
+import { expectSql, line, Message, User } from '../test-utils/test-utils';
 
 describe('clear', () => {
   it('should remove query statements for select', () => {

package/src/queryMethods/columnInfo.test.ts

@@ -1,4 +1,8 @@
-import { expectQueryNotMutated, expectSql, User } from '../test-utils';
+import {
+  expectQueryNotMutated,
+  expectSql,
+  User,
+} from '../test-utils/test-utils';
 
 describe('columnInfo', () => {
   it('should return all columns info', async () => {

package/src/queryMethods/copy.test.ts

@@ -0,0 +1,63 @@
+import { expectSql, User, useTestDatabase } from '../test-utils/test-utils';
+
+describe('copy', () => {
+  useTestDatabase();
+
+  const columns = ['name', 'password'] as ['name', 'password'];
+  const options = {
+    columns: columns,
+    format: 'csv' as const,
+    freeze: true,
+    delimiter: ',',
+    null: 'null',
+    header: 'match' as const,
+    quote: 'quote',
+    escape: 'escape',
+    forceQuote: columns,
+    forceNotNull: columns,
+    forceNull: columns,
+    encoding: 'encoding',
+  };
+
+  describe.each`
+    method    | sql
+    ${'from'} | ${'FROM'}
+    ${'to'}   | ${'TO'}
+  `('$method', ({ method, sql }) => {
+    test(`simple copy ${method}`, () => {
+      const q = User.copy({
+        [method as 'from']: 'path-to-file',
+      });
+
+      expectSql(q.toSql(), `COPY "user" ${sql} 'path-to-file'`);
+    });
+
+    test(`copy ${method} with options`, () => {
+      const q = User.copy({
+        [method as 'from']: { program: 'program' },
+        ...options,
+      });
+
+      expectSql(
+        q.toSql(),
+        `
+        COPY "user"("name", "password")
+        ${sql} PROGRAM 'program'
+        WITH (
+          FORMAT csv,
+          FREEZE true,
+          DELIMITER ',',
+          NULL 'null',
+          HEADER match,
+          QUOTE 'quote',
+          ESCAPE 'escape',
+          FORCE_QUOTE ("name", "password"),
+          FORCE_NOT_NULL ("name", "password"),
+          FORCE_NULL ("name", "password"),
+          ENCODING 'encoding'
+        )
+      `,
+      );
+    });
+  });
+});

package/src/queryMethods/copy.ts

@@ -0,0 +1,17 @@
+import { Query } from '../query';
+import { CopyOptions } from '../sql';
+
+type CopyArg<T extends Query> = CopyOptions<keyof T['shape']>;
+
+export class CopyMethods {
+  copy<T extends Query>(this: T, arg: CopyArg<T>): T {
+    return this.clone()._copy(arg);
+  }
+  _copy<T extends Query>(this: T, arg: CopyArg<T>) {
+    Object.assign(this.query, {
+      type: 'copy',
+      copy: arg,
+    });
+    return this;
+  }
+}

package/src/queryMethods/create.test.ts

@@ -10,7 +10,7 @@ import {
   userData,
   UserRecord,
   useTestDatabase,
-} from '../test-utils';
+} from '../test-utils/test-utils';
 import { OnConflictQueryBuilder } from './create';
 
 describe('create functions', () => {

package/src/queryMethods/delete.test.ts

@@ -6,7 +6,7 @@ import {
   User,
   userData,
   useTestDatabase,
-} from '../test-utils';
+} from '../test-utils/test-utils';
 import { DeleteQueryData } from '../sql';
 
 describe('delete', () => {

package/src/queryMethods/for.test.ts

@@ -1,4 +1,8 @@
-import { expectQueryNotMutated, expectSql, User } from '../test-utils';
+import {
+  expectQueryNotMutated,
+  expectSql,
+  User,
+} from '../test-utils/test-utils';
 
 describe('for', () => {
   describe.each`

package/src/queryMethods/from.test.ts

@@ -1,4 +1,9 @@
-import { db, expectQueryNotMutated, expectSql, User } from '../test-utils';
+import {
+  db,
+  expectQueryNotMutated,
+  expectSql,
+  User,
+} from '../test-utils/test-utils';
 
 describe('from', () => {
   it('should accept string parameter', () => {

package/src/queryMethods/get.test.ts

@@ -1,4 +1,10 @@
-import { assertType, db, User, userData, useTestDatabase } from '../test-utils';
+import {
+  assertType,
+  db,
+  User,
+  userData,
+  useTestDatabase,
+} from '../test-utils/test-utils';
 import { NotFoundError } from '../errors';
 
 describe('get', () => {

package/src/queryMethods/having.test.ts

@@ -1,4 +1,9 @@
-import { db, expectQueryNotMutated, expectSql, User } from '../test-utils';
+import {
+  db,
+  expectQueryNotMutated,
+  expectSql,
+  User,
+} from '../test-utils/test-utils';
 
 describe('having', () => {
   it('should support { count: value } object', () => {

package/src/queryMethods/join.test.ts

@@ -1,4 +1,9 @@
-import { expectQueryNotMutated, expectSql, Message, User } from '../test-utils';
+import {
+  expectQueryNotMutated,
+  expectSql,
+  Message,
+  User,
+} from '../test-utils/test-utils';
 import { OnQueryBuilder } from './join';
 import { testJoin, testWhere } from './where.test';
 import { Sql } from '../sql';

package/src/queryMethods/json.test.ts

@@ -5,7 +5,7 @@ import {
   User,
   userData,
   useTestDatabase,
-} from '../test-utils';
+} from '../test-utils/test-utils';
 import { columnTypes } from '../columnSchema';
 
 describe('json methods', () => {

package/src/queryMethods/log.test.ts

@@ -1,5 +1,10 @@
 import { createDb } from '../db';
-import { adapter, dbOptions, userData, useTestDatabase } from '../test-utils';
+import {
+  adapter,
+  dbOptions,
+  userData,
+  useTestDatabase,
+} from '../test-utils/test-utils';
 import { logColors } from './log';
 import { noop } from '../utils';
 import { columnTypes } from '../columnSchema';

package/src/queryMethods/log.ts

@@ -11,6 +11,7 @@ export type QueryLogObject = {
 
 export type QueryLogger = {
   log(message: string): void;
+  warn(message: string): void;
   error(message: string): void;
 };
 

package/src/queryMethods/merge.test.ts

@@ -5,7 +5,7 @@ import {
   Message,
   Profile,
   User,
-} from '../test-utils';
+} from '../test-utils/test-utils';
 import { QueryReturnType } from '../query';
 import { IntegerColumn, TextColumn } from '../columnSchema';
 import { getValueKey } from './get';

package/src/queryMethods/queryMethods.test.ts

@@ -10,7 +10,7 @@ import {
   now,
   assertType,
   UserRecord,
-} from '../test-utils';
+} from '../test-utils/test-utils';
 import { NotFoundError } from '../errors';
 
 describe('queryMethods', () => {

package/src/queryMethods/queryMethods.ts

@@ -49,6 +49,7 @@ import { QueryUpsert } from './upsert';
 import { QueryGet } from './get';
 import { MergeQueryMethods } from './merge';
 import { RawMethods } from './raw';
+import { CopyMethods } from './copy';
 
 export type WindowArg<T extends Query> = Record<
   string,
@@ -98,7 +99,8 @@ export interface QueryMethods
     QueryUpsert,
     QueryGet,
     MergeQueryMethods,
-    RawMethods {}
+    RawMethods,
+    CopyMethods {}
 
 export class QueryMethods {
   windows!: EmptyObject;
@@ -394,4 +396,5 @@ applyMixins(QueryMethods, [
   QueryGet,
   MergeQueryMethods,
   RawMethods,
+  CopyMethods,
 ]);

package/src/queryMethods/raw.test.ts

@@ -1,6 +1,6 @@
 import { ColumnType } from '../columnSchema';
 import { createDb } from '../db';
-import { adapter } from '../test-utils';
+import { adapter } from '../test-utils/test-utils';
 
 describe('raw', () => {
   it('should use column types in callback from a db instance', () => {

package/src/queryMethods/select.test.ts

@@ -9,7 +9,7 @@ import {
   userData,
   UserRecord,
   useTestDatabase,
-} from '../test-utils';
+} from '../test-utils/test-utils';
 import { DateColumn } from '../columnSchema';
 
 const insertUserAndProfile = async () => {

package/src/queryMethods/then.test.ts

@@ -1,4 +1,9 @@
-import { assertType, db, User, useTestDatabase } from '../test-utils';
+import {
+  assertType,
+  db,
+  User,
+  useTestDatabase,
+} from '../test-utils/test-utils';
 
 describe('then', () => {
   useTestDatabase();

package/src/queryMethods/transaction.test.ts

@@ -1,4 +1,4 @@
-import { db, User } from '../test-utils';
+import { db, User } from '../test-utils/test-utils';
 import { Client } from 'pg';
 
 describe('transaction', () => {

package/src/queryMethods/union.test.ts

@@ -4,7 +4,7 @@ import {
   expectQueryNotMutated,
   expectSql,
   User,
-} from '../test-utils';
+} from '../test-utils/test-utils';
 
 ['union', 'intersect', 'except'].forEach((what) => {
   const upper = what.toUpperCase();

package/src/queryMethods/update.test.ts

@@ -7,7 +7,7 @@ import {
   userData,
   UserRecord,
   useTestDatabase,
-} from '../test-utils';
+} from '../test-utils/test-utils';
 
 describe('update', () => {
   useTestDatabase();

package/src/queryMethods/upsert.test.ts

@@ -1,4 +1,9 @@
-import { assertType, User, userData, useTestDatabase } from '../test-utils';
+import {
+  assertType,
+  User,
+  userData,
+  useTestDatabase,
+} from '../test-utils/test-utils';
 
 describe('upsert', () => {
   useTestDatabase();

package/src/queryMethods/where.test.ts

@@ -1,4 +1,4 @@
-import { db, expectSql, Message, User } from '../test-utils';
+import { db, expectSql, Message, User } from '../test-utils/test-utils';
 import { Sql } from '../sql';
 import { Query } from '../query';
 import { pushQueryOn } from './join';

package/src/queryMethods/window.test.ts

@@ -5,7 +5,7 @@ import {
   User,
   userData,
   useTestDatabase,
-} from '../test-utils';
+} from '../test-utils/test-utils';
 
 describe('window functions', () => {
   useTestDatabase();

package/src/queryMethods/with.test.ts

@@ -1,5 +1,10 @@
 import { WithOptions } from '../sql';
-import { db, expectQueryNotMutated, expectSql, User } from '../test-utils';
+import {
+  db,
+  expectQueryNotMutated,
+  expectSql,
+  User,
+} from '../test-utils/test-utils';
 import { columnTypes } from '../columnSchema';
 
 describe('with', () => {