@akemona-org/strapi-admin 3.7.0

package/config/routes.json

@@ -0,0 +1,320 @@
+{
+  "routes": [
+    {
+      "method": "GET",
+      "path": "/plugins",
+      "handler": "admin.plugins",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin",
+          ["admin::hasPermissions", ["admin::marketplace.read"]]
+        ]
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/init",
+      "handler": "admin.init"
+    },
+    {
+      "method": "GET",
+      "path": "/information",
+      "handler": "admin.information",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin"
+        ]
+      }
+    },
+    {
+      "method": "POST",
+      "path": "/plugins/install",
+      "handler": "admin.installPlugin",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin",
+          ["admin::hasPermissions", ["admin::marketplace.plugins.install"]]
+        ]
+      }
+    },
+    {
+      "method": "DELETE",
+      "path": "/plugins/uninstall/:plugin",
+      "handler": "admin.uninstallPlugin",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin",
+          ["admin::hasPermissions", ["admin::marketplace.plugins.uninstall"]]
+        ]
+      }
+    },
+    {
+      "method": "POST",
+      "path": "/login",
+      "handler": "authentication.login"
+    },
+    {
+      "method": "POST",
+      "path": "/renew-token",
+      "handler": "authentication.renewToken"
+    },
+    {
+      "method": "POST",
+      "path": "/register-admin",
+      "handler": "authentication.registerAdmin"
+    },
+    {
+      "method": "GET",
+      "path": "/registration-info",
+      "handler": "authentication.registrationInfo"
+    },
+    {
+      "method": "POST",
+      "path": "/register",
+      "handler": "authentication.register"
+    },
+    {
+      "method": "POST",
+      "path": "/forgot-password",
+      "handler": "authentication.forgotPassword"
+    },
+    {
+      "method": "POST",
+      "path": "/reset-password",
+      "handler": "authentication.resetPassword"
+    },
+    {
+      "method": "GET",
+      "path": "/webhooks",
+      "handler": "Webhooks.listWebhooks",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin",
+          ["admin::hasPermissions", ["admin::webhooks.read"]]
+        ]
+      }
+    },
+    {
+      "method": "POST",
+      "path": "/webhooks",
+      "handler": "Webhooks.createWebhook",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin",
+          ["admin::hasPermissions", ["admin::webhooks.create"]]
+        ]
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/webhooks/:id",
+      "handler": "Webhooks.getWebhook",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin",
+          ["admin::hasPermissions", ["admin::webhooks.read"]]
+        ]
+      }
+    },
+    {
+      "method": "PUT",
+      "path": "/webhooks/:id",
+      "handler": "Webhooks.updateWebhook",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin",
+          ["admin::hasPermissions", ["admin::webhooks.update"]]
+        ]
+      }
+    },
+    {
+      "method": "DELETE",
+      "path": "/webhooks/:id",
+      "handler": "Webhooks.deleteWebhook",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin",
+          ["admin::hasPermissions", ["admin::webhooks.delete"]]
+        ]
+      }
+    },
+    {
+      "method": "POST",
+      "path": "/webhooks/batch-delete",
+      "handler": "Webhooks.deleteWebhooks",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin",
+          ["admin::hasPermissions", ["admin::webhooks.delete"]]
+        ]
+      }
+    },
+    {
+      "method": "POST",
+      "path": "/webhooks/:id/trigger",
+      "handler": "Webhooks.triggerWebhook",
+      "config": {
+        "policies": []
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/users/me",
+      "handler": "authenticated-user.getMe",
+      "config": {
+        "policies": ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      "method": "PUT",
+      "path": "/users/me",
+      "handler": "authenticated-user.updateMe",
+      "config": {
+        "policies": ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/users/me/permissions",
+      "handler": "authenticated-user.getOwnPermissions",
+      "config": {
+        "policies": ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      "method": "POST",
+      "path": "/users",
+      "handler": "user.create",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin",
+          ["admin::hasPermissions", ["admin::users.create"]]
+        ]
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/users",
+      "handler": "user.find",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin",
+          ["admin::hasPermissions", ["admin::users.read"]]
+        ]
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/users/:id",
+      "handler": "user.findOne",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin",
+          ["admin::hasPermissions", ["admin::users.read"]]
+        ]
+      }
+    },
+    {
+      "method": "PUT",
+      "path": "/users/:id",
+      "handler": "user.update",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin",
+          ["admin::hasPermissions", ["admin::users.update"]]
+        ]
+      }
+    },
+    {
+      "method": "DELETE",
+      "path": "/users/:id",
+      "handler": "user.deleteOne",
+      "config": {
+        "policies": [
+          ["admin::hasPermissions", ["admin::users.delete"]]
+        ]
+      }
+    },
+    {
+      "method": "POST",
+      "path": "/users/batch-delete",
+      "handler": "user.deleteMany",
+      "config": {
+        "policies": [
+          ["admin::hasPermissions", ["admin::users.delete"]]
+        ]
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/roles/:id/permissions",
+      "handler": "role.getPermissions",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin",
+          ["admin::hasPermissions", ["admin::roles.read"]]
+        ]
+      }
+    },
+    {
+      "method": "PUT",
+      "path": "/roles/:id/permissions",
+      "handler": "role.updatePermissions",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin",
+          ["admin::hasPermissions", ["admin::roles.update"]]
+        ]
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/roles/:id",
+      "handler": "role.findOne",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin",
+          ["admin::hasPermissions", ["admin::roles.read"]]
+        ]
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/roles",
+      "handler": "role.findAll",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin",
+          ["admin::hasPermissions", ["admin::roles.read"]]
+        ]
+      }
+    },
+    {
+      "method": "PUT",
+      "path": "/roles/:id",
+      "handler": "role.update",
+      "config": {
+        "policies": [
+          "admin::isAuthenticatedAdmin",
+          ["admin::hasPermissions", ["admin::roles.update"]]
+        ]
+      }
+    },
+    {
+      "method": "GET",
+      "path": "/permissions",
+      "handler": "permission.getAll",
+      "config": {
+        "policies": ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      "method": "POST",
+      "path": "/permissions/check",
+      "handler": "permission.check",
+      "config": {
+        "policies": ["admin::isAuthenticatedAdmin"]
+      }
+    }
+  ]
+}

package/config/settings.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const forgotPasswordTemplate = require('./email-templates/forgot-password');
+
+module.exports = {
+  forgotPassword: {
+    emailTemplate: forgotPasswordTemplate,
+  },
+};

package/controllers/Webhooks.js

@@ -0,0 +1,150 @@
+'use strict';
+
+const _ = require('lodash');
+const { yup, formatYupErrors, webhook: webhookUtils } = require('@akemona-org/strapi-utils');
+
+const urlRegex =
+  /^(?:([a-z0-9+.-]+):\/\/)(?:\S+(?::\S*)?@)?(?:(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u00a1-\uffff0-9_]-*)*[a-z\u00a1-\uffff0-9_]+)(?:\.(?:[a-z\u00a1-\uffff0-9_]-*)*[a-z\u00a1-\uffff0-9_]+)*\.?)(?::\d{2,5})?(?:[/?#]\S*)?$/;
+
+const webhookValidator = yup
+  .object({
+    name: yup.string().required(),
+    url: yup.string().matches(urlRegex, 'url must be a valid URL').required(),
+    headers: yup.lazy((data) => {
+      if (typeof data !== 'object') {
+        return yup.object().required();
+      }
+
+      return yup
+        .object(
+          _.mapValues(data, () => {
+            yup.string().min(1).required();
+          })
+        )
+        .required();
+    }),
+    events: yup.array().of(yup.string().oneOf(_.values(webhookUtils.webhookEvents)).required()),
+  })
+  .noUnknown();
+
+const updateWebhookValidator = webhookValidator.shape({
+  isEnabled: yup.boolean(),
+});
+
+module.exports = {
+  async listWebhooks(ctx) {
+    const webhooks = await strapi.webhookStore.findWebhooks();
+    ctx.send({ data: webhooks });
+  },
+
+  async getWebhook(ctx) {
+    const { id } = ctx.params;
+    const webhook = await strapi.webhookStore.findWebhook(id);
+
+    if (!webhook) {
+      return ctx.notFound('webhook.notFound');
+    }
+
+    ctx.send({ data: webhook });
+  },
+
+  async createWebhook(ctx) {
+    const { body } = ctx.request;
+
+    try {
+      await webhookValidator.validate(body, {
+        strict: true,
+        abortEarly: false,
+      });
+    } catch (error) {
+      return ctx.badRequest('ValidationError', {
+        errors: formatYupErrors(error),
+      });
+    }
+
+    const webhook = await strapi.webhookStore.createWebhook(body);
+
+    strapi.webhookRunner.add(webhook);
+
+    ctx.created({ data: webhook });
+  },
+
+  async updateWebhook(ctx) {
+    const { id } = ctx.params;
+    const { body } = ctx.request;
+
+    try {
+      await updateWebhookValidator.validate(body, {
+        strict: true,
+        abortEarly: false,
+      });
+    } catch (error) {
+      return ctx.badRequest('ValidationError', {
+        errors: formatYupErrors(error),
+      });
+    }
+
+    const webhook = await strapi.webhookStore.findWebhook(id);
+
+    if (!webhook) {
+      return ctx.notFound('webhook.notFound');
+    }
+
+    const updatedWebhook = await strapi.webhookStore.updateWebhook(id, {
+      ...webhook,
+      ...body,
+    });
+
+    if (!updatedWebhook) {
+      return ctx.notFound('webhook.notFound');
+    }
+
+    strapi.webhookRunner.update(updatedWebhook);
+
+    ctx.send({ data: updatedWebhook });
+  },
+
+  async deleteWebhook(ctx) {
+    const { id } = ctx.params;
+    const webhook = await strapi.webhookStore.findWebhook(id);
+
+    if (!webhook) {
+      return ctx.notFound('webhook.notFound');
+    }
+
+    await strapi.webhookStore.deleteWebhook(id);
+
+    strapi.webhookRunner.remove(webhook);
+
+    ctx.body = { data: webhook };
+  },
+
+  async deleteWebhooks(ctx) {
+    const { ids } = ctx.request.body;
+
+    if (!Array.isArray(ids) || ids.length === 0) {
+      return ctx.badRequest('ids must be an array of id');
+    }
+
+    for (const id of ids) {
+      const webhook = await strapi.webhookStore.findWebhook(id);
+
+      if (!webhook) continue;
+
+      await strapi.webhookStore.deleteWebhook(id);
+      strapi.webhookRunner.remove(webhook);
+    }
+
+    ctx.send({ data: ids });
+  },
+
+  async triggerWebhook(ctx) {
+    const { id } = ctx.params;
+
+    const webhook = await strapi.webhookStore.findWebhook(id);
+
+    const response = await strapi.webhookRunner.run(webhook, 'trigger-test', {});
+
+    ctx.body = { data: response };
+  },
+};

package/controllers/admin.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const execa = require('execa');
+const _ = require('lodash');
+
+const PLUGIN_NAME_REGEX = /^[A-Za-z][A-Za-z0-9-_]+$/;
+
+/**
+ * Validates a plugin name format
+ */
+const isValidPluginName = plugin => {
+  return _.isString(plugin) && !_.isEmpty(plugin) && PLUGIN_NAME_REGEX.test(plugin);
+};
+
+/**
+ * A set of functions called "actions" for `Admin`
+ */
+
+module.exports = {
+  async init() {
+    const uuid = strapi.config.get('uuid', false);
+    const hasAdmin = await strapi.admin.services.user.exists();
+
+    return { data: { uuid, hasAdmin } };
+  },
+
+  async information() {
+    const currentEnvironment = strapi.app.env;
+    const autoReload = strapi.config.get('autoReload', false);
+    const strapiVersion = strapi.config.get('info.strapi', null);
+    const nodeVersion = process.version;
+    const communityEdition = !strapi.EE;
+
+    return {
+      data: { currentEnvironment, autoReload, strapiVersion, nodeVersion, communityEdition },
+    };
+  },
+
+  async installPlugin(ctx) {
+    try {
+      const { plugin } = ctx.request.body;
+
+      if (!isValidPluginName(plugin)) {
+        return ctx.badRequest('Invalid plugin name');
+      }
+
+      strapi.reload.isWatching = false;
+
+      strapi.log.info(`Installing ${plugin}...`);
+      await execa('npm', ['run', 'strapi', '--', 'install', plugin]);
+
+      ctx.send({ ok: true });
+
+      strapi.reload();
+    } catch (err) {
+      strapi.log.error(err);
+      strapi.reload.isWatching = true;
+      ctx.badRequest(null, [{ messages: [{ id: 'An error occurred' }] }]);
+    }
+  },
+
+  async plugins(ctx) {
+    try {
+      const plugins = Object.keys(strapi.plugins).reduce((acc, key) => {
+        acc[key] = _.get(strapi.plugins, [key, 'package', 'strapi'], {
+          name: key,
+        });
+
+        return acc;
+      }, {});
+
+      ctx.send({ plugins });
+    } catch (err) {
+      strapi.log.error(err);
+      ctx.badRequest(null, [{ messages: [{ id: 'An error occurred' }] }]);
+    }
+  },
+
+  async uninstallPlugin(ctx) {
+    try {
+      const { plugin } = ctx.params;
+
+      if (!isValidPluginName(plugin)) {
+        return ctx.badRequest('Invalid plugin name');
+      }
+
+      strapi.reload.isWatching = false;
+
+      strapi.log.info(`Uninstalling ${plugin}...`);
+      await execa('npm', ['run', 'strapi', '--', 'uninstall', plugin, '-d']);
+
+      ctx.send({ ok: true });
+
+      strapi.reload();
+    } catch (err) {
+      strapi.log.error(err);
+      strapi.reload.isWatching = true;
+      ctx.badRequest(null, [{ messages: [{ id: 'An error occurred' }] }]);
+    }
+  },
+};

package/controllers/authenticated-user.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const { validateProfileUpdateInput } = require('../validation/user');
+const { getService } = require('../utils');
+
+module.exports = {
+  async getMe(ctx) {
+    const userInfo = getService('user').sanitizeUser(ctx.state.user);
+
+    ctx.body = {
+      data: userInfo,
+    };
+  },
+
+  async updateMe(ctx) {
+    const input = ctx.request.body;
+
+    try {
+      await validateProfileUpdateInput(input);
+    } catch (err) {
+      return ctx.badRequest('ValidationError', err);
+    }
+
+    const { currentPassword, ...userInfo } = input;
+
+    const authService = getService('auth');
+    const userService = getService('user');
+
+    if (currentPassword && userInfo.password) {
+      const isValid = await authService.validatePassword(currentPassword, ctx.state.user.password);
+
+      if (!isValid) {
+        return ctx.badRequest('ValidationError', {
+          currentPassword: ['Invalid credentials'],
+        });
+      }
+    }
+
+    const updatedUser = await userService.updateById(ctx.state.user.id, userInfo);
+
+    ctx.body = {
+      data: userService.sanitizeUser(updatedUser),
+    };
+  },
+
+  async getOwnPermissions(ctx) {
+    const { findUserPermissions, sanitizePermission } = getService('permission');
+    const { user } = ctx.state;
+
+    const userPermissions = await findUserPermissions(user);
+
+    ctx.body = {
+      data: userPermissions.map(sanitizePermission),
+    };
+  },
+};