orchid-orm 0.0.1

package/src/relations/belongsTo.test.ts

@@ -0,0 +1,890 @@
+import { db } from '../test-utils/test-db';
+import {
+  assertType,
+  chatData,
+  expectSql,
+  messageData,
+  profileData,
+  userData,
+  useTestDatabase,
+} from '../test-utils/test-utils';
+import { RelationQuery } from 'pqb';
+import { User } from '../test-utils/test-models';
+
+describe('belongsTo', () => {
+  useTestDatabase();
+
+  describe('querying', () => {
+    it('should have method to query related data', async () => {
+      const userQuery = db.user.take();
+      type UserQuery = typeof userQuery;
+
+      assertType<
+        typeof db.profile.user,
+        RelationQuery<'user', { userId: number | null }, never, UserQuery, true>
+      >();
+
+      const userId = await db.user.get('id').create(userData);
+      const profileId = await db.profile
+        .get('id')
+        .create({ ...profileData, userId });
+
+      const profile = await db.profile.find(profileId);
+      const query = db.profile.user(profile);
+
+      expectSql(
+        query.toSql(),
+        `
+        SELECT * FROM "user"
+        WHERE "user"."id" = $1
+        LIMIT $2
+      `,
+        [userId, 1],
+      );
+
+      const user = await query;
+
+      expect(user).toMatchObject(userData);
+    });
+
+    it('should handle chained query', () => {
+      const query = db.profile
+        .where({ bio: 'bio' })
+        .user.where({ name: 'name' });
+
+      expectSql(
+        query.toSql(),
+        `
+          SELECT * FROM "user"
+          WHERE EXISTS (
+                  SELECT 1 FROM "profile"
+                  WHERE "profile"."bio" = $1
+                    AND "profile"."userId" = "user"."id"
+                  LIMIT 1
+                )
+            AND "user"."name" = $2
+          LIMIT $3
+        `,
+        ['bio', 'name', 1],
+      );
+    });
+
+    it('should have disabled create and delete method', () => {
+      // @ts-expect-error belongsTo should not have chained create
+      db.profile.user.create(userData);
+
+      // @ts-expect-error belongsTo should not have chained create
+      db.profile.user.find(1).delete();
+    });
+
+    it('should have proper joinQuery', () => {
+      expectSql(
+        db.profile.relations.user
+          .joinQuery(db.profile.as('p'), db.user.as('u'))
+          .toSql(),
+        `
+          SELECT * FROM "user" AS "u"
+          WHERE "u"."id" = "p"."userId"
+        `,
+      );
+    });
+
+    it('should be supported in whereExists', () => {
+      expectSql(
+        db.profile.whereExists('user').toSql(),
+        `
+          SELECT * FROM "profile"
+          WHERE EXISTS (
+            SELECT 1 FROM "user"
+            WHERE "user"."id" = "profile"."userId"
+            LIMIT 1
+          )
+        `,
+      );
+
+      expectSql(
+        db.profile
+          .as('p')
+          .whereExists('user', (q) => q.where({ name: 'name' }))
+          .toSql(),
+        `
+        SELECT * FROM "profile" AS "p"
+        WHERE EXISTS (
+          SELECT 1 FROM "user"
+          WHERE "user"."id" = "p"."userId"
+            AND "user"."name" = $1
+          LIMIT 1
+        )
+      `,
+        ['name'],
+      );
+    });
+
+    it('should support nested whereExists', () => {
+      expectSql(
+        db.message
+          .as('m')
+          .whereExists('user', (q) =>
+            q.whereExists('profile', (q) => q.where({ bio: 'bio' })),
+          )
+          .toSql(),
+        `
+          SELECT * FROM "message" AS "m"
+          WHERE EXISTS (
+            SELECT 1 FROM "user"
+            WHERE "user"."id" = "m"."authorId"
+              AND EXISTS (
+                SELECT 1 FROM "profile"
+                WHERE "profile"."userId" = "user"."id"
+                  AND "profile"."bio" = $1
+                LIMIT 1
+              )
+            LIMIT 1
+          )
+        `,
+        ['bio'],
+      );
+    });
+
+    it('should be supported in join', () => {
+      const query = db.profile
+        .as('p')
+        .join('user', (q) => q.where({ name: 'name' }))
+        .select('bio', 'user.name');
+
+      assertType<
+        Awaited<typeof query>,
+        { bio: string | null; name: string }[]
+      >();
+
+      expectSql(
+        query.toSql(),
+        `
+        SELECT "p"."bio", "user"."name"
+        FROM "profile" AS "p"
+        JOIN "user" ON "user"."id" = "p"."userId" AND "user"."name" = $1
+      `,
+        ['name'],
+      );
+    });
+
+    describe('select', () => {
+      it('should be selectable', async () => {
+        const query = db.profile.as('p').select('id', {
+          user: (q) => q.user.select('id', 'name').where({ name: 'name' }),
+        });
+
+        assertType<
+          Awaited<typeof query>,
+          { id: number; user: { id: number; name: string } }[]
+        >();
+
+        expectSql(
+          query.toSql(),
+          `
+            SELECT
+              "p"."id",
+              (
+                SELECT row_to_json("t".*)
+                FROM (
+                  SELECT "user"."id", "user"."name" FROM "user"
+                  WHERE "user"."name" = $1
+                    AND "user"."id" = "p"."userId"
+                  LIMIT $2
+                ) AS "t"
+              ) AS "user"
+            FROM "profile" AS "p"
+          `,
+          ['name', 1],
+        );
+      });
+
+      it('should be selectable by relation name', async () => {
+        const query = db.profile.select('id', 'user');
+
+        assertType<Awaited<typeof query>, { id: number; user: User }[]>();
+
+        expectSql(
+          query.toSql(),
+          `
+            SELECT
+              "profile"."id",
+              (
+                SELECT row_to_json("t".*)
+                FROM (
+                  SELECT * FROM "user"
+                  WHERE "user"."id" = "profile"."userId"
+                  LIMIT $1
+                ) AS "t"
+              ) AS "user"
+            FROM "profile"
+          `,
+          [1],
+        );
+      });
+
+      it('should handle exists sub query', async () => {
+        const query = db.profile.as('p').select('id', {
+          hasUser: (q) => q.user.exists(),
+        });
+
+        assertType<Awaited<typeof query>, { id: number; hasUser: boolean }[]>();
+
+        expectSql(
+          query.toSql(),
+          `
+            SELECT
+              "p"."id",
+              COALESCE((
+                SELECT true
+                FROM "user"
+                WHERE "user"."id" = "p"."userId"
+              ), false) AS "hasUser"
+            FROM "profile" AS "p"
+          `,
+        );
+      });
+    });
+  });
+
+  describe('create', () => {
+    const checkCreatedResults = async ({
+      messageId,
+      chatId,
+      authorId,
+      text,
+      title,
+      name,
+    }: {
+      messageId: number;
+      chatId: number;
+      authorId: number | null;
+      text: string;
+      title: string;
+      name: string;
+    }) => {
+      const message = await db.message.find(messageId);
+      expect(message).toEqual({
+        ...message,
+        ...messageData,
+        chatId,
+        authorId,
+        text,
+      });
+
+      const chat = await db.chat.find(chatId);
+      expect(chat).toEqual({
+        ...chat,
+        ...chatData,
+        title,
+      });
+
+      if (!authorId) return;
+      const user = await db.user.find(authorId);
+      expect(user).toEqual({
+        ...user,
+        ...userData,
+        active: null,
+        age: null,
+        data: null,
+        picture: null,
+        name,
+      });
+    };
+
+    describe('nested create', () => {
+      it('should support create', async () => {
+        const {
+          id: messageId,
+          chatId,
+          authorId,
+        } = await db.message.select('id', 'chatId', 'authorId').create({
+          ...messageData,
+          text: 'message',
+          chat: {
+            create: {
+              ...chatData,
+              title: 'chat',
+            },
+          },
+          user: {
+            create: {
+              ...userData,
+              name: 'user',
+            },
+          },
+        });
+
+        await checkCreatedResults({
+          messageId,
+          chatId,
+          authorId,
+          text: 'message',
+          title: 'chat',
+          name: 'user',
+        });
+      });
+
+      it('should support create in batch create', async () => {
+        const query = db.message.select('id', 'chatId', 'authorId').createMany([
+          {
+            ...messageData,
+            text: 'message 1',
+            chat: {
+              create: {
+                ...chatData,
+                title: 'chat 1',
+              },
+            },
+            user: {
+              create: {
+                ...userData,
+                name: 'user 1',
+              },
+            },
+          },
+          {
+            ...messageData,
+            text: 'message 2',
+            chat: {
+              create: {
+                ...chatData,
+                title: 'chat 2',
+              },
+            },
+            user: {
+              create: {
+                ...userData,
+                name: 'user 2',
+              },
+            },
+          },
+        ]);
+
+        const [first, second] = await query;
+
+        await checkCreatedResults({
+          messageId: first.id,
+          chatId: first.chatId,
+          authorId: first.authorId,
+          text: 'message 1',
+          title: 'chat 1',
+          name: 'user 1',
+        });
+
+        await checkCreatedResults({
+          messageId: second.id,
+          chatId: second.chatId,
+          authorId: second.authorId,
+          text: 'message 2',
+          title: 'chat 2',
+          name: 'user 2',
+        });
+      });
+    });
+
+    describe('connect', () => {
+      it('should support connect', async () => {
+        await db.chat.create({ ...chatData, title: 'chat' });
+        await db.user.create({ ...userData, name: 'user' });
+
+        const query = db.message.select('id', 'chatId', 'authorId').create({
+          ...messageData,
+          text: 'message',
+          chat: {
+            connect: { title: 'chat' },
+          },
+          user: {
+            connect: { name: 'user' },
+          },
+        });
+
+        const { id: messageId, chatId, authorId } = await query;
+
+        await checkCreatedResults({
+          messageId,
+          chatId,
+          authorId,
+          text: 'message',
+          title: 'chat',
+          name: 'user',
+        });
+      });
+
+      it('should support connect in batch create', async () => {
+        await db.chat.createMany([
+          { ...chatData, title: 'chat 1' },
+          { ...chatData, title: 'chat 2' },
+        ]);
+        await db.user.createMany([
+          { ...userData, name: 'user 1' },
+          { ...userData, name: 'user 2' },
+        ]);
+
+        const query = db.message.select('id', 'chatId', 'authorId').createMany([
+          {
+            ...messageData,
+            text: 'message 1',
+            chat: {
+              connect: { title: 'chat 1' },
+            },
+            user: {
+              connect: { name: 'user 1' },
+            },
+          },
+          {
+            ...messageData,
+            text: 'message 2',
+            chat: {
+              connect: { title: 'chat 2' },
+            },
+            user: {
+              connect: { name: 'user 2' },
+            },
+          },
+        ]);
+
+        const [first, second] = await query;
+
+        await checkCreatedResults({
+          messageId: first.id,
+          chatId: first.chatId,
+          authorId: first.authorId,
+          text: 'message 1',
+          title: 'chat 1',
+          name: 'user 1',
+        });
+
+        await checkCreatedResults({
+          messageId: second.id,
+          chatId: second.chatId,
+          authorId: second.authorId,
+          text: 'message 2',
+          title: 'chat 2',
+          name: 'user 2',
+        });
+      });
+    });
+
+    describe('connectOrCreate', () => {
+      it('should support connect or create', async () => {
+        const chat = await db.chat.select('id').create({
+          ...chatData,
+          title: 'chat',
+        });
+
+        const query = await db.message
+          .select('id', 'chatId', 'authorId')
+          .create({
+            ...messageData,
+            text: 'message',
+            chat: {
+              connectOrCreate: {
+                where: { title: 'chat' },
+                create: { ...chatData, title: 'chat' },
+              },
+            },
+            user: {
+              connectOrCreate: {
+                where: { name: 'user' },
+                create: { ...userData, name: 'user' },
+              },
+            },
+          });
+
+        const { id: messageId, chatId, authorId } = await query;
+
+        expect(chatId).toBe(chat.id);
+
+        await checkCreatedResults({
+          messageId,
+          chatId,
+          authorId,
+          text: 'message',
+          title: 'chat',
+          name: 'user',
+        });
+      });
+
+      it('should support connect or create in batch create', async () => {
+        const chat = await db.chat.select('id').create({
+          ...chatData,
+          title: 'chat 1',
+        });
+        const user = await db.user.select('id').create({
+          ...userData,
+          name: 'user 2',
+        });
+
+        const query = await db.message
+          .select('id', 'chatId', 'authorId')
+          .createMany([
+            {
+              ...messageData,
+              text: 'message 1',
+              chat: {
+                connectOrCreate: {
+                  where: { title: 'chat 1' },
+                  create: { ...chatData, title: 'chat 1' },
+                },
+              },
+              user: {
+                connectOrCreate: {
+                  where: { name: 'user 1' },
+                  create: { ...userData, name: 'user 1' },
+                },
+              },
+            },
+            {
+              ...messageData,
+              text: 'message 2',
+              chat: {
+                connectOrCreate: {
+                  where: { title: 'chat 2' },
+                  create: { ...chatData, title: 'chat 2' },
+                },
+              },
+              user: {
+                connectOrCreate: {
+                  where: { name: 'user 2' },
+                  create: { ...userData, name: 'user 2' },
+                },
+              },
+            },
+          ]);
+
+        const [first, second] = await query;
+
+        expect(first.chatId).toBe(chat.id);
+        expect(second.authorId).toBe(user.id);
+
+        await checkCreatedResults({
+          messageId: first.id,
+          chatId: first.chatId,
+          authorId: first.authorId,
+          text: 'message 1',
+          title: 'chat 1',
+          name: 'user 1',
+        });
+
+        await checkCreatedResults({
+          messageId: second.id,
+          chatId: second.chatId,
+          authorId: second.authorId,
+          text: 'message 2',
+          title: 'chat 2',
+          name: 'user 2',
+        });
+      });
+    });
+  });
+
+  describe('update', () => {
+    describe('disconnect', () => {
+      it('should nullify foreignKey', async () => {
+        const id = await db.profile
+          .get('id')
+          .create({ ...profileData, user: { create: userData } });
+
+        const profile = await db.profile
+          .select('userId')
+          .find(id)
+          .update({
+            bio: 'string',
+            user: { disconnect: true },
+          });
+
+        expect(profile.userId).toBe(null);
+      });
+
+      it('should nullify foreignKey in batch update', async () => {
+        const ids = await db.profile.pluck('id').createMany([
+          { ...profileData, user: { create: userData } },
+          { ...profileData, user: { create: userData } },
+        ]);
+
+        const userIds = await db.profile
+          .pluck('userId')
+          .where({ id: { in: ids } })
+          .update({
+            bio: 'string',
+            user: { disconnect: true },
+          });
+
+        expect(userIds).toEqual([null, null]);
+      });
+    });
+
+    describe('set', () => {
+      it('should set foreignKey of current record with provided primaryKey', async () => {
+        const id = await db.profile.get('id').create(profileData);
+        const user = await db.user.select('id').create(userData);
+
+        const profile = await db.profile
+          .selectAll()
+          .find(id)
+          .update({
+            user: {
+              set: user,
+            },
+          });
+
+        expect(profile.userId).toBe(user.id);
+      });
+
+      it('should set foreignKey of current record from found related record', async () => {
+        const id = await db.profile.get('id').create(profileData);
+        const user = await db.user.select('id').create({
+          ...userData,
+          name: 'user',
+        });
+
+        const profile = await db.profile
+          .selectAll()
+          .find(id)
+          .update({
+            user: {
+              set: { name: 'user' },
+            },
+          });
+
+        expect(profile.userId).toBe(user.id);
+      });
+
+      it('should set foreignKey of current record with provided primaryKey in batch update', async () => {
+        const profileIds = await db.profile
+          .pluck('id')
+          .createMany([profileData, profileData]);
+        const user = await db.user.select('id').create(userData);
+
+        const updatedUserIds = await db.profile
+          .pluck('userId')
+          .where({ id: { in: profileIds } })
+          .update({
+            user: {
+              set: user,
+            },
+          });
+
+        expect(updatedUserIds).toEqual([user.id, user.id]);
+      });
+
+      it('should set foreignKey of current record from found related record in batch update', async () => {
+        const profileIds = await db.profile
+          .pluck('id')
+          .createMany([profileData, profileData]);
+        const user = await db.user.select('id').create({
+          ...userData,
+          name: 'user',
+        });
+
+        const updatedUserIds = await db.profile
+          .pluck('userId')
+          .where({ id: { in: profileIds } })
+          .update({
+            user: {
+              set: { name: 'user' },
+            },
+          });
+
+        expect(updatedUserIds).toEqual([user.id, user.id]);
+      });
+    });
+
+    describe('delete', () => {
+      it('should nullify foreignKey and delete related record', async () => {
+        const { id, userId } = await db.profile
+          .select('id', 'userId')
+          .create({ ...profileData, user: { create: userData } });
+
+        const profile = await db.profile
+          .select('userId')
+          .find(id)
+          .update({
+            user: {
+              delete: true,
+            },
+          });
+
+        expect(profile.userId).toBe(null);
+
+        const user = await db.user.findByOptional({ id: userId });
+        expect(user).toBe(undefined);
+      });
+
+      it('should nullify foreignKey and delete related record in batch update', async () => {
+        const user = await db.user.selectAll().create(userData);
+        const profileIds = await db.profile.pluck('id').createMany([
+          { ...profileData, userId: user.id },
+          { ...profileData, userId: user.id },
+        ]);
+
+        const updatedUserIds = await db.profile
+          .pluck('userId')
+          .where({ id: { in: profileIds } })
+          .update({
+            user: {
+              delete: true,
+            },
+          });
+
+        expect(updatedUserIds).toEqual([null, null]);
+
+        const deletedUser = await db.user.findOptional(user.id);
+        expect(deletedUser).toBe(undefined);
+      });
+    });
+
+    describe('nested update', () => {
+      it('should update related record', async () => {
+        const { id, userId } = await db.profile
+          .select('id', 'userId')
+          .create({ ...profileData, user: { create: userData } });
+
+        await db.profile
+          .select('userId')
+          .find(id)
+          .update({
+            user: {
+              update: {
+                name: 'new name',
+              },
+            },
+          });
+
+        const user = await db.user.findBy({ id: userId });
+        expect(user.name).toBe('new name');
+      });
+
+      it('should update related records in batch update', async () => {
+        const profiles = await db.profile.select('id', 'userId').createMany([
+          { ...profileData, user: { create: userData } },
+          { ...profileData, user: { create: userData } },
+        ]);
+
+        await db.profile
+          .where({ id: { in: profiles.map((profile) => profile.id) } })
+          .update({
+            user: {
+              update: {
+                name: 'new name',
+              },
+            },
+          });
+
+        const updatedNames = await db.user.pluck('name').where({
+          id: { in: profiles.map((profile) => profile.userId as number) },
+        });
+        expect(updatedNames).toEqual(['new name', 'new name']);
+      });
+    });
+
+    describe('nested upsert', () => {
+      it('should update related record if it exists', async () => {
+        const profile = await db.profile.create({
+          ...profileData,
+          user: {
+            create: userData,
+          },
+        });
+
+        await db.profile.find(profile.id).update({
+          user: {
+            upsert: {
+              update: {
+                name: 'updated',
+              },
+              create: userData,
+            },
+          },
+        });
+
+        const user = await db.profile.user(profile);
+        expect(user.name).toBe('updated');
+      });
+
+      it('should create related record if it does not exist', async () => {
+        const profile = await db.profile.create(profileData);
+
+        const updated = await db.profile
+          .selectAll()
+          .find(profile.id)
+          .update({
+            user: {
+              upsert: {
+                update: {
+                  name: 'updated',
+                },
+                create: {
+                  ...userData,
+                  name: 'created',
+                },
+              },
+            },
+          });
+
+        const user = await db.profile.user(updated);
+        expect(user.name).toBe('created');
+      });
+
+      it('should throw in batch update', () => {
+        expect(() =>
+          db.profile.where({ id: 1 }).update({
+            user: {
+              // @ts-expect-error not allows in batch update
+              upsert: {
+                update: {
+                  name: 'updated',
+                },
+                create: {
+                  ...userData,
+                  name: 'created',
+                },
+              },
+            },
+          }),
+        ).toThrow();
+      });
+    });
+
+    describe('nested create', () => {
+      it('should create new related record and update foreignKey', async () => {
+        const profileId = await db.profile
+          .get('id')
+          .create({ ...profileData, user: { create: userData } });
+
+        const updated = await db.profile
+          .selectAll()
+          .find(profileId)
+          .update({
+            user: {
+              create: { ...userData, name: 'created' },
+            },
+          });
+
+        const user = await db.profile.user(updated);
+        expect(user.name).toBe('created');
+      });
+
+      it('should create new related record and update foreignKey in batch update', async () => {
+        const profileIds = await db.profile
+          .pluck('id')
+          .createMany([profileData, profileData]);
+
+        const updatedUserIds = await db.profile
+          .pluck('userId')
+          .where({ id: { in: profileIds } })
+          .update({
+            user: {
+              create: { ...userData, name: 'created' },
+            },
+          });
+
+        expect(updatedUserIds[0]).toBe(updatedUserIds[1]);
+
+        const user = await db.user.find(updatedUserIds[0] as number);
+        expect(user.name).toBe('created');
+      });
+    });
+  });
+});