orchid-orm 1.5.29 → 1.5.31

package/src/relations/belongsTo.test.ts

@@ -1,1122 +0,0 @@
-import { db } from '../test-utils/test-db';
-import {
-  assertType,
-  chatData,
-  expectSql,
-  messageData,
-  profileData,
-  userData,
-  useRelationCallback,
-  useTestDatabase,
-} from '../test-utils/test-utils';
-import { RelationQuery } from 'pqb';
-import { User } from '../test-utils/test-tables';
-
-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('relation callbacks', () => {
-        const { beforeCreate, afterCreate, resetMocks } = useRelationCallback(
-          db.message.relations.chat,
-        );
-
-        const data = {
-          ...messageData,
-          chat: {
-            create: chatData,
-          },
-        };
-
-        it('should invoke callbacks', async () => {
-          await db.message.create(data);
-
-          expect(beforeCreate).toHaveBeenCalledTimes(1);
-          expect(afterCreate).toHaveBeenCalledTimes(1);
-        });
-
-        it('should invoke callbacks in a batch create', async () => {
-          resetMocks();
-
-          await db.message.createMany([data, data]);
-
-          expect(beforeCreate).toHaveBeenCalledTimes(1);
-          expect(afterCreate).toHaveBeenCalledTimes(1);
-        });
-      });
-    });
-
-    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('relation callbacks', () => {
-        const { beforeCreate, afterCreate, resetMocks } = useRelationCallback(
-          db.message.relations.chat,
-        );
-
-        const data = {
-          ...messageData,
-          chat: {
-            connectOrCreate: {
-              where: { title: 'title' },
-              create: chatData,
-            },
-          },
-        };
-
-        it('should invoke callbacks', async () => {
-          await db.message.create(data);
-
-          expect(beforeCreate).toHaveBeenCalledTimes(1);
-          expect(afterCreate).toHaveBeenCalledTimes(1);
-        });
-
-        it('should invoke callbacks in a batch create', async () => {
-          resetMocks();
-
-          await db.message.createMany([data, data]);
-
-          expect(beforeCreate).toHaveBeenCalledTimes(1);
-          expect(afterCreate).toHaveBeenCalledTimes(1);
-        });
-      });
-    });
-  });
-
-  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('relation callbacks', () => {
-        const { beforeDelete, afterDelete, resetMocks } = useRelationCallback(
-          db.profile.relations.user,
-        );
-
-        const profileWithUserData = {
-          ...profileData,
-          user: {
-            create: userData,
-          },
-        };
-
-        const data = {
-          user: {
-            delete: true,
-          },
-        };
-
-        it('should invoke callbacks', async () => {
-          const id = await db.profile.get('id').create(profileWithUserData);
-
-          await db.profile.find(id).update(data);
-
-          expect(beforeDelete).toHaveBeenCalledTimes(1);
-          expect(afterDelete).toHaveBeenCalledTimes(1);
-        });
-
-        it('should invoke callbacks in a batch delete', async () => {
-          resetMocks();
-
-          const ids = await db.profile
-            .pluck('id')
-            .createMany([profileWithUserData, profileWithUserData]);
-
-          await db.profile.where({ id: { in: ids } }).update(data);
-
-          expect(beforeDelete).toHaveBeenCalledTimes(1);
-          expect(afterDelete).toHaveBeenCalledTimes(1);
-        });
-      });
-    });
-
-    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('relation callbacks', () => {
-        const { beforeUpdate, afterUpdate, resetMocks } = useRelationCallback(
-          db.profile.relations.user,
-        );
-
-        const profileWithUserData = {
-          ...profileData,
-          user: {
-            create: userData,
-          },
-        };
-
-        const data = {
-          user: {
-            update: {
-              name: 'new name',
-            },
-          },
-        };
-
-        it('should invoke callbacks', async () => {
-          const id = await db.profile.get('id').create(profileWithUserData);
-
-          await db.profile.find(id).update(data);
-
-          expect(beforeUpdate).toHaveBeenCalledTimes(1);
-          expect(afterUpdate).toHaveBeenCalledTimes(1);
-        });
-
-        it('should invoke callbacks in a batch create', async () => {
-          resetMocks();
-
-          const ids = await db.profile
-            .pluck('id')
-            .createMany([profileWithUserData, profileWithUserData]);
-
-          await db.profile.where({ id: { in: ids } }).update(data);
-
-          expect(beforeUpdate).toHaveBeenCalledTimes(1);
-          expect(afterUpdate).toHaveBeenCalledTimes(1);
-        });
-      });
-    });
-
-    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('relation callbacks', () => {
-        const {
-          beforeUpdate,
-          afterUpdate,
-          beforeCreate,
-          afterCreate,
-          resetMocks,
-        } = useRelationCallback(db.profile.relations.user);
-
-        const data = {
-          user: {
-            upsert: {
-              update: {
-                name: 'new name',
-              },
-              create: userData,
-            },
-          },
-        };
-
-        it('should invoke update callbacks when updating', async () => {
-          const id = await db.profile.get('id').create({
-            ...profileData,
-            user: {
-              create: userData,
-            },
-          });
-
-          resetMocks();
-
-          await db.profile.find(id).update(data);
-
-          expect(beforeUpdate).toHaveBeenCalledTimes(1);
-          expect(afterUpdate).toHaveBeenCalledTimes(1);
-          expect(beforeCreate).not.toBeCalled();
-          expect(afterCreate).not.toBeCalled();
-        });
-
-        it('should invoke create callbacks when creating', async () => {
-          resetMocks();
-
-          const id = await db.profile.get('id').create(profileData);
-
-          await db.profile.find(id).update(data);
-
-          expect(beforeUpdate).not.toBeCalled();
-          expect(afterUpdate).not.toBeCalled();
-          expect(beforeCreate).toHaveBeenCalledTimes(1);
-          expect(afterCreate).toHaveBeenCalledTimes(1);
-        });
-      });
-    });
-
-    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');
-      });
-
-      describe('relation callbacks', () => {
-        const { beforeCreate, afterCreate, resetMocks } = useRelationCallback(
-          db.profile.relations.user,
-        );
-
-        const data = {
-          user: {
-            create: userData,
-          },
-        };
-
-        it('should invoke callbacks', async () => {
-          const id = await db.profile.get('id').create(profileData);
-
-          await db.profile.find(id).update(data);
-
-          expect(beforeCreate).toHaveBeenCalledTimes(1);
-          expect(afterCreate).toHaveBeenCalledTimes(1);
-        });
-
-        it('should invoke callbacks in a batch update', async () => {
-          const ids = await db.profile
-            .pluck('id')
-            .createMany([profileData, profileData]);
-
-          resetMocks();
-
-          await db.profile.where({ id: { in: ids } }).update(data);
-
-          expect(beforeCreate).toHaveBeenCalledTimes(1);
-          expect(afterCreate).toHaveBeenCalledTimes(1);
-        });
-      });
-    });
-  });
-});