orchid-orm 1.3.0 → 1.3.2

package/src/relations/belongsTo.test.ts

@@ -6,6 +6,7 @@ import {
   messageData,
   profileData,
   userData,
+  useRelationCallback,
   useTestDatabase,
 } from '../test-utils/test-utils';
 import { RelationQuery } from 'pqb';
@@ -381,6 +382,35 @@ describe('belongsTo', () => {
           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', () => {
@@ -576,6 +606,38 @@ describe('belongsTo', () => {
           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);
+        });
+      });
     });
   });
 
@@ -733,6 +795,47 @@ describe('belongsTo', () => {
         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', () => {
@@ -777,6 +880,49 @@ describe('belongsTo', () => {
         });
         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', () => {
@@ -845,6 +991,58 @@ describe('belongsTo', () => {
           }),
         ).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', () => {
@@ -885,6 +1083,40 @@ describe('belongsTo', () => {
         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);
+        });
+      });
     });
   });
 });

package/src/relations/hasAndBelongsToMany.test.ts

@@ -6,6 +6,7 @@ import {
   useTestDatabase,
   now,
   assertType,
+  useRelationCallback,
 } from '../test-utils/test-utils';
 import { RelationQuery, Sql, TransactionAdapter } from 'pqb';
 import { Chat, User } from '../test-utils/test-models';
@@ -107,11 +108,10 @@ describe('hasAndBelongsToMany', () => {
       });
 
       it('should throw when the main query returns many records', async () => {
-        await expect(
-          async () =>
-            await db.user.chats.create({
-              title: 'title',
-            }),
+        await expect(() =>
+          db.user.chats.create({
+            title: 'title',
+          }),
         ).rejects.toThrow(
           'Cannot create based on a query which returns multiple records',
         );
@@ -584,6 +584,35 @@ describe('hasAndBelongsToMany', () => {
           },
         });
       });
+
+      describe('relation callbacks', () => {
+        const { beforeCreate, afterCreate, resetMocks } = useRelationCallback(
+          db.user.relations.chats,
+        );
+
+        const data = {
+          ...userData,
+          chats: {
+            create: [chatData, chatData],
+          },
+        };
+
+        it('should invoke callbacks', async () => {
+          await db.user.create(data);
+
+          expect(beforeCreate).toHaveBeenCalledTimes(1);
+          expect(afterCreate).toHaveBeenCalledTimes(1);
+        });
+
+        it('should invoke callbacks in a batch create', async () => {
+          resetMocks();
+
+          await db.user.createMany([data, data]);
+
+          expect(beforeCreate).toHaveBeenCalledTimes(1);
+          expect(afterCreate).toHaveBeenCalledTimes(1);
+        });
+      });
     });
 
     describe('nested connect', () => {
@@ -872,6 +901,44 @@ describe('hasAndBelongsToMany', () => {
           },
         });
       });
+
+      describe('relation callbacks', () => {
+        const { beforeCreate, afterCreate, resetMocks } = useRelationCallback(
+          db.user.relations.chats,
+        );
+
+        const data = {
+          ...userData,
+          chats: {
+            connectOrCreate: [
+              {
+                where: { title: 'one' },
+                create: chatData,
+              },
+              {
+                where: { title: 'two' },
+                create: chatData,
+              },
+            ],
+          },
+        };
+
+        it('should invoke callbacks', async () => {
+          await db.user.create(data);
+
+          expect(beforeCreate).toHaveBeenCalledTimes(1);
+          expect(afterCreate).toHaveBeenCalledTimes(1);
+        });
+
+        it('should invoke callbacks in a batch create', async () => {
+          resetMocks();
+
+          await db.user.createMany([data, data]);
+
+          expect(beforeCreate).toHaveBeenCalledTimes(1);
+          expect(afterCreate).toHaveBeenCalledTimes(1);
+        });
+      });
     });
   });
 
@@ -1000,6 +1067,65 @@ describe('hasAndBelongsToMany', () => {
         const chats = await db.user.chats({ id }).pluck('title');
         expect(chats).toEqual(['chat 1']);
       });
+
+      describe('relation callbacks', () => {
+        const { beforeDelete, afterDelete, resetMocks } = useRelationCallback(
+          db.user.relations.chats,
+        );
+
+        const data = {
+          chats: {
+            delete: [{ title: 'chat 1' }, { title: 'chat 2' }],
+          },
+        };
+
+        it('should invoke callbacks', async () => {
+          const id = await db.user.get('id').create({
+            ...userData,
+            chats: {
+              create: [
+                { ...chatData, title: 'chat 1' },
+                { ...chatData, title: 'chat 2' },
+              ],
+            },
+          });
+
+          await db.user.find(id).update(data);
+
+          expect(beforeDelete).toHaveBeenCalledTimes(1);
+          expect(afterDelete).toHaveBeenCalledTimes(1);
+        });
+
+        it('should invoke callbacks in a batch update', async () => {
+          resetMocks();
+
+          const ids = await db.user.pluck('id').createMany([
+            {
+              ...userData,
+              chats: {
+                create: [
+                  { ...chatData, title: 'chat 1' },
+                  { ...chatData, title: 'chat 3' },
+                ],
+              },
+            },
+            {
+              ...userData,
+              chats: {
+                create: [
+                  { ...chatData, title: 'chat 2' },
+                  { ...chatData, title: 'chat 4' },
+                ],
+              },
+            },
+          ]);
+
+          await db.user.where({ id: { in: ids } }).update(data);
+
+          expect(beforeDelete).toHaveBeenCalledTimes(1);
+          expect(afterDelete).toHaveBeenCalledTimes(1);
+        });
+      });
     });
 
     describe('nested update', () => {
@@ -1061,6 +1187,59 @@ describe('hasAndBelongsToMany', () => {
         const chats = await db.user.chats({ id }).pluck('title');
         expect(chats).toEqual(['chat 1']);
       });
+
+      describe('relation callbacks', () => {
+        const { beforeUpdate, afterUpdate, resetMocks } = useRelationCallback(
+          db.user.relations.chats,
+        );
+
+        const data = {
+          chats: {
+            update: {
+              where: [{ title: 'chat 1' }, { title: 'chat 2' }],
+              data: { title: 'new title' },
+            },
+          },
+        };
+
+        it('should invoke callbacks', async () => {
+          const id = await db.user.get('id').create({
+            ...userData,
+            chats: {
+              create: [{ ...chatData, title: 'chat 1' }],
+            },
+          });
+
+          await db.user.find(id).update(data);
+
+          expect(beforeUpdate).toHaveBeenCalledTimes(1);
+          expect(afterUpdate).toHaveBeenCalledTimes(1);
+        });
+
+        it('should invoke callbacks in a batch update', async () => {
+          const id = await db.user.get('id').createMany([
+            {
+              ...userData,
+              chats: {
+                create: [{ ...chatData, title: 'chat 1' }],
+              },
+            },
+            {
+              ...userData,
+              chats: {
+                create: [{ ...chatData, title: 'chat 2' }],
+              },
+            },
+          ]);
+
+          resetMocks();
+
+          await db.user.find(id).update(data);
+
+          expect(beforeUpdate).toHaveBeenCalledTimes(1);
+          expect(afterUpdate).toHaveBeenCalledTimes(1);
+        });
+      });
     });
 
     describe('nested create', () => {
@@ -1117,6 +1296,40 @@ describe('hasAndBelongsToMany', () => {
         const chats = await db.user.chats({ id });
         expect(chats).toEqual([]);
       });
+
+      describe('relation callbacks', () => {
+        const { beforeCreate, afterCreate, resetMocks } = useRelationCallback(
+          db.user.relations.chats,
+        );
+
+        const data = {
+          chats: {
+            create: [chatData, chatData],
+          },
+        };
+
+        it('should invoke callbacks', async () => {
+          const id = await db.user.get('id').create(userData);
+
+          await db.user.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.user
+            .pluck('id')
+            .createMany([userData, userData]);
+
+          resetMocks();
+
+          await db.user.where({ id: { in: ids } }).update(data);
+
+          expect(beforeCreate).toHaveBeenCalledTimes(1);
+          expect(afterCreate).toHaveBeenCalledTimes(1);
+        });
+      });
     });
   });
 });