pqb 0.4.5 → 0.4.7

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

@@ -35,10 +35,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 +49,7 @@ export interface Db<
   columns: (keyof ColumnShapeOutput<Shape>)[];
 
   queryBuilder: Db;
+  columnTypes: CT;
   whereQueryBuilder: Query['whereQueryBuilder'];
   onQueryBuilder: Query['onQueryBuilder'];
   table: Table;
@@ -95,6 +97,7 @@ 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;
@@ -105,9 +108,10 @@ export class Db<
     public queryBuilder: Db,
     public table: Table = undefined as Table,
     public shape: Shape = {} as Shape,
+    public columnTypes: CT,
     options: DbTableOptions,
   ) {
-    this.__model = this;
+    this.__model = this as Query;
 
     const logger = options.logger || console;
     this.query = {
@@ -181,7 +185,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 +223,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 +253,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(),
@@ -414,7 +414,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 +527,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(),

package/src/queryMethods/create.ts

@@ -8,7 +8,6 @@ import {
   SetQueryReturnsOne,
 } from '../query';
 import { pushQueryArray } from '../queryDataUtils';
-import { RawExpression } from '../common';
 import {
   BelongsToNestedInsert,
   BelongsToRelation,
@@ -26,6 +25,7 @@ import { InsertQueryData, OnConflictItem, OnConflictMergeUpdate } from '../sql';
 import { WhereArg } from './where';
 import { parseResult, queryMethodByReturnType } from './then';
 import { NotFoundError } from '../errors';
+import { RawExpression } from '../common';
 
 export type CreateData<
   T extends Query,

package/src/queryMethods/delete.ts

@@ -1,5 +1,7 @@
 import { Query, SetQueryReturnsRowCount } from '../query';
 
+export type DeleteMethodsNames = 'del' | '_del' | 'delete' | '_delete';
+
 type DeleteArgs<T extends Query> = T['hasWhere'] extends true
   ? [forceAll?: boolean]
   : [true];

package/src/queryMethods/for.test.ts

@@ -1,5 +1,4 @@
 import { expectQueryNotMutated, expectSql, User } from '../test-utils';
-import { raw } from '../common';
 
 describe('for', () => {
   describe.each`
@@ -30,7 +29,7 @@ describe('for', () => {
     it('should accept raw sql', () => {
       const q = User.all();
       expectSql(
-        q[method as 'forUpdate'](raw('raw sql')).toSql(),
+        q[method as 'forUpdate'](User.raw('raw sql')).toSql(),
         `SELECT * FROM "user" FOR ${sql} OF raw sql`,
       );
       expectQueryNotMutated(q);

package/src/queryMethods/for.ts

@@ -1,6 +1,6 @@
 import { Query } from '../query';
-import { RawExpression } from '../common';
 import { SelectQueryData } from '../sql';
+import { RawExpression } from '../common';
 
 type ForQueryBuilder<Q extends Query> = Q & {
   noWait<T extends ForQueryBuilder<Q>>(this: T): T;

package/src/queryMethods/from.test.ts

@@ -1,5 +1,4 @@
-import { expectQueryNotMutated, expectSql, User } from '../test-utils';
-import { raw } from '../common';
+import { db, expectQueryNotMutated, expectSql, User } from '../test-utils';
 
 describe('from', () => {
   it('should accept string parameter', () => {
@@ -20,7 +19,7 @@ describe('from', () => {
   it('should accept raw parameter', () => {
     const q = User.all();
     expectSql(
-      q.as('t').from(raw('profile')).toSql(),
+      q.as('t').from(db.raw('profile')).toSql(),
       `SELECT * FROM profile AS "t"`,
     );
     expectQueryNotMutated(q);

package/src/queryMethods/get.test.ts

@@ -1,7 +1,5 @@
-import { assertType, User, userData, useTestDatabase } from '../test-utils';
-import { NumberColumn } from '../columnSchema';
+import { assertType, db, User, userData, useTestDatabase } from '../test-utils';
 import { NotFoundError } from '../errors';
-import { raw } from '../common';
 
 describe('get', () => {
   useTestDatabase();
@@ -18,7 +16,9 @@ describe('get', () => {
     });
 
     it('should select raw and return a single value', async () => {
-      const received = await User.get(raw<NumberColumn>('count(*)::int'));
+      const received = await User.get(
+        db.raw((t) => t.integer(), 'count(*)::int'),
+      );
 
       assertType<typeof received, number>();
 
@@ -43,7 +43,7 @@ describe('get', () => {
 
     it('should select raw and return a single value when exists', async () => {
       const received = await User.getOptional(
-        raw<NumberColumn>('count(*)::int'),
+        db.raw((t) => t.integer(), 'count(*)::int'),
       );
 
       assertType<typeof received, number | undefined>();

package/src/queryMethods/having.test.ts

@@ -1,5 +1,4 @@
-import { expectQueryNotMutated, expectSql, User } from '../test-utils';
-import { raw } from '../common';
+import { db, expectQueryNotMutated, expectSql, User } from '../test-utils';
 
 describe('having', () => {
   it('should support { count: value } object', () => {
@@ -196,12 +195,12 @@ describe('having', () => {
     `;
 
     expectSql(
-      q.having(raw('count(*) = 1'), raw('sum(id) = 2')).toSql(),
+      q.having(db.raw('count(*) = 1'), db.raw('sum(id) = 2')).toSql(),
       expectedSql,
     );
     expectQueryNotMutated(q);
 
-    q._having(raw('count(*) = 1'), raw('sum(id) = 2'));
+    q._having(db.raw('count(*) = 1'), db.raw('sum(id) = 2'));
     expectSql(q.toSql({ clearCache: true }), expectedSql);
   });
 
@@ -235,7 +234,9 @@ describe('having', () => {
     it('should accept raw sql', () => {
       const q = User.all();
       expectSql(
-        q.havingOr(raw('count(*) = 1 + 2'), raw('count(*) = 2 + 3')).toSql(),
+        q
+          .havingOr(db.raw('count(*) = 1 + 2'), db.raw('count(*) = 2 + 3'))
+          .toSql(),
         `
         SELECT * FROM "user"
         HAVING count(*) = 1 + 2 OR count(*) = 2 + 3

package/src/queryMethods/index.ts

@@ -21,3 +21,4 @@ export * from './update';
 export * from './upsert';
 export * from './where';
 export * from './with';
+export * from './raw';

package/src/queryMethods/json.ts

@@ -7,7 +7,7 @@ import {
 import { pushQueryValue } from '../queryDataUtils';
 import { ColumnType, StringColumn } from '../columnSchema';
 import { JsonItem } from '../sql';
-import { raw, StringKey } from '../common';
+import { StringKey } from '../common';
 
 type JsonColumnName<T extends Pick<Query, 'selectable'>> = StringKey<
   {
@@ -55,7 +55,7 @@ export class Json {
   ): SetQueryReturnsValueOptional<T, StringColumn> {
     const q = this._wrap(this.__model.clone()) as T;
     q._getOptional(
-      raw<StringColumn>(
+      this.raw<Query, StringColumn>(
         queryTypeWithLimitOne[this.query.returnType]
           ? `row_to_json("t".*)`
           : `COALESCE(json_agg(row_to_json("t".*)), '[]')`,

package/src/queryMethods/merge.test.ts

@@ -1,4 +1,11 @@
-import { assertType, expectSql, Message, Profile, User } from '../test-utils';
+import {
+  assertType,
+  db,
+  expectSql,
+  Message,
+  Profile,
+  User,
+} from '../test-utils';
 import { QueryReturnType } from '../query';
 import { IntegerColumn, TextColumn } from '../columnSchema';
 import { getValueKey } from './get';
@@ -11,7 +18,6 @@ import {
   TruncateQueryData,
   UpdateQueryData,
 } from '../sql';
-import { raw } from '../common';
 
 describe('merge queries', () => {
   describe('select', () => {
@@ -350,8 +356,8 @@ describe('merge queries', () => {
       s2.having = [{ b: { b: 2 } }];
       s1.havingOr = [[{ a: { a: 1 } }]];
       s2.havingOr = [[{ b: { b: 2 } }]];
-      s1.union = [{ arg: raw('a'), kind: 'UNION' }];
-      s2.union = [{ arg: raw('b'), kind: 'EXCEPT' }];
+      s1.union = [{ arg: db.raw('a'), kind: 'UNION' }];
+      s2.union = [{ arg: db.raw('b'), kind: 'EXCEPT' }];
       s1.order = [{ id: 'ASC' }];
       s2.order = [{ name: 'DESC' }];
       s1.limit = 1;

package/src/queryMethods/queryMethods.test.ts

@@ -1,4 +1,3 @@
-import { raw } from '../common';
 import {
   expectQueryNotMutated,
   adapter,
@@ -12,7 +11,6 @@ import {
   assertType,
   UserRecord,
 } from '../test-utils';
-import { NumberColumn } from '../columnSchema';
 import { NotFoundError } from '../errors';
 
 describe('queryMethods', () => {
@@ -126,7 +124,7 @@ describe('queryMethods', () => {
     });
 
     it('should support raw expression', async () => {
-      const result = await User.pluck(raw<NumberColumn>('123'));
+      const result = await User.pluck(db.raw((t) => t.integer(), '123'));
       expect(result).toEqual([123, 123, 123]);
 
       assertType<typeof result, number[]>();
@@ -206,7 +204,7 @@ describe('queryMethods', () => {
     it('should add distinct on raw sql', () => {
       const q = User.all();
       expectSql(
-        q.distinct(raw('"user".id')).toSql(),
+        q.distinct(db.raw('"user".id')).toSql(),
         `
           SELECT DISTINCT ON ("user".id) * FROM "user"
         `,
@@ -236,7 +234,7 @@ describe('queryMethods', () => {
 
     it('should accept raw sql', () => {
       const q = User.all();
-      const query = q.find(raw('$1 + $2', 1, 2));
+      const query = q.find(db.raw('$1 + $2', 1, 2));
 
       assertType<Awaited<typeof query>, UserRecord>();
 
@@ -274,7 +272,7 @@ describe('queryMethods', () => {
 
     it('should accept raw sql', () => {
       const q = User.all();
-      const query = q.findOptional(raw('$1 + $2', 1, 2));
+      const query = q.findOptional(db.raw('$1 + $2', 1, 2));
 
       assertType<Awaited<typeof query>, UserRecord | undefined>();
 
@@ -305,7 +303,7 @@ describe('queryMethods', () => {
     it('should accept raw', () => {
       const q = User.all();
       expectSql(
-        q.findBy({ name: raw(`'string'`) }).toSql(),
+        q.findBy({ name: db.raw(`'string'`) }).toSql(),
         `SELECT * FROM "user" WHERE "user"."name" = 'string' LIMIT $1`,
         [1],
       );
@@ -330,7 +328,7 @@ describe('queryMethods', () => {
 
     it('should accept raw', () => {
       const q = User.all();
-      const query = q.findByOptional({ name: raw(`'string'`) });
+      const query = q.findByOptional({ name: db.raw(`'string'`) });
 
       assertType<Awaited<typeof query>, UserRecord | undefined>();
 
@@ -431,10 +429,10 @@ describe('queryMethods', () => {
         SELECT * FROM "user"
         GROUP BY id, name
       `;
-      expectSql(q.group(raw('id'), raw('name')).toSql(), expectedSql);
+      expectSql(q.group(db.raw('id'), db.raw('name')).toSql(), expectedSql);
       expectQueryNotMutated(q);
 
-      q._group(raw('id'), raw('name'));
+      q._group(db.raw('id'), db.raw('name'));
       expectSql(q.toSql({ clearCache: true }), expectedSql);
     });
   });
@@ -471,7 +469,7 @@ describe('queryMethods', () => {
       const windowSql = 'PARTITION BY id ORDER BY name DESC';
       expectSql(
         q
-          .window({ w: raw(windowSql) })
+          .window({ w: db.raw(windowSql) })
           .selectAvg('id', {
             over: 'w',
           })
@@ -527,7 +525,7 @@ describe('queryMethods', () => {
     it('adds order with raw sql', () => {
       const q = User.all();
       expectSql(
-        q.order(raw('id ASC NULLS FIRST')).toSql(),
+        q.order(db.raw('id ASC NULLS FIRST')).toSql(),
         `
         SELECT * FROM "user"
         ORDER BY id ASC NULLS FIRST

package/src/queryMethods/queryMethods.ts

@@ -1,4 +1,4 @@
-import { Expression, raw, RawExpression } from '../common';
+import { Expression, RawExpression } from '../common';
 import {
   Query,
   QueryBase,
@@ -48,6 +48,7 @@ import { QueryCallbacks } from './callbacks';
 import { QueryUpsert } from './upsert';
 import { QueryGet } from './get';
 import { MergeQueryMethods } from './merge';
+import { RawMethods } from './raw';
 
 export type WindowArg<T extends Query> = Record<
   string,
@@ -96,7 +97,8 @@ export interface QueryMethods
     QueryCallbacks,
     QueryUpsert,
     QueryGet,
-    MergeQueryMethods {}
+    MergeQueryMethods,
+    RawMethods {}
 
 export class QueryMethods {
   windows!: EmptyObject;
@@ -309,7 +311,7 @@ export class QueryMethods {
     return query
       .as(as ?? 't')
       ._from(
-        raw(`(${sql.text})`, ...sql.values),
+        this.raw(`(${sql.text})`, ...sql.values),
       ) as unknown as SetQueryTableAlias<Q, As>;
   }
 
@@ -344,7 +346,7 @@ export class QueryMethods {
   }
 
   _exists<T extends Query>(this: T): SetQueryReturnsValue<T, BooleanColumn> {
-    const q = this._getOptional(raw<BooleanColumn>('true'));
+    const q = this._getOptional(this.raw<Query, BooleanColumn>('true'));
     q.query.notFoundDefault = false;
     q.query.coalesceValue = false;
     return q as unknown as SetQueryReturnsValue<T, BooleanColumn>;
@@ -397,4 +399,5 @@ applyMixins(QueryMethods, [
   QueryUpsert,
   QueryGet,
   MergeQueryMethods,
+  RawMethods,
 ]);

package/src/queryMethods/raw.test.ts

@@ -0,0 +1,19 @@
+import { ColumnType } from '../columnSchema';
+import { createDb } from '../db';
+import { adapter } from '../test-utils';
+
+describe('raw', () => {
+  it('should use column types in callback from a db instance', () => {
+    const type = {} as unknown as ColumnType;
+    const db = createDb({
+      adapter,
+      columnTypes: {
+        type: () => type,
+      },
+    });
+
+    const value = db.raw((t) => t.type(), 'sql');
+
+    expect(value.__column).toBe(type);
+  });
+});