Remove lifecycles from connectors

Signed-off-by: Alexandre Bodin <bodin.alex@gmail.com>

packages/strapi-connector-bookshelf/lib/mount-models.js

@@ -16,21 +16,6 @@ const populateFetch = require('./populate');
 
 const PIVOT_PREFIX = '_pivot_';
 
-// const LIFECYCLES = {
-//   creating: 'beforeCreate',
-//   created: 'afterCreate',
-//   destroying: 'beforeDestroy',
-//   destroyed: 'afterDestroy',
-//   updating: 'beforeUpdate',
-//   updated: 'afterUpdate',
-//   fetching: 'beforeFetch',
-//   'fetching:collection': 'beforeFetchAll',
-//   fetched: 'afterFetch',
-//   'fetched:collection': 'afterFetchAll',
-//   saving: 'beforeSave',
-//   saved: 'afterSave',
-// };
-
 const getDatabaseName = connection => {
   const dbName = _.get(connection.settings, 'database');
   const dbSchema = _.get(connection.settings, 'schema', 'public');
@@ -566,28 +551,12 @@ module.exports = ({ models, target }, ctx) => {
         // Load bookshelf plugin arguments from model options
         this.constructor.__super__.initialize.apply(this, arguments);
 
-        // _.forEach(LIFECYCLES, (fn, key) => {
-        //   if (_.isFunction(target[model.toLowerCase()][fn])) {
-        //     this.on(key, target[model.toLowerCase()][fn]);
-        //   }
-        // });
-
-        // Update withRelated level to bypass many-to-many association for polymorphic relationshiips.
-        // Apply only during fetching.
         this.on('fetching fetching:collection', (instance, attrs, options) => {
           populateFetch(definition, options);
-
-          // return _.isFunction(target[model.toLowerCase()]['beforeFetchAll'])
-          //   ? target[model.toLowerCase()]['beforeFetchAll']
-          //   : Promise.resolve();
         });
 
         this.on('saving', (instance, attrs) => {
           instance.attributes = _.assign(instance.attributes, mapper(attrs));
-
-          return _.isFunction(target[model.toLowerCase()]['beforeSave']);
-          // ? target[model.toLowerCase()]['beforeSave']
-          // : Promise.resolve();
         });
 
         const formatValue = createFormatter(definition.client);
@@ -598,37 +567,12 @@ module.exports = ({ models, target }, ctx) => {
           });
         }
 
-        function formatOutput(instance) {
+        this.on('saved fetched fetched:collection', instance => {
           if (Array.isArray(instance.models)) {
             instance.models.forEach(entry => formatEntry(entry));
           } else {
             formatEntry(instance);
           }
-        }
-
-        const events = [
-          {
-            name: 'saved',
-            target: 'afterSave',
-          },
-          {
-            name: 'fetched',
-            target: 'afterFetch',
-          },
-          {
-            name: 'fetched:collection',
-            target: 'afterFetchAll',
-          },
-        ];
-
-        events.forEach(event => {
-          this.on(event.name, instance => {
-            formatOutput(instance);
-
-            // return _.isFunction(target[model.toLowerCase()][event.target])
-            //   ? target[model.toLowerCase()][event.target]
-            //   : Promise.resolve();
-          });
         });
       };
 

packages/strapi-connector-mongoose/lib/mount-models.js

@@ -82,19 +82,6 @@ module.exports = ({ models, target }, ctx) => {
       _.omitBy(definition.loadedModel, ({ type }) => type === 'virtual')
     );
 
-    // Initialize lifecycle callbacks.
-    const preLifecycle = {
-      validate: 'beforeCreate',
-      find: 'beforeFetchAll',
-      findOne: 'beforeFetch',
-      findOneAndUpdate: 'beforeUpdate',
-      findOneAndRemove: 'beforeDestroy',
-      remove: 'beforeDestroy',
-      update: 'beforeUpdate',
-      updateOne: 'beforeUpdate',
-      save: 'beforeSave',
-    };
-
     const findLifecycles = ['find', 'findOne', 'findOneAndUpdate', 'findOneAndRemove'];
 
     /*
@@ -102,7 +89,6 @@ module.exports = ({ models, target }, ctx) => {
         It allows us to make Upload.find().populate('related')
         instead of Upload.find().populate('related.item')
       */
-
     const morphAssociations = definition.associations.filter(isPolymorphicAssoc);
 
     const populateFn = createOnFetchPopulateFn({
@@ -115,45 +101,6 @@ module.exports = ({ models, target }, ctx) => {
       schema.pre(key, populateFn);
     });
 
-    Object.keys(preLifecycle).forEach(key => {
-      const fn = preLifecycle[key];
-
-      if (_.isFunction(target[model.toLowerCase()][fn])) {
-        schema.pre(key, function() {
-          return target[model.toLowerCase()][fn](this);
-        });
-      }
-    });
-
-    const postLifecycle = {
-      validate: 'afterCreate',
-      findOneAndRemove: 'afterDestroy',
-      remove: 'afterDestroy',
-      update: 'afterUpdate',
-      updateOne: 'afterUpdate',
-      find: 'afterFetchAll',
-      findOne: 'afterFetch',
-      save: 'afterSave',
-    };
-
-    // Mongoose doesn't allow post 'remove' event on model.
-    // See https://github.com/Automattic/mongoose/issues/3054
-    Object.keys(postLifecycle).forEach(key => {
-      const fn = postLifecycle[key];
-
-      if (_.isFunction(target[model.toLowerCase()][fn])) {
-        schema.post(key, function(doc, next) {
-          target[model.toLowerCase()]
-            [fn](this, doc)
-            .then(next)
-            .catch(err => {
-              strapi.log.error(err);
-              next(err);
-            });
-        });
-      }
-    });
-
     // Add virtual key to provide populate and reverse populate
     _.forEach(
       _.pickBy(definition.loadedModel, model => {

packages/strapi-database/lib/queries/create-query.js

@@ -42,33 +42,33 @@ module.exports = function createQuery(opts) {
       return mapping[this.model.orm].call(this, { model: this.model });
     },
 
-    create: wrapQuery({ hook: 'create', model, connectorQuery }),
-    update: wrapQuery({ hook: 'update', model, connectorQuery }),
-    delete: wrapQuery({ hook: 'delete', model, connectorQuery }),
-    find: wrapQuery({ hook: 'find', model, connectorQuery }),
-    findOne: wrapQuery({ hook: 'findOne', model, connectorQuery }),
-    count: wrapQuery({ hook: 'count', model, connectorQuery }),
-    search: wrapQuery({ hook: 'search', model, connectorQuery }),
-    countSearch: wrapQuery({ hook: 'countSearch', model, connectorQuery }),
+    create: createQueryWithHooks({ query: 'create', model, connectorQuery }),
+    update: createQueryWithHooks({ query: 'update', model, connectorQuery }),
+    delete: createQueryWithHooks({ query: 'delete', model, connectorQuery }),
+    find: createQueryWithHooks({ query: 'find', model, connectorQuery }),
+    findOne: createQueryWithHooks({ query: 'findOne', model, connectorQuery }),
+    count: createQueryWithHooks({ query: 'count', model, connectorQuery }),
+    search: createQueryWithHooks({ query: 'search', model, connectorQuery }),
+    countSearch: createQueryWithHooks({ query: 'countSearch', model, connectorQuery }),
   };
 };
 
 // wraps a connectorQuery call with:
 // - param substitution
 // - lifecycle hooks
-const wrapQuery = ({ hook, model, connectorQuery }) => async (params, ...rest) => {
+const createQueryWithHooks = ({ query, model, connectorQuery }) => async (params, ...rest) => {
   // substite id for primaryKey value in params
   const newParams = replaceIdByPrimaryKey(params, model);
   const queryArguments = [newParams, ...rest];
 
   // execute before hook
-  await executeBeforeHook(hook, model, ...queryArguments);
+  await executeBeforeHook(query, model, ...queryArguments);
 
   // execute query
-  const result = await connectorQuery[hook](...queryArguments);
+  const result = await connectorQuery[query](...queryArguments);
 
   // execute after hook with result and arguments
-  await executeAfterHook(hook, model, result, ...queryArguments);
+  await executeAfterHook(query, model, result, ...queryArguments);
 
   // return result
   return result;