feat(hooks): Change the signature of all the hooks to take an object instead of an array.

BREAKING CHANGE: Change the signature of all the hooks to take an object instead of an array.

Author: vincentdesmares

lib/createListResolver.js

@@ -166,7 +166,8 @@ var argsAdvancedProcessing = function (findOptions, args, context, info, model,
     if (info.parentType &&
         models[info.parentType.name] &&
         models[info.parentType.name].associations[info.fieldName].scope) {
-        findOptions.where = __assign(__assign({}, (findOptions.where ? findOptions.where : {})), models[info.parentType.name].associations[info.fieldName].scope);
+        findOptions.where = __assign(__assign({}, (findOptions.where ? findOptions.where : {})), models[info.parentType.name].associations[info.fieldName]
+            .scope);
     }
     return findOptions;
 };
@@ -352,7 +353,12 @@ function createListResolver(graphqlTypeDeclaration, models, globalPreCallback, r
                     case 8:
                         if (!listBefore) return [3 /*break*/, 10];
                         handle = globalPreCallback('listBefore');
-                        return [4 /*yield*/, listBefore(processedFindOptions, args, context, info)];
+                        return [4 /*yield*/, listBefore({
+                                findOptions: processedFindOptions,
+                                args: args,
+                                context: context,
+                                info: info
+                            })];
                     case 9:
                         resultBefore = _b.sent();
                         if (!resultBefore) {
@@ -381,7 +387,12 @@ function createListResolver(graphqlTypeDeclaration, models, globalPreCallback, r
                     case 0:
                         if (!listAfter) return [3 /*break*/, 2];
                         handle = globalPreCallback('listAfter');
-                        return [4 /*yield*/, listAfter(result, args, context, info)];
+                        return [4 /*yield*/, listAfter({
+                                result: result,
+                                args: args,
+                                context: context,
+                                info: info
+                            })];
                     case 1:
                         modifiedResult = _a.sent();
                         if (handle) {

lib/mutationResolvers/create.js

@@ -132,7 +132,12 @@ function generateMutationCreate(modelName, inputType, outputType, model, graphql
                             'before' in graphqlModelDeclaration.create &&
                             graphqlModelDeclaration.create.before)) return [3 /*break*/, 10];
                         beforeHandle = globalPreCallback('createBefore');
-                        return [4 /*yield*/, graphqlModelDeclaration.create.before(source, args, context, info)];
+                        return [4 /*yield*/, graphqlModelDeclaration.create.before({
+                                source: source,
+                                args: args,
+                                context: context,
+                                info: info
+                            })];
                     case 9:
                         attributes = _d.sent();
                         if (!attributes) {
@@ -188,7 +193,14 @@ function generateMutationCreate(modelName, inputType, outputType, model, graphql
                             graphqlModelDeclaration.create.after)) return [3 /*break*/, 20];
                         afterHandle = globalPreCallback('createAfter');
                         hookData = { data: newEntity.get({ plain: true }) };
-                        return [4 /*yield*/, graphqlModelDeclaration.create.after(newEntity, source, args, context, info, (0, setWebhookData_1["default"])(hookData))];
+                        return [4 /*yield*/, graphqlModelDeclaration.create.after({
+                                newEntity: newEntity,
+                                source: source,
+                                args: args,
+                                context: context,
+                                info: info,
+                                setWebhookData: (0, setWebhookData_1["default"])(hookData)
+                            })];
                     case 18:
                         updatedEntity = _d.sent();
                         if (afterHandle) {

lib/mutationResolvers/delete.js

@@ -62,7 +62,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 exports.__esModule = true;
 var graphql_1 = require("graphql");
-var setWebhookData_1 = __importDefault(require("../webhook/setWebhookData"));
 var callModelWebhook_1 = __importDefault(require("./callModelWebhook"));
 /**
  * Generates a delete mutation operation
@@ -131,7 +130,13 @@ function generateMutationDelete(modelName, graphqlModelDeclaration, models, glob
                             'before' in graphqlModelDeclaration["delete"] &&
                             graphqlModelDeclaration["delete"].before)) return [3 /*break*/, 10];
                         beforeHandle = globalPreCallback('deleteBefore');
-                        return [4 /*yield*/, graphqlModelDeclaration["delete"].before(where, source, args, context, info)];
+                        return [4 /*yield*/, graphqlModelDeclaration["delete"].before({
+                                where: where,
+                                source: source,
+                                args: args,
+                                context: context,
+                                info: info
+                            })];
                     case 9:
                         where = _c.sent();
                         if (beforeHandle) {
@@ -161,7 +166,13 @@ function generateMutationDelete(modelName, graphqlModelDeclaration, models, glob
                             graphqlModelDeclaration["delete"].after)) return [3 /*break*/, 15];
                         hookData = { data: __assign({}, snapshotBeforeDelete) };
                         afterHandle = globalPreCallback('deleteAfter');
-                        return [4 /*yield*/, graphqlModelDeclaration["delete"].after(entity, source, args, context, info, (0, setWebhookData_1["default"])(hookData))];
+                        return [4 /*yield*/, graphqlModelDeclaration["delete"].after({
+                                deletedEntity: entity,
+                                source: source,
+                                args: args,
+                                context: context,
+                                info: info
+                            })];
                     case 13:
                         _c.sent();
                         if (afterHandle) {

lib/mutationResolvers/update.js

@@ -62,7 +62,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 exports.__esModule = true;
 var graphql_1 = require("graphql");
-var setWebhookData_1 = __importDefault(require("../webhook/setWebhookData"));
 var callModelWebhook_1 = __importDefault(require("./callModelWebhook"));
 /**
  * Generates a update mutation operation
@@ -133,7 +132,12 @@ function generateMutationUpdate(modelName, inputType, outputType, graphqlModelDe
                             'before' in graphqlModelDeclaration.update &&
                             graphqlModelDeclaration.update.before)) return [3 /*break*/, 10];
                         beforeHandle = globalPreCallback('updateBefore');
-                        return [4 /*yield*/, graphqlModelDeclaration.update.before(source, args, context, info)];
+                        return [4 /*yield*/, graphqlModelDeclaration.update.before({
+                                source: source,
+                                args: args,
+                                context: context,
+                                info: info
+                            })];
                     case 9:
                         data = _c.sent();
                         if (beforeHandle) {
@@ -163,7 +167,14 @@ function generateMutationUpdate(modelName, inputType, outputType, graphqlModelDe
                             }
                         };
                         afterHandle = globalPreCallback('updateAfter');
-                        return [4 /*yield*/, graphqlModelDeclaration.update.after(entity, snapshotBeforeUpdate, source, args, context, info, (0, setWebhookData_1["default"])(hookData))];
+                        return [4 /*yield*/, graphqlModelDeclaration.update.after({
+                                updatedEntity: entity,
+                                entitySnapshot: snapshotBeforeUpdate,
+                                source: source,
+                                args: args,
+                                context: context,
+                                info: info
+                            })];
                     case 14:
                         updatedEntity = _c.sent();
                         if (afterHandle) {

lib/queryResolvers/count.js

@@ -64,7 +64,7 @@ function countResolver(model, schemaDeclaration, globalPreCallback) {
         ? schemaDeclaration.count.before
         : listBefore;
     return function (source, args, context, info) { return __awaiter(_this, void 0, void 0, function () {
-        var beforeList, beforeList_1, beforeList_1_1, before, handle, e_1_1, handle, countOptions;
+        var beforeList, beforeList_1, beforeList_1_1, before, handle, e_1_1, findOptions, handle, resultBefore;
         var e_1, _a;
         return __generator(this, function (_b) {
             switch (_b.label) {
@@ -105,16 +105,26 @@ function countResolver(model, schemaDeclaration, globalPreCallback) {
                     finally { if (e_1) throw e_1.error; }
                     return [7 /*endfinally*/];
                 case 8:
-                    if (!(typeof countBefore !== 'undefined')) return [3 /*break*/, 10];
+                    findOptions = graphql_sequelize_1.argsToFindOptions["default"](args, Object.keys(model.getAttributes()));
+                    if (!countBefore) return [3 /*break*/, 10];
                     handle = globalPreCallback('countBefore');
-                    return [4 /*yield*/, countBefore(graphql_sequelize_1.argsToFindOptions["default"](args, Object.keys(model.getAttributes())), args, context, info)];
+                    return [4 /*yield*/, countBefore({
+                            findOptions: findOptions,
+                            args: args,
+                            context: context,
+                            info: info
+                        })];
                 case 9:
-                    countOptions = _b.sent();
+                    resultBefore = _b.sent();
+                    if (!resultBefore) {
+                        throw new Error('The before hook of the count endpoint must return a value.');
+                    }
+                    findOptions = resultBefore;
                     if (handle) {
                         handle();
                     }
-                    return [2 /*return*/, model.count(countOptions)];
-                case 10: return [2 /*return*/, model.count(graphql_sequelize_1.argsToFindOptions["default"](args, Object.keys(model.getAttributes())))];
+                    return [2 /*return*/, model.count(findOptions)];
+                case 10: return [2 /*return*/, model.count(findOptions)];
             }
         });
     }); };

src/createListResolver.ts

@@ -1,13 +1,30 @@
 import { resolver } from 'graphql-sequelize'
-import { FindOptions, Model, Op } from 'sequelize'
+import { FindOptions, Model, ModelStatic, Op } from 'sequelize'
 import removeUnusedAttributes from './removeUnusedAttributes'
-import { GlobalBeforeHook, ModelDeclarationType } from './types/types'
+import {
+  GlobalBeforeHook,
+  ModelDeclarationType,
+  SequelizeModels,
+} from './types/types'
 
-function allowOrderOnAssociations(findOptions: FindOptions<any>, model: any) {
+interface ModelInclude {
+  model: ModelStatic<Model<any>>
+  as?: string
+}
+
+interface ModelSort {
+  model: ModelStatic<Model<any>>
+  as?: string
+}
+
+function allowOrderOnAssociations<M extends Model<any>>(
+  findOptions: FindOptions<M>,
+  model: ModelStatic<M>
+) {
   if (typeof findOptions.order === 'undefined') {
     return findOptions
   }
-  const processedOrder: any = []
+  const processedOrder: any[] = []
 
   const checkForAssociationSort = (singleOrder: any, index: any) => {
     // When the comas is used, graphql-sequelize will not handle the 'reverse:' command.
@@ -43,7 +60,7 @@ function allowOrderOnAssociations(findOptions: FindOptions<any>, model: any) {
         findOptions.include = []
       }
 
-      const modelInclude: any = {
+      const modelInclude: ModelInclude = {
         model: model.associations[associationName].target,
       }
 
@@ -56,7 +73,7 @@ function allowOrderOnAssociations(findOptions: FindOptions<any>, model: any) {
         findOptions.include.push(modelInclude)
       }
 
-      const modelSort: any = {
+      const modelSort: ModelSort = {
         model: model.associations[associationName].target,
       }
       // When sorting by a associated table, the alias must be specified
@@ -72,12 +89,12 @@ function allowOrderOnAssociations(findOptions: FindOptions<any>, model: any) {
       if (
         field &&
         model.rawAttributes[field] &&
-        model.rawAttributes[field].type.key === 'VIRTUAL'
+        (model.rawAttributes[field].type as any).key === 'VIRTUAL'
       ) {
         // When a virtual field is used, we must sort with the expression and not
         // the name of the field, as it is not compatible with multiple database engines.
         // IE : Sorting by virtual field is inefficient if using sub-queries.
-        field = model.rawAttributes[field].type.fields[0][0]
+        field = (model.rawAttributes[field].type as any).fields[0][0]
       }
       processedOrder.push([field, direction])
     }
@@ -113,42 +130,43 @@ function allowOrderOnAssociations(findOptions: FindOptions<any>, model: any) {
   return findOptions
 }
 
-const argsAdvancedProcessing = (
-  findOptions: FindOptions<any>,
+const argsAdvancedProcessing = <M extends Model<any>>(
+  findOptions: FindOptions<M>,
   args: any,
   context: any,
   info: any,
-  model: any,
-  models: any
+  model: ModelStatic<M>,
+  models: SequelizeModels
 ) => {
   findOptions = allowOrderOnAssociations(findOptions, model)
 
   // When an association uses a scope, we have to add it to the where condition by default.
   if (
     info.parentType &&
     models[info.parentType.name] &&
-    models[info.parentType.name].associations[info.fieldName].scope
+    (models[info.parentType.name].associations[info.fieldName] as any).scope
   ) {
     findOptions.where = {
       ...(findOptions.where ? findOptions.where : {}),
-      ...models[info.parentType.name].associations[info.fieldName].scope,
+      ...(models[info.parentType.name].associations[info.fieldName] as any)
+        .scope,
     }
   }
 
   return findOptions
 }
 
-async function trimAndOptimizeFindOptions({
+async function trimAndOptimizeFindOptions<M extends Model<any>>({
   findOptions,
   graphqlTypeDeclaration,
   info,
   models,
   args,
 }: {
-  findOptions: FindOptions<any>
-  graphqlTypeDeclaration: any
+  findOptions: FindOptions<M>
+  graphqlTypeDeclaration: ModelDeclarationType<M>
   info: any
-  models: any
+  models: SequelizeModels
   args: any
 }) {
   const trimedFindOptions =
@@ -213,7 +231,7 @@ async function trimAndOptimizeFindOptions({
         ...trimedFindOptions,
         // We only fetch the primary attribute
         attributes: graphqlTypeDeclaration.model.primaryKeyAttributes,
-      }
+      } as FindOptions<M>
       const result = await graphqlTypeDeclaration.model.findAll(
         fetchIdsMultiColumnsFindOptions
       )
@@ -268,11 +286,11 @@ async function trimAndOptimizeFindOptions({
   return trimedFindOptions
 }
 
-export default function createListResolver(
-  graphqlTypeDeclaration: ModelDeclarationType<any>,
-  models: any,
+export default function createListResolver<M extends Model<any>>(
+  graphqlTypeDeclaration: ModelDeclarationType<M>,
+  models: SequelizeModels,
   globalPreCallback: any,
-  relation = null
+  relation: ModelStatic<M> | null = null
 ) {
   if (graphqlTypeDeclaration?.list?.resolver) {
     return async (source: any, args: any, context: any, info: any) => {
@@ -305,8 +323,13 @@ export default function createListResolver(
     contextToOptions: graphqlTypeDeclaration.list
       ? graphqlTypeDeclaration.list.contextToOptions
       : undefined,
-    before: async (findOptions: any, args: any, context: any, info: any) => {
-      let processedFindOptions: FindOptions<any> = argsAdvancedProcessing(
+    before: async (
+      findOptions: FindOptions<M>,
+      args: any,
+      context: any,
+      info: any
+    ) => {
+      let processedFindOptions: FindOptions<M> = argsAdvancedProcessing(
         findOptions,
         args,
         context,
@@ -355,12 +378,12 @@ export default function createListResolver(
       // before hook, can mutate the findOptions
       if (listBefore) {
         const handle = globalPreCallback('listBefore')
-        const resultBefore = await listBefore(
-          processedFindOptions,
+        const resultBefore = await listBefore({
+          findOptions: processedFindOptions,
           args,
           context,
-          info
-        )
+          info,
+        })
         if (!resultBefore) {
           throw new Error(
             'The before hook of the list endpoint must return a value.'
@@ -383,15 +406,15 @@ export default function createListResolver(
         args,
       })
     },
-    after: async (
-      result: Model<any> | Model<any>[],
-      args: any,
-      context: any,
-      info: any
-    ) => {
+    after: async (result: M | M[], args: any, context: any, info: any) => {
       if (listAfter) {
         const handle = globalPreCallback('listAfter')
-        const modifiedResult = await listAfter(result, args, context, info)
+        const modifiedResult = await listAfter({
+          result,
+          args,
+          context,
+          info,
+        })
         if (handle) {
           handle()
         }