Create a webhook model to perist them outside of the core_store

packages/strapi-admin/controllers/Webhooks.js

@@ -16,7 +16,6 @@ module.exports = {
       url,
       headers,
       events,
-      isEnabled: true,
     });
 
     strapi.webhookRunner.add(webhook);
@@ -28,6 +27,10 @@ module.exports = {
     const { id } = ctx.params;
     const webhook = await strapi.webhookStore.findWebhook(id);
 
+    if (!webhook) {
+      return ctx.notFound('webhook.notFound');
+    }
+
     ctx.send({ data: webhook });
   },
 

packages/strapi-plugin-graphql/services/Loaders.js

@@ -17,7 +17,7 @@ module.exports = {
 
     // Create loaders for each relational field (exclude core models).
     Object.keys(strapi.models)
-      .filter(model => model !== 'core_store')
+      .filter(model => model.internal !== true)
       .forEach(modelKey => {
         const model = strapi.models[modelKey];
         this.createLoader(model.uid);

packages/strapi-plugin-graphql/services/Schema.js

@@ -135,7 +135,7 @@ const schemaBuilder = {
     // build defaults schemas if shadowCRUD is enabled
     if (strapi.plugins.graphql.config.shadowCRUD !== false) {
       const modelCruds = Resolvers.buildShadowCRUD(
-        _.omit(strapi.models, ['core_store'])
+        _.omitBy(strapi.models, model => model.internal === true)
       );
 
       shadowCRUD = Object.keys(strapi.plugins).reduce((acc, plugin) => {

packages/strapi/lib/Strapi.js

@@ -31,7 +31,10 @@ const getPrefixedDeps = require('./utils/get-prefixed-dependencies');
 
 const createEventHub = require('./services/event-hub');
 const createWebhookRunner = require('./services/webhook-runner');
-const createWebhookStore = require('./services/webhook-store');
+const {
+  webhookModel,
+  createWebhookStore,
+} = require('./services/webhook-store');
 const { createCoreStore, coreStoreModel } = require('./services/core-store');
 const { createDatabaseManager } = require('strapi-database');
 
@@ -366,6 +369,7 @@ class Strapi extends EventEmitter {
 
     // Init core store
     this.models['core_store'] = coreStoreModel;
+    this.models['strapi_webhooks'] = webhookModel;
 
     this.db = createDatabaseManager(this);
     await this.db.initialize();

packages/strapi/lib/services/core-store.js

@@ -1,6 +1,8 @@
 'use strict';
 
 const coreStoreModel = {
+  uid: 'strapi::core-store',
+  internal: true,
   connection: 'default',
   info: {
     name: 'core_store',

packages/strapi/lib/services/webhook-runner.js

@@ -107,8 +107,8 @@ class WebhookRunner {
 
   update(webhook) {
     debug(`Refreshing webhook '${webhook.id}'`);
-    this.unregister(webhook);
+    this.remove(webhook);
-    this.register(webhook);
+    this.add(webhook);
   }
 
   remove(webhook) {

packages/strapi/lib/services/webhook-store.js

@@ -3,81 +3,104 @@
  */
 'use strict';
 
-const uuid = require('uuid');
+const webhookModel = {
+  uid: 'strapi::webhooks',
+  internal: true,
+  connection: 'default',
+  globalId: 'StrapiWebhooks',
+  collectionName: 'strapi_webhooks',
+  info: {
+    name: 'Strapi webhooks',
+    description: '',
+  },
+  attributes: {
+    name: {
+      type: 'string',
+    },
+    url: {
+      type: 'text',
+    },
+    headers: {
+      type: 'json',
+    },
+    events: {
+      type: 'json',
+    },
+    enabled: {
+      type: 'boolean',
+    },
+  },
+};
 
-module.exports = ({ db }) => ({
+const formatWebhookInfo = webhook => {
+  return {
+    id: webhook.id,
+    name: webhook.name,
+    url: webhook.url,
+    headers: webhook.headers,
+    events: webhook.events,
+    isEnabled: webhook.enabled,
+  };
+};
+
+const createWebhookStore = ({ db }) => {
+  const webhookQueries = db.query('strapi_webhooks');
+
+  return {
     async findWebhooks() {
-    const row = await db.query('core_store').findOne({
+      const results = await webhookQueries.find();
-      key: 'webhooks',
-    });
 
-    return row ? JSON.parse(row.value) : [];
+      return results.map(formatWebhookInfo);
     },
 
     async findWebhook(id) {
-    const webhooks = await this.findWebhooks();
+      const result = await webhookQueries.findOne({ id });
-    return webhooks.find(hook => hook.id === id);
+      return result ? formatWebhookInfo(result) : null;
     },
 
-  async createWebhook(data) {
+    createWebhook(data) {
-    const webhooks = await this.findWebhooks();
+      const { name, url, headers, events } = data;
 
       const webhook = {
-      id: uuid(),
+        name,
-      ...data,
+        url,
+        headers,
+        events,
+        enabled: true,
       };
 
-    const res = await db.query('core_store').findOne({
+      return webhookQueries.create(webhook).then(formatWebhookInfo);
-      key: 'webhooks',
-    });
-
-    if (!res) {
-      await db
-        .query('core_store')
-        .create({ key: 'webhooks', value: JSON.stringify([webhook]) });
-    } else {
-      await db
-        .query('core_store')
-        .update(
-          { key: 'webhooks' },
-          { value: JSON.stringify(webhooks.concat(webhook)) }
-        );
-    }
-
-    return webhook;
     },
 
     async updateWebhook(id, data) {
       const oldWebhook = await this.findWebhook(id);
-    const webhooks = await this.findWebhooks();
 
-    const updatedWebhook = {
+      if (!oldWebhook) {
-      ...oldWebhook,
+        throw new Error('webhook.notFound');
-      ...data,
-    };
-
-    const updatedWebhooks = webhooks.map(webhook => {
-      if (webhook.id === id) {
-        return updatedWebhook;
       }
 
-      return webhook;
+      const { name, url, headers, events, isEnabled } = data;
-    });
 
-    await db
+      const updatedWebhook = {
-      .query('core_store')
+        name,
-      .update({ key: 'webhooks' }, { value: JSON.stringify(updatedWebhooks) });
+        url,
+        headers,
+        events,
+        enabled: isEnabled,
+      };
 
-    return updatedWebhook;
+      return webhookQueries
+        .update({ id }, updatedWebhook)
+        .then(formatWebhookInfo);
     },
 
-  async deleteWebhook(id) {
+    deleteWebhook(id) {
-    const webhooks = await this.findWebhooks();
+      return webhookQueries.delete({ id });
-
-    const updatedWebhooks = webhooks.filter(webhook => webhook.id !== id);
-
-    await db
-      .query('core_store')
-      .update({ key: 'webhooks' }, { value: JSON.stringify(updatedWebhooks) });
     },
-});
+  };
+};
+
+module.exports = {
+  webhookModel,
+  createWebhookStore,
+};