orchid-orm 1.3.0 → 1.3.3

package/src/model.ts

@@ -43,6 +43,7 @@ export type Model = {
   columns: ModelConfig;
   schema?: string;
   columnTypes: ColumnTypesBase;
+  noPrimaryKey?: boolean;
 };
 
 export const createModel = <CT extends ColumnTypesBase>(options: {
@@ -53,6 +54,7 @@ export const createModel = <CT extends ColumnTypesBase>(options: {
     columns!: ModelConfig;
     schema?: string;
     columnTypes: CT;
+    noPrimaryKey?: boolean;
 
     constructor() {
       this.columnTypes = options.columnTypes;

package/src/orm.ts

@@ -1,4 +1,13 @@
-import { Adapter, Db, AdapterOptions, QueryLogOptions, columnTypes } from 'pqb';
+import {
+  Adapter,
+  Db,
+  AdapterOptions,
+  QueryLogOptions,
+  columnTypes,
+  NoPrimaryKeyOption,
+  anyShape,
+  DbTableOptions,
+} from 'pqb';
 import { DbModel, Model, ModelClasses } from './model';
 import { applyRelations } from './relations/relations';
 import { transaction } from './transaction';
@@ -17,10 +26,12 @@ export const orchidORM = <T extends ModelClasses>(
     log,
     logger,
     autoPreparedStatements,
+    noPrimaryKey = 'error',
     ...options
   }: ({ adapter: Adapter } | Omit<AdapterOptions, 'log'>) &
     QueryLogOptions & {
       autoPreparedStatements?: boolean;
+      noPrimaryKey?: NoPrimaryKeyOption;
     },
   models: T,
 ): OrchidORM<T> => {
@@ -29,12 +40,13 @@ export const orchidORM = <T extends ModelClasses>(
     log,
     logger,
     autoPreparedStatements,
+    noPrimaryKey,
   };
   const qb = new Db(
     adapter,
     undefined as unknown as Db,
     undefined,
-    {},
+    anyShape,
     columnTypes,
     commonOptions,
   );
@@ -57,6 +69,13 @@ export const orchidORM = <T extends ModelClasses>(
     const model = new models[key]();
     modelInstances[key] = model;
 
+    const options: DbTableOptions = {
+      ...commonOptions,
+      schema: model.schema,
+    };
+
+    if (model.noPrimaryKey) options.noPrimaryKey = 'ignore';
+
     const dbModel = new Db(
       adapter,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -64,10 +83,7 @@ export const orchidORM = <T extends ModelClasses>(
       model.table,
       model.columns.shape,
       model.columnTypes,
-      {
-        ...commonOptions,
-        schema: model.schema,
-      },
+      options,
     );
 
     (dbModel as unknown as { definedAs: string }).definedAs = key;

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);
+        });
+      });
     });
   });
 });