pqb 0.4.5 → 0.4.7

package/src/queryMethods/raw.ts

@@ -0,0 +1,27 @@
+import { ColumnType, ColumnTypesBase } from '../columnSchema';
+import { Query } from '../query';
+import { RawExpression } from '../common';
+
+type RawArgs<CT extends ColumnTypesBase, C extends ColumnType> =
+  | [column: (types: CT) => C, sql: string, ...values: unknown[]]
+  | [sql: string, ...values: unknown[]];
+
+export class RawMethods {
+  raw<T extends Query, C extends ColumnType>(
+    this: T,
+    ...args: RawArgs<T['columnTypes'], C>
+  ): RawExpression<C> {
+    if (typeof args[0] === 'string') {
+      return {
+        __raw: args[0],
+        __values: args.slice(1),
+      } as RawExpression<C>;
+    } else {
+      return {
+        __column: args[0](this.columnTypes),
+        __raw: args[1],
+        __values: args.slice(2),
+      } as RawExpression<C>;
+    }
+  }
+}

package/src/queryMethods/select.test.ts

@@ -1,25 +1,16 @@
 import {
   assertType,
-  Chat,
-  chatData,
+  db,
   expectQueryNotMutated,
   expectSql,
-  Message,
-  messageData,
-  MessageRecord,
-  now,
   Profile,
   profileData,
-  ProfileRecord,
   User,
   userData,
   UserRecord,
   useTestDatabase,
 } from '../test-utils';
-import { raw } from '../common';
-import { columnTypes, DateColumn } from '../columnSchema';
-import { addQueryOn } from './join';
-import { RelationQuery, relationQueryKey } from '../relations';
+import { DateColumn } from '../columnSchema';
 
 const insertUserAndProfile = async () => {
   const id = await User.get('id').create(userData);
@@ -115,201 +106,6 @@ describe('selectMethods', () => {
       expectQueryNotMutated(q);
     });
 
-    describe('select relation', () => {
-      const profileQuery = Profile.takeOptional();
-      const profileRelationQuery = addQueryOn(
-        profileQuery,
-        User,
-        profileQuery,
-        'userId',
-        'id',
-      );
-      profileRelationQuery.query[relationQueryKey] = 'profile';
-
-      const profileRelation = new Proxy(() => undefined, {
-        get(_, key) {
-          return (
-            profileRelationQuery as unknown as Record<string | symbol, unknown>
-          )[key];
-        },
-      }) as unknown as RelationQuery<
-        'profile',
-        Record<string, unknown>,
-        never,
-        typeof profileQuery
-      >;
-
-      it('should select relation which returns one record', () => {
-        const q = User.all();
-
-        const query = q.select('id', {
-          profile: () => profileRelation.where({ bio: 'bio' }),
-        });
-
-        assertType<
-          Awaited<typeof query>,
-          { id: number; profile: typeof Profile['type'] | null }[]
-        >();
-
-        expectSql(
-          query.toSql(),
-          `
-            SELECT
-              "user"."id",
-              (
-                SELECT row_to_json("t".*)
-                FROM (
-                  SELECT *
-                  FROM "profile"
-                  WHERE "profile"."userId" = "user"."id"
-                    AND "profile"."bio" = $1
-                  LIMIT $2
-                ) AS "t"
-              ) AS "profile"
-            FROM "user"
-          `,
-          ['bio', 1],
-        );
-
-        expectQueryNotMutated(q);
-      });
-
-      it('should have proper type for required relation', () => {
-        const q = User.all();
-
-        const query = q.select('id', {
-          profile: () =>
-            profileRelation as unknown as RelationQuery<
-              'profile',
-              Record<string, unknown>,
-              never,
-              typeof profileRelationQuery,
-              true
-            >,
-        });
-
-        assertType<
-          Awaited<typeof query>,
-          { id: number; profile: typeof Profile['type'] }[]
-        >();
-      });
-
-      it('should parse columns in single relation record result', async () => {
-        const userId = await User.get('id').create(userData);
-        const now = new Date();
-        await Profile.create({ userId, updatedAt: now, createdAt: now });
-
-        const [record] = await User.select('id', {
-          profile: () => profileRelation,
-        });
-
-        assertType<
-          typeof record,
-          { id: number; profile: ProfileRecord | null }
-        >();
-
-        expect(record.profile).toMatchObject({
-          updatedAt: now,
-          createdAt: now,
-        });
-      });
-
-      const messagesQuery = Message.as('messages');
-      const messageRelationQuery = addQueryOn(
-        messagesQuery,
-        User,
-        messagesQuery,
-        'authorId',
-        'id',
-      );
-      messageRelationQuery.query[relationQueryKey] = 'messages';
-
-      const messageRelation = new Proxy(() => undefined, {
-        get(_, key) {
-          return (
-            messageRelationQuery as unknown as Record<string | symbol, unknown>
-          )[key];
-        },
-      }) as unknown as RelationQuery<
-        'messages',
-        Record<string, unknown>,
-        never,
-        typeof messageRelationQuery
-      >;
-
-      it('should select relation which returns many records', () => {
-        const q = User.all();
-
-        const query = q.select('id', {
-          messages: () => messageRelation.where({ text: 'text' }),
-        });
-
-        assertType<
-          Awaited<typeof query>,
-          { id: number; messages: typeof Message['type'][] }[]
-        >();
-
-        expectSql(
-          query.toSql(),
-          `
-            SELECT
-              "user"."id",
-              (
-                SELECT COALESCE(json_agg(row_to_json("t".*)), '[]')
-                FROM (
-                  SELECT *
-                  FROM "message" AS "messages"
-                  WHERE "messages"."authorId" = "user"."id"
-                    AND "messages"."text" = $1
-                ) AS "t"
-              ) AS "messages"
-            FROM "user"
-          `,
-          ['text'],
-        );
-
-        expectQueryNotMutated(q);
-      });
-
-      it('should parse columns in multiple relation records result', async () => {
-        const { id: authorId } = await User.select('id').create(userData);
-        const { id: chatId } = await Chat.select('id').create(chatData);
-        await Message.create({
-          authorId,
-          chatId,
-          ...messageData,
-          createdAt: now,
-          updatedAt: now,
-        });
-
-        const [record] = await User.select('id', {
-          messages: () => messageRelation,
-        });
-
-        assertType<typeof record, { id: number; messages: MessageRecord[] }>();
-
-        expect(record.messages[0]).toMatchObject({
-          updatedAt: now,
-          createdAt: now,
-        });
-      });
-
-      it('should have proper type for conditional sub queries', async () => {
-        const condition = true;
-
-        const query = User.select('id', {
-          hasProfile: condition
-            ? () => profileRelation.exists()
-            : raw(columnTypes.boolean(), 'true'),
-        });
-
-        assertType<
-          Awaited<typeof query>,
-          { id: number; hasProfile: boolean }[]
-        >();
-      });
-    });
-
     describe('parse columns', () => {
       beforeEach(insertUserAndProfile);
 
@@ -440,7 +236,7 @@ describe('selectMethods', () => {
 
     it('can select raw', () => {
       const q = User.all();
-      const query = q.select({ one: raw('1') });
+      const query = q.select({ one: db.raw('1') });
 
       assertType<Awaited<typeof query>, { one: unknown }[]>();
 
@@ -549,8 +345,8 @@ describe('selectMethods', () => {
 
     it('should parse raw column', async () => {
       const q = User.select({
-        date: raw(
-          new DateColumn().parse((input) => new Date(input)),
+        date: db.raw(
+          () => new DateColumn().parse((input) => new Date(input)),
           '"createdAt"',
         ),
       });

package/src/queryMethods/then.test.ts

@@ -1,6 +1,4 @@
-import { assertType, User, useTestDatabase } from '../test-utils';
-import { raw } from '../common';
-import { columnTypes } from '../columnSchema';
+import { assertType, db, User, useTestDatabase } from '../test-utils';
 
 describe('then', () => {
   useTestDatabase();
@@ -8,7 +6,7 @@ describe('then', () => {
   describe('catch', () => {
     it('should catch error', (done) => {
       const query = User.select({
-        column: raw(columnTypes.boolean(), 'koko'),
+        column: db.raw((t) => t.boolean(), 'koko'),
       }).catch((err) => {
         expect(err.message).toBe(`column "koko" does not exist`);
         done();

package/src/queryMethods/union.test.ts

@@ -1,5 +1,10 @@
-import { Chat, expectQueryNotMutated, expectSql, User } from '../test-utils';
-import { raw } from '../common';
+import {
+  Chat,
+  db,
+  expectQueryNotMutated,
+  expectSql,
+  User,
+} from '../test-utils';
 
 ['union', 'intersect', 'except'].forEach((what) => {
   const upper = what.toUpperCase();
@@ -7,10 +12,10 @@ import { raw } from '../common';
     it(`adds ${what}`, () => {
       const q = User.all();
       let query = q.select('id');
-      query = query[what as 'union']([Chat.select('id'), raw('SELECT 1')]);
+      query = query[what as 'union']([Chat.select('id'), db.raw('SELECT 1')]);
       query = query[
         (what + 'All') as 'unionAll' | 'intersectAll' | 'exceptAll'
-      ]([raw('SELECT 2')], true);
+      ]([db.raw('SELECT 2')], true);
 
       const wrapped = query.wrap(User.select('id'));
 
@@ -34,7 +39,7 @@ import { raw } from '../common';
 
     it('has modifier', () => {
       const q = User.select('id');
-      q[`_${what}` as '_union']([raw('SELECT 1')]);
+      q[`_${what}` as '_union']([db.raw('SELECT 1')]);
       expectSql(
         q.toSql(),
         `
@@ -43,7 +48,7 @@ import { raw } from '../common';
           SELECT 1
         `,
       );
-      q[`_${what}All` as '_unionAll']([raw('SELECT 2')], true);
+      q[`_${what}All` as '_unionAll']([db.raw('SELECT 2')], true);
       expectSql(
         q.toSql({ clearCache: true }),
         `

package/src/queryMethods/update.test.ts

@@ -1,12 +1,12 @@
 import {
   assertType,
+  db,
   expectQueryNotMutated,
   expectSql,
   User,
   userData,
   useTestDatabase,
 } from '../test-utils';
-import { raw } from '../common';
 
 describe('update', () => {
   useTestDatabase();
@@ -37,7 +37,7 @@ describe('update', () => {
     const count = 2;
     const users = await User.select('id').createMany([userData, userData]);
 
-    const query = User.or(...users).updateRaw(raw(`name = 'name'`));
+    const query = User.or(...users).updateRaw(db.raw(`name = 'name'`));
     expectSql(
       query.toSql(),
       `
@@ -254,7 +254,7 @@ describe('update', () => {
 
   it('should support raw sql as a value', () => {
     const query = User.where({ id: 1 }).update({
-      name: raw(`'raw sql'`),
+      name: db.raw(`'raw sql'`),
     });
     expectSql(
       query.toSql(),