pqb 0.4.6 → 0.4.8

package/src/columnSchema/timestamps.test.ts

@@ -1,5 +1,4 @@
 import { db, expectSql, now, useTestDatabase } from '../test-utils';
-import { raw } from '../common';
 
 describe('timestamps', () => {
   useTestDatabase();
@@ -37,7 +36,7 @@ describe('timestamps', () => {
   });
 
   it('should update updatedAt when updating with raw sql', async () => {
-    const query = model.updateRaw(raw('name = $1', 'name'), true);
+    const query = model.updateRaw(db.raw('name = $1', 'name'), true);
     await query;
 
     expectSql(
@@ -51,7 +50,7 @@ describe('timestamps', () => {
   });
 
   it('should update updatedAt when updating with raw sql which has updatedAt somewhere but not in set', async () => {
-    const query = model.updateRaw(raw('"createdAt" = "updatedAt"'), true);
+    const query = model.updateRaw(db.raw('"createdAt" = "updatedAt"'), true);
     await query;
 
     expectSql(
@@ -64,7 +63,7 @@ describe('timestamps', () => {
   });
 
   it('should not update updatedAt column when updating with raw sql which contains `updatedAt = `', async () => {
-    const query = model.updateRaw(raw('"updatedAt" = $1', now), true);
+    const query = model.updateRaw(db.raw('"updatedAt" = $1', now), true);
     await query;
 
     expectSql(

package/src/columnSchema/timestamps.ts

@@ -1,5 +1,4 @@
 import { ColumnType } from './columnType';
-import { getRawSql, isRaw, raw } from '../common';
 import { Query } from '../query';
 import { makeRegexToFindInSql, pushOrNewArrayToObject } from '../utils';
 import {
@@ -7,6 +6,7 @@ import {
   UpdateQueryData,
   UpdateQueryDataItem,
 } from '../sql';
+import { getRawSql, isRaw, raw } from '../common';
 
 export function timestamps<T extends ColumnType>(this: {
   timestamp(): T;

package/src/columnsOperators.test.ts

@@ -1,5 +1,4 @@
-import { expectSql, User } from './test-utils';
-import { raw } from './common';
+import { db, expectSql, User } from './test-utils';
 
 describe('operators', () => {
   describe('equals', () => {
@@ -27,7 +26,7 @@ describe('operators', () => {
 
     it('should handle raw query', () => {
       expectSql(
-        User.where({ name: { equals: raw("'name'") } }).toSql(),
+        User.where({ name: { equals: db.raw("'name'") } }).toSql(),
         `
           SELECT * FROM "user"
           WHERE "user"."name" = 'name'
@@ -61,7 +60,7 @@ describe('operators', () => {
 
     it('should handle raw query', () => {
       expectSql(
-        User.where({ name: { not: raw("'name'") } }).toSql(),
+        User.where({ name: { not: db.raw("'name'") } }).toSql(),
         `
           SELECT * FROM "user"
           WHERE "user"."name" <> 'name'
@@ -94,7 +93,7 @@ describe('operators', () => {
 
     it('should handle raw query', () => {
       expectSql(
-        User.where({ name: { in: raw("('a', 'b')") } }).toSql(),
+        User.where({ name: { in: db.raw("('a', 'b')") } }).toSql(),
         `
           SELECT * FROM "user"
           WHERE "user"."name" IN ('a', 'b')
@@ -127,7 +126,7 @@ describe('operators', () => {
 
     it('should handle raw query', () => {
       expectSql(
-        User.where({ name: { notIn: raw("('a', 'b')") } }).toSql(),
+        User.where({ name: { notIn: db.raw("('a', 'b')") } }).toSql(),
         `
           SELECT * FROM "user"
           WHERE NOT "user"."name" IN ('a', 'b')
@@ -161,7 +160,7 @@ describe('operators', () => {
 
     it('should handle raw query', () => {
       expectSql(
-        User.where({ id: { lt: raw('5') } }).toSql(),
+        User.where({ id: { lt: db.raw('5') } }).toSql(),
         `
           SELECT * FROM "user"
           WHERE "user"."id" < 5
@@ -195,7 +194,7 @@ describe('operators', () => {
 
     it('should handle raw query', () => {
       expectSql(
-        User.where({ id: { lte: raw('5') } }).toSql(),
+        User.where({ id: { lte: db.raw('5') } }).toSql(),
         `
           SELECT * FROM "user"
           WHERE "user"."id" <= 5
@@ -229,7 +228,7 @@ describe('operators', () => {
 
     it('should handle raw query', () => {
       expectSql(
-        User.where({ id: { gt: raw('5') } }).toSql(),
+        User.where({ id: { gt: db.raw('5') } }).toSql(),
         `
           SELECT * FROM "user"
           WHERE "user"."id" > 5
@@ -263,7 +262,7 @@ describe('operators', () => {
 
     it('should handle raw query', () => {
       expectSql(
-        User.where({ id: { gte: raw('5') } }).toSql(),
+        User.where({ id: { gte: db.raw('5') } }).toSql(),
         `
           SELECT * FROM "user"
           WHERE "user"."id" >= 5
@@ -297,7 +296,7 @@ describe('operators', () => {
 
     it('should handle raw query', () => {
       expectSql(
-        User.where({ name: { contains: raw("'ko'") } }).toSql(),
+        User.where({ name: { contains: db.raw("'ko'") } }).toSql(),
         `
           SELECT * FROM "user"
           WHERE "user"."name" LIKE '%' || 'ko' || '%'
@@ -333,7 +332,7 @@ describe('operators', () => {
 
     it('should handle raw query', () => {
       expectSql(
-        User.where({ name: { containsInsensitive: raw("'ko'") } }).toSql(),
+        User.where({ name: { containsInsensitive: db.raw("'ko'") } }).toSql(),
         `
           SELECT * FROM "user"
           WHERE "user"."name" ILIKE '%' || 'ko' || '%'
@@ -369,7 +368,7 @@ describe('operators', () => {
 
     it('should handle raw query', () => {
       expectSql(
-        User.where({ name: { startsWith: raw("'ko'") } }).toSql(),
+        User.where({ name: { startsWith: db.raw("'ko'") } }).toSql(),
         `
           SELECT * FROM "user"
           WHERE "user"."name" LIKE 'ko' || '%'
@@ -405,7 +404,7 @@ describe('operators', () => {
 
     it('should handle raw query', () => {
       expectSql(
-        User.where({ name: { startsWithInsensitive: raw("'ko'") } }).toSql(),
+        User.where({ name: { startsWithInsensitive: db.raw("'ko'") } }).toSql(),
         `
           SELECT * FROM "user"
           WHERE "user"."name" ILIKE 'ko' || '%'
@@ -441,7 +440,7 @@ describe('operators', () => {
 
     it('should handle raw query', () => {
       expectSql(
-        User.where({ name: { endsWith: raw("'ko'") } }).toSql(),
+        User.where({ name: { endsWith: db.raw("'ko'") } }).toSql(),
         `
           SELECT * FROM "user"
           WHERE "user"."name" LIKE '%' || 'ko'
@@ -477,7 +476,7 @@ describe('operators', () => {
 
     it('should handle raw query', () => {
       expectSql(
-        User.where({ name: { endsWithInsensitive: raw("'ko'") } }).toSql(),
+        User.where({ name: { endsWithInsensitive: db.raw("'ko'") } }).toSql(),
         `
           SELECT * FROM "user"
           WHERE "user"."name" ILIKE '%' || 'ko'
@@ -515,7 +514,7 @@ describe('operators', () => {
 
     it('should handle raw query', () => {
       expectSql(
-        User.where({ id: { between: [raw('1'), raw('10')] } }).toSql(),
+        User.where({ id: { between: [db.raw('1'), db.raw('10')] } }).toSql(),
         `
           SELECT * FROM "user"
           WHERE "user"."id" BETWEEN 1 AND 10
@@ -554,7 +553,7 @@ describe('operators', () => {
     it('should handle raw query', () => {
       expectSql(
         User.where({
-          data: { jsonPath: ['$.name', '=', raw("'name'")] },
+          data: { jsonPath: ['$.name', '=', db.raw("'name'")] },
         }).toSql(),
         `
           SELECT * FROM "user"
@@ -596,7 +595,7 @@ describe('operators', () => {
     it('should handle raw query', () => {
       expectSql(
         User.where({
-          data: { [method]: raw(`'{"a":"b"}'`) },
+          data: { [method]: db.raw(`'{"a":"b"}'`) },
         }).toSql(),
         `
           SELECT * FROM "user"

package/src/columnsOperators.ts

@@ -1,7 +1,7 @@
 import { Query } from './query';
-import { getRaw, isRaw, RawExpression } from './common';
 import { quote } from './quote';
 import { addValue } from './sql/common';
+import { getRaw, isRaw, RawExpression } from './common';
 
 type Fn<T> = (key: string, value: T, values: unknown[]) => string;
 

package/src/common.ts

@@ -16,6 +16,23 @@ export type RawExpression<C extends ColumnType = ColumnType> = {
   __column: C;
 };
 
+export const raw = (sql: string, ...values: unknown[]): RawExpression =>
+  ({
+    __raw: sql,
+    __values: values,
+  } as RawExpression);
+
+export const isRaw = (obj: object): obj is RawExpression => '__raw' in obj;
+
+export const getRaw = (raw: RawExpression, values: unknown[]) => {
+  values.push(...raw.__values);
+  return raw.__raw;
+};
+
+export const getRawSql = (raw: RawExpression) => {
+  return raw.__raw;
+};
+
 export type Expression<
   T extends Query = Query,
   C extends ColumnType = ColumnType,
@@ -55,36 +72,6 @@ export type ExpressionOutput<
   ? ColumnType
   : never;
 
-export const raw = <C extends ColumnType>(
-  ...args:
-    | [column: C, sql: string, ...values: unknown[]]
-    | [sql: string, ...values: unknown[]]
-) => {
-  if (typeof args[0] === 'string') {
-    return {
-      __raw: args[0],
-      __values: args.slice(1),
-    } as RawExpression<C>;
-  } else {
-    return {
-      __column: args[0],
-      __raw: args[1],
-      __values: args.slice(2),
-    } as RawExpression<C>;
-  }
-};
-
-export const isRaw = (obj: object): obj is RawExpression => '__raw' in obj;
-
-export const getRaw = (raw: RawExpression, values: unknown[]) => {
-  values.push(...raw.__values);
-  return raw.__raw;
-};
-
-export const getRawSql = (raw: RawExpression) => {
-  return raw.__raw;
-};
-
 export const EMPTY_OBJECT = {};
 
 export const getQueryParsers = (q: Query) => {

package/src/db.ts

@@ -22,6 +22,7 @@ import {
   ColumnTypesBase,
   getColumnTypes,
   SinglePrimaryKey,
+  ColumnType,
 } from './columnSchema';
 import { applyMixins, pushOrNewArray } from './utils';
 import { StringKey } from './common';
@@ -35,10 +36,11 @@ export interface Db<
   Table extends string | undefined = undefined,
   Shape extends ColumnsShape = Record<string, never>,
   Relations extends Query['relations'] = Query['relations'],
+  CT extends ColumnTypesBase = ColumnTypesBase,
 > extends QueryMethods {
   new (
     adapter: Adapter,
-    queryBuilder: Db,
+    queryBuilder: Db<Table, Shape, Relations, CT>,
     table?: Table,
     shape?: Shape,
     options?: DbTableOptions,
@@ -48,6 +50,7 @@ export interface Db<
   columns: (keyof ColumnShapeOutput<Shape>)[];
 
   queryBuilder: Db;
+  columnTypes: CT;
   whereQueryBuilder: Query['whereQueryBuilder'];
   onQueryBuilder: Query['onQueryBuilder'];
   table: Table;
@@ -91,10 +94,13 @@ export interface Db<
   >;
 }
 
+export const anyShape = {} as Record<string, ColumnType>;
+
 export class Db<
   Table extends string | undefined = undefined,
   Shape extends ColumnsShape = Record<string, never>,
   Relations extends Query['relations'] = Query['relations'],
+  CT extends ColumnTypesBase = ColumnTypesBase,
 > implements Query
 {
   whereQueryBuilder = WhereQueryBuilder;
@@ -104,10 +110,11 @@ export class Db<
     public adapter: Adapter,
     public queryBuilder: Db,
     public table: Table = undefined as Table,
-    public shape: Shape = {} as Shape,
+    public shape: Shape = anyShape as Shape,
+    public columnTypes: CT,
     options: DbTableOptions,
   ) {
-    this.__model = this;
+    this.__model = this as Query;
 
     const logger = options.logger || console;
     this.query = {
@@ -181,7 +188,12 @@ export class Db<
 applyMixins(Db, [QueryMethods]);
 Db.prototype.constructor = Db;
 
-type DbResult<CT extends ColumnTypesBase> = Db & {
+type DbResult<CT extends ColumnTypesBase> = Db<
+  string,
+  Record<string, never>,
+  Query['relations'],
+  CT
+> & {
   <Table extends string, Shape extends ColumnsShape = ColumnsShape>(
     table: Table,
     shape?: ((t: CT) => Shape) | Shape,
@@ -214,21 +226,23 @@ export const createDb = <CT extends ColumnTypesBase>({
     undefined as unknown as Db,
     undefined,
     {},
+    ct,
     commonOptions,
   );
-  qb.queryBuilder = qb;
+  qb.queryBuilder = qb as unknown as Db;
 
   const db = Object.assign(
     <Table extends string, Shape extends ColumnsShape = ColumnsShape>(
       table: Table,
       shape?: ((t: CT) => Shape) | Shape,
       options?: DbTableOptions,
-    ): Db<Table, Shape> => {
-      return new Db<Table, Shape>(
+    ): Db<Table, Shape, Query['relations'], CT> => {
+      return new Db<Table, Shape, Query['relations'], CT>(
         adapter,
-        qb,
+        qb as unknown as Db,
         table as Table,
         typeof shape === 'function' ? getColumnTypes(ct, shape) : shape,
+        ct,
         { ...commonOptions, ...options },
       );
     },
@@ -242,5 +256,5 @@ export const createDb = <CT extends ColumnTypesBase>({
       Db.prototype[name as keyof typeof Db.prototype];
   });
 
-  return db as DbResult<CT>;
+  return db as unknown as DbResult<CT>;
 };

package/src/errors.test.ts

@@ -1,6 +1,4 @@
-import { UniqueTable, User, useTestDatabase } from './test-utils';
-import { raw } from './common';
-import { columnTypes } from './columnSchema';
+import { db, UniqueTable, User, useTestDatabase } from './test-utils';
 import { QueryError } from './errors';
 
 describe('errors', () => {
@@ -10,7 +8,7 @@ describe('errors', () => {
     let err: Error | undefined;
 
     try {
-      await User.select({ column: raw(columnTypes.boolean(), 'koko') });
+      await User.select({ column: db.raw((t) => t.boolean(), 'koko') });
     } catch (error) {
       err = error as Error;
     }

package/src/index.ts

@@ -3,7 +3,6 @@ export * from './sql';
 export * from './adapter';
 export * from './common';
 export * from './db';
-export * from './columnsOperators';
 export * from './query';
 export * from './queryMethods';
 export * from './quote';
@@ -11,3 +10,4 @@ export * from './utils';
 export * from './queryDataUtils';
 export * from './errors';
 export * from './relations';
+export * from './columnsOperators';

package/src/query.ts

@@ -8,7 +8,12 @@ import {
   getValueKey,
 } from './queryMethods';
 import { QueryData } from './sql';
-import { ColumnShapeOutput, ColumnsShape, ColumnType } from './columnSchema';
+import {
+  ColumnShapeOutput,
+  ColumnsShape,
+  ColumnType,
+  ColumnTypesBase,
+} from './columnSchema';
 import { EmptyObject, Spread } from './utils';
 import { AliasOrTable, RawExpression, StringKey } from './common';
 import { Db } from './db';
@@ -43,6 +48,7 @@ export const defaultsKey: unique symbol = Symbol('defaults');
 
 export type Query = QueryMethods & {
   queryBuilder: Db;
+  columnTypes: ColumnTypesBase;
   whereQueryBuilder: typeof WhereQueryBuilder;
   onQueryBuilder: typeof OnQueryBuilder;
   table?: string;

package/src/queryMethods/aggregate.test.ts

@@ -5,8 +5,8 @@ import {
   useTestDatabase,
   userData,
   assertType,
+  db,
 } from '../test-utils';
-import { raw } from '../common';
 
 describe('aggregate', () => {
   useTestDatabase();
@@ -340,7 +340,7 @@ describe('aggregate', () => {
 
     it('should support raw sql parameter', () => {
       const q = User.all();
-      expectSql(q[method as 'count'](raw('name')).toSql(), getSql('name'));
+      expectSql(q[method as 'count'](db.raw('name')).toSql(), getSql('name'));
       expectQueryNotMutated(q);
     });
 
@@ -359,7 +359,9 @@ describe('aggregate', () => {
       const q = User.all();
       const expectedSql = getSql('name', 'name');
       expectSql(
-        q[selectMethod as 'selectCount'](raw('name'), { as: 'name' }).toSql(),
+        q[selectMethod as 'selectCount'](db.raw('name'), {
+          as: 'name',
+        }).toSql(),
         expectedSql,
       );
       expectQueryNotMutated(q);
@@ -436,7 +438,7 @@ describe('aggregate', () => {
       const q = User.clone();
       expectSql(
         q[method as 'jsonObjectAgg']({
-          alias: raw('name'),
+          alias: db.raw('name'),
         }).toSql(),
         `SELECT ${functionName}($1::text, name) FROM "user"`,
         ['alias'],
@@ -463,7 +465,7 @@ describe('aggregate', () => {
       const expectedSql = `SELECT ${functionName}($1::text, name) AS "name" FROM "user"`;
       expectSql(
         q[selectMethod as 'jsonObjectAgg'](
-          { alias: raw('name') },
+          { alias: db.raw('name') },
           { as: 'name' },
         ).toSql(),
         expectedSql,
@@ -525,7 +527,7 @@ describe('aggregate', () => {
     it('should support raw sql parameter', async () => {
       const q = User.all();
       expectSql(
-        q.stringAgg(raw('name'), ' & ').toSql(),
+        q.stringAgg(db.raw('name'), ' & ').toSql(),
         `SELECT string_agg(name, $1) FROM "user"`,
         [' & '],
       );
@@ -547,7 +549,7 @@ describe('aggregate', () => {
       const q = User.all();
       const expectedSql = `SELECT string_agg(name, $1) AS "name" FROM "user"`;
       expectSql(
-        q.stringAgg(raw('name'), ' & ', { as: 'name' }).toSql(),
+        q.stringAgg(db.raw('name'), ' & ', { as: 'name' }).toSql(),
         expectedSql,
         [' & '],
       );

package/src/queryMethods/create.test.ts

@@ -1,6 +1,7 @@
 import {
   assertType,
   Chat,
+  db,
   expectQueryNotMutated,
   expectSql,
   Message,
@@ -10,7 +11,6 @@ import {
   UserRecord,
   useTestDatabase,
 } from '../test-utils';
-import { raw } from '../common';
 import { OnConflictQueryBuilder } from './create';
 
 describe('create functions', () => {
@@ -22,7 +22,7 @@ describe('create functions', () => {
 
       const query = q.createRaw({
         columns: ['name', 'password'],
-        values: raw('raw sql'),
+        values: db.raw('raw sql'),
       });
       expectSql(
         query.toSql(),
@@ -150,6 +150,24 @@ describe('create functions', () => {
         ['name', 'override'],
       );
     });
+
+    it('should strip unknown keys', () => {
+      const query = User.create({
+        name: 'name',
+        password: 'password',
+        unknown: 'should be stripped',
+      } as unknown as UserRecord);
+
+      expectSql(
+        query.toSql(),
+        `
+          INSERT INTO "user"("name", "password")
+          VALUES ($1, $2)
+          RETURNING *
+        `,
+        ['name', 'password'],
+      );
+    });
   });
 
   describe('createMany', () => {
@@ -265,6 +283,31 @@ describe('create functions', () => {
 
       expectQueryNotMutated(q);
     });
+
+    it('should strip unknown keys', () => {
+      const query = User.createMany([
+        {
+          name: 'name',
+          password: 'password',
+          unknown: 'should be stripped',
+        },
+        {
+          name: 'name',
+          password: 'password',
+          unknown: 'should be stripped',
+        },
+      ] as unknown as UserRecord[]);
+
+      expectSql(
+        query.toSql(),
+        `
+          INSERT INTO "user"("name", "password")
+          VALUES ($1, $2), ($3, $4)
+          RETURNING *
+        `,
+        ['name', 'password', 'name', 'password'],
+      );
+    });
   });
 
   describe('createFrom', () => {
@@ -414,7 +457,7 @@ describe('create functions', () => {
         const query = q
           .count()
           .create(userData)
-          .onConflict(raw('raw query'))
+          .onConflict(db.raw('raw query'))
           .ignore();
         expectSql(
           query.toSql(),
@@ -527,8 +570,8 @@ describe('create functions', () => {
         const query = q
           .count()
           .create(userData)
-          .onConflict(raw('on conflict raw'))
-          .merge(raw('merge raw'));
+          .onConflict(db.raw('on conflict raw'))
+          .merge(db.raw('merge raw'));
 
         expectSql(
           query.toSql(),