fix(hooks): Fix a regression on the custom resolve for mutations.

Author: vincentdesmares

lib/injectHooks.js

@@ -2,11 +2,12 @@
 exports.__esModule = true;
 exports.injectHooks = void 0;
 function injectListHooks(declaration, injectFunctions) {
+    var _a;
     if (!declaration.list) {
         declaration.list = {};
     }
     // If the list is resolved by a custom function, we don't need to inject hooks
-    if (declaration.list.resolve) {
+    if ((_a = declaration === null || declaration === void 0 ? void 0 : declaration.list) === null || _a === void 0 ? void 0 : _a.resolve) {
         return;
     }
     var beforeList = Array.isArray(declaration.list.before)
@@ -27,16 +28,16 @@ function injectListHooks(declaration, injectFunctions) {
         : afterList;
 }
 function injectUpdateHooks(declaration, injectFunctions) {
-    var _a;
+    var _a, _b;
     if (!((_a = declaration.actions) === null || _a === void 0 ? void 0 : _a.includes('update')))
         return;
-    if (!declaration.update || 'type' in declaration.update) {
-        declaration.update = {};
-    }
     // If the update is resolved by a custom function, we don't need to inject hooks
-    if (declaration.update.resolve) {
+    if ((_b = declaration === null || declaration === void 0 ? void 0 : declaration.update) === null || _b === void 0 ? void 0 : _b.resolve) {
         return;
     }
+    if (!declaration.update) {
+        declaration.update = {};
+    }
     var beforeUpdate = Array.isArray(declaration.update.before)
         ? declaration.update.before
         : declaration.update.before
@@ -55,16 +56,16 @@ function injectUpdateHooks(declaration, injectFunctions) {
         : afterUpdate;
 }
 function injectCreateHooks(declaration, injectFunctions) {
-    var _a;
+    var _a, _b;
     if (!((_a = declaration.actions) === null || _a === void 0 ? void 0 : _a.includes('create')))
         return;
-    if (!declaration.create || 'type' in declaration.create) {
-        declaration.create = {};
-    }
     // If the create is resolved by a custom function, we don't need to inject hooks
-    if (declaration.list.create) {
+    if ((_b = declaration === null || declaration === void 0 ? void 0 : declaration.create) === null || _b === void 0 ? void 0 : _b.resolve) {
         return;
     }
+    if (!declaration.create) {
+        declaration.create = {};
+    }
     var beforeCreate = Array.isArray(declaration.create.before)
         ? declaration.create.before
         : declaration.create.before
@@ -83,16 +84,16 @@ function injectCreateHooks(declaration, injectFunctions) {
         : afterCreate;
 }
 function injectDeleteHooks(declaration, injectFunctions) {
-    var _a;
+    var _a, _b;
     if (!((_a = declaration.actions) === null || _a === void 0 ? void 0 : _a.includes('delete')))
         return;
-    if (!declaration["delete"] || 'type' in declaration["delete"]) {
-        declaration["delete"] = {};
-    }
     // If the delete is resolved by a custom function, we don't need to inject hooks
-    if (declaration["delete"].resolve) {
+    if ((_b = declaration === null || declaration === void 0 ? void 0 : declaration["delete"]) === null || _b === void 0 ? void 0 : _b.resolve) {
         return;
     }
+    if (!declaration["delete"]) {
+        declaration["delete"] = {};
+    }
     var beforeDelete = Array.isArray(declaration["delete"].before)
         ? declaration["delete"].before
         : declaration["delete"].before

src/injectHooks.ts

@@ -24,7 +24,7 @@ function injectListHooks<T extends Model<any, any>>(
   }
 
   // If the list is resolved by a custom function, we don't need to inject hooks
-  if (declaration.list.resolve) {
+  if (declaration?.list?.resolve) {
     return
   }
 
@@ -57,15 +57,15 @@ function injectUpdateHooks<T extends Model<any, any>>(
 ) {
   if (!declaration.actions?.includes('update')) return
 
-  if (!declaration.update || 'type' in declaration.update) {
-    declaration.update = {} as UpdateFieldDeclarationType<T>
-  }
-
   // If the update is resolved by a custom function, we don't need to inject hooks
-  if (declaration.update.resolve) {
+  if (declaration?.update?.resolve) {
     return
   }
 
+  if (!declaration.update) {
+    declaration.update = {} as UpdateFieldDeclarationType<T>
+  }
+
   const beforeUpdate: UpdateBeforeHook<T>[] = Array.isArray(
     declaration.update.before
   )
@@ -97,15 +97,15 @@ function injectCreateHooks<T extends Model<any, any>>(
 ) {
   if (!declaration.actions?.includes('create')) return
 
-  if (!declaration.create || 'type' in declaration.create) {
-    declaration.create = {} as CreateFieldDeclarationType<T>
-  }
-
   // If the create is resolved by a custom function, we don't need to inject hooks
-  if (declaration.list.create) {
+  if (declaration?.create?.resolve) {
     return
   }
 
+  if (!declaration.create) {
+    declaration.create = {} as CreateFieldDeclarationType<T>
+  }
+
   const beforeCreate: CreateBeforeHook<T>[] = Array.isArray(
     declaration.create.before
   )
@@ -137,15 +137,15 @@ function injectDeleteHooks<T extends Model<any, any>>(
 ) {
   if (!declaration.actions?.includes('delete')) return
 
-  if (!declaration.delete || 'type' in declaration.delete) {
-    declaration.delete = {} as DeleteFieldDeclarationType<T>
-  }
-
   // If the delete is resolved by a custom function, we don't need to inject hooks
-  if (declaration.delete.resolve) {
+  if (declaration?.delete?.resolve) {
     return
   }
 
+  if (!declaration.delete) {
+    declaration.delete = {} as DeleteFieldDeclarationType<T>
+  }
+
   const beforeDelete: DeleteBeforeHook<T>[] = Array.isArray(
     declaration.delete.before
   )

src/tests/injectHooks.test.js

@@ -0,0 +1,80 @@
+const { injectHooks } = require('../../lib')
+const { GraphQLError } = require('graphql')
+
+describe('injectHooks', () => {
+  it('should not overwrite custom update hooks', () => {
+    // Create a custom update hook that throws an error
+    const customUpdateHook = () => {
+      throw new GraphQLError('Custom update hook should be called')
+    }
+
+    // Create a schema declaration with custom update hooks
+    const schemaDeclaration = {
+      user: {
+        model: 'User',
+        actions: ['update'],
+        update: {
+          before: [customUpdateHook],
+          after: [customUpdateHook],
+        },
+      },
+    }
+
+    // Create inject functions that would normally add hooks
+    const injectFunctions = {
+      updateBefore: (model, existingHooks) => {
+        return [...existingHooks, () => {}]
+      },
+      updateAfter: (model, existingHooks) => {
+        return [...existingHooks, () => {}]
+      },
+    }
+
+    // Inject hooks
+    const result = injectHooks({
+      graphqlSchemaDeclaration: schemaDeclaration,
+      injectFunctions,
+    })
+
+    // Verify that the custom hooks are still present and in the correct order
+    expect(result.user.update.before).toContain(customUpdateHook)
+    expect(result.user.update.after).toContain(customUpdateHook)
+    expect(result.user.update.before[0]).toBe(customUpdateHook)
+    expect(result.user.update.after[0]).toBe(customUpdateHook)
+  })
+
+  it('should not inject hooks when custom resolve function is provided', () => {
+    const customResolve = () => {
+      return 'custom resolve result'
+    }
+
+    const schemaDeclaration = {
+      user: {
+        model: 'User',
+        actions: ['update'],
+        update: {
+          resolve: customResolve,
+        },
+      },
+    }
+
+    const injectFunctions = {
+      updateBefore: (model, existingHooks) => {
+        return [...existingHooks, () => {}]
+      },
+      updateAfter: (model, existingHooks) => {
+        return [...existingHooks, () => {}]
+      },
+    }
+
+    const result = injectHooks({
+      graphqlSchemaDeclaration: schemaDeclaration,
+      injectFunctions,
+    })
+
+    // Verify that no hooks were injected
+    expect(result.user.update.before).toBeUndefined()
+    expect(result.user.update.after).toBeUndefined()
+    expect(result.user.update.resolve).toBe(customResolve)
+  })
+})