@strapi/plugin-users-permissions 4.0.0-next.9 → 4.0.3

package/server/graphql/index.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const getTypes = require('./types');
+const getQueries = require('./queries');
+const getMutations = require('./mutations');
+const getResolversConfig = require('./resolvers-configs');
+
+module.exports = ({ strapi }) => {
+  const { config: graphQLConfig } = strapi.plugin('graphql');
+  const extensionService = strapi.plugin('graphql').service('extension');
+
+  const isShadowCRUDEnabled = graphQLConfig('shadowCRUD', true);
+
+  if (!isShadowCRUDEnabled) {
+    return;
+  }
+
+  // Disable Permissions queries & mutations but allow the
+  // type to be used/selected in filters or nested resolvers
+  extensionService
+    .shadowCRUD('plugin::users-permissions.permission')
+    .disableQueries()
+    .disableMutations();
+
+  // Disable User & Role's Create/Update/Delete actions so they can be replaced
+  const actionsToDisable = ['create', 'update', 'delete'];
+
+  extensionService.shadowCRUD('plugin::users-permissions.user').disableActions(actionsToDisable);
+  extensionService.shadowCRUD('plugin::users-permissions.role').disableActions(actionsToDisable);
+
+  // Register new types & resolvers config
+  extensionService.use(({ nexus }) => {
+    const types = getTypes({ strapi, nexus });
+    const queries = getQueries({ strapi, nexus });
+    const mutations = getMutations({ strapi, nexus });
+    const resolversConfig = getResolversConfig({ strapi });
+
+    return {
+      types: [types, queries, mutations],
+
+      resolversConfig,
+    };
+  });
+};

package/server/graphql/mutations/auth/email-confirmation.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const { toPlainObject } = require('lodash/fp');
+
+const { checkBadRequest } = require('../../utils');
+
+module.exports = ({ nexus, strapi }) => {
+  const { nonNull } = nexus;
+
+  return {
+    type: 'UsersPermissionsLoginPayload',
+
+    args: {
+      confirmation: nonNull('String'),
+    },
+
+    description: 'Confirm an email users email address',
+
+    async resolve(parent, args, context) {
+      const { koaContext } = context;
+
+      koaContext.request.body = toPlainObject(args);
+
+      await strapi
+        .plugin('users-permissions')
+        .controller('auth')
+        .emailConfirmation(koaContext, null, true);
+
+      const output = koaContext.body;
+
+      checkBadRequest(output);
+
+      return {
+        user: output.user || output,
+        jwt: output.jwt,
+      };
+    },
+  };
+};

package/server/graphql/mutations/auth/forgot-password.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const { toPlainObject } = require('lodash/fp');
+
+const { checkBadRequest } = require('../../utils');
+
+module.exports = ({ nexus, strapi }) => {
+  const { nonNull } = nexus;
+
+  return {
+    type: 'UsersPermissionsPasswordPayload',
+
+    args: {
+      email: nonNull('String'),
+    },
+
+    description: 'Request a reset password token',
+
+    async resolve(parent, args, context) {
+      const { koaContext } = context;
+
+      koaContext.request.body = toPlainObject(args);
+
+      await strapi
+        .plugin('users-permissions')
+        .controller('auth')
+        .forgotPassword(koaContext);
+
+      const output = koaContext.body;
+
+      checkBadRequest(output);
+
+      return {
+        ok: output.ok || output,
+      };
+    },
+  };
+};

package/server/graphql/mutations/auth/login.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const { toPlainObject } = require('lodash/fp');
+
+const { checkBadRequest } = require('../../utils');
+
+module.exports = ({ nexus, strapi }) => {
+  const { nonNull } = nexus;
+
+  return {
+    type: nonNull('UsersPermissionsLoginPayload'),
+
+    args: {
+      input: nonNull('UsersPermissionsLoginInput'),
+    },
+
+    async resolve(parent, args, context) {
+      const { koaContext } = context;
+
+      koaContext.params = { provider: args.input.provider };
+      koaContext.request.body = toPlainObject(args.input);
+
+      await strapi
+        .plugin('users-permissions')
+        .controller('auth')
+        .callback(koaContext);
+
+      const output = koaContext.body;
+
+      checkBadRequest(output);
+
+      return {
+        user: output.user || output,
+        jwt: output.jwt,
+      };
+    },
+  };
+};

package/server/graphql/mutations/auth/register.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const { toPlainObject } = require('lodash/fp');
+
+const { checkBadRequest } = require('../../utils');
+
+module.exports = ({ nexus, strapi }) => {
+  const { nonNull } = nexus;
+
+  return {
+    type: nonNull('UsersPermissionsLoginPayload'),
+
+    args: {
+      input: nonNull('UsersPermissionsRegisterInput'),
+    },
+
+    description: 'Register a user',
+
+    async resolve(parent, args, context) {
+      const { koaContext } = context;
+
+      koaContext.request.body = toPlainObject(args.input);
+
+      await strapi
+        .plugin('users-permissions')
+        .controller('auth')
+        .register(koaContext);
+
+      const output = koaContext.body;
+
+      checkBadRequest(output);
+
+      return {
+        user: output.user || output,
+        jwt: output.jwt,
+      };
+    },
+  };
+};

package/server/graphql/mutations/auth/reset-password.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const { toPlainObject } = require('lodash/fp');
+
+const { checkBadRequest } = require('../../utils');
+
+module.exports = ({ nexus, strapi }) => {
+  const { nonNull } = nexus;
+
+  return {
+    type: 'UsersPermissionsLoginPayload',
+
+    args: {
+      password: nonNull('String'),
+      passwordConfirmation: nonNull('String'),
+      code: nonNull('String'),
+    },
+
+    description: 'Reset user password. Confirm with a code (resetToken from forgotPassword)',
+
+    async resolve(parent, args, context) {
+      const { koaContext } = context;
+
+      koaContext.request.body = toPlainObject(args);
+
+      await strapi
+        .plugin('users-permissions')
+        .controller('auth')
+        .resetPassword(koaContext);
+
+      const output = koaContext.body;
+
+      checkBadRequest(output);
+
+      return {
+        user: output.user || output,
+        jwt: output.jwt,
+      };
+    },
+  };
+};

package/server/graphql/mutations/crud/role/create-role.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const { toPlainObject } = require('lodash/fp');
+
+const usersPermissionsRoleUID = 'plugin::users-permissions.role';
+
+module.exports = ({ nexus, strapi }) => {
+  const { getContentTypeInputName } = strapi.plugin('graphql').service('utils').naming;
+  const { nonNull } = nexus;
+
+  const roleContentType = strapi.getModel(usersPermissionsRoleUID);
+
+  const roleInputName = getContentTypeInputName(roleContentType);
+
+  return {
+    type: 'UsersPermissionsCreateRolePayload',
+
+    args: {
+      data: nonNull(roleInputName),
+    },
+
+    description: 'Create a new role',
+
+    async resolve(parent, args, context) {
+      const { koaContext } = context;
+
+      koaContext.request.body = toPlainObject(args.data);
+
+      await strapi
+        .plugin('users-permissions')
+        .controller('role')
+        .createRole(koaContext);
+
+      return { ok: true };
+    },
+  };
+};

package/server/graphql/mutations/crud/role/delete-role.js

@@ -0,0 +1,28 @@
+'use strict';
+
+module.exports = ({ nexus, strapi }) => {
+  const { nonNull } = nexus;
+
+  return {
+    type: 'UsersPermissionsDeleteRolePayload',
+
+    args: {
+      id: nonNull('ID'),
+    },
+
+    description: 'Delete an existing role',
+
+    async resolve(parent, args, context) {
+      const { koaContext } = context;
+
+      koaContext.params = { role: args.id };
+
+      await strapi
+        .plugin('users-permissions')
+        .controller('role')
+        .deleteRole(koaContext);
+
+      return { ok: true };
+    },
+  };
+};

package/server/graphql/mutations/crud/role/update-role.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const usersPermissionsRoleUID = 'plugin::users-permissions.role';
+
+module.exports = ({ nexus, strapi }) => {
+  const { getContentTypeInputName } = strapi.plugin('graphql').service('utils').naming;
+  const { nonNull } = nexus;
+
+  const roleContentType = strapi.getModel(usersPermissionsRoleUID);
+
+  const roleInputName = getContentTypeInputName(roleContentType);
+
+  return {
+    type: 'UsersPermissionsUpdateRolePayload',
+
+    args: {
+      id: nonNull('ID'),
+      data: nonNull(roleInputName),
+    },
+
+    description: 'Update an existing role',
+
+    async resolve(parent, args, context) {
+      const { koaContext } = context;
+
+      koaContext.params = { role: args.id };
+      koaContext.request.body = args.data;
+      koaContext.request.body.role = args.id;
+
+      await strapi
+        .plugin('users-permissions')
+        .controller('role')
+        .updateRole(koaContext);
+
+      return { ok: true };
+    },
+  };
+};

package/server/graphql/mutations/crud/user/create-user.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const { toPlainObject } = require('lodash/fp');
+
+const { checkBadRequest } = require('../../../utils');
+
+const usersPermissionsUserUID = 'plugin::users-permissions.user';
+
+module.exports = ({ nexus, strapi }) => {
+  const { nonNull } = nexus;
+  const { getContentTypeInputName, getEntityResponseName } = strapi
+    .plugin('graphql')
+    .service('utils').naming;
+
+  const userContentType = strapi.getModel(usersPermissionsUserUID);
+
+  const userInputName = getContentTypeInputName(userContentType);
+  const responseName = getEntityResponseName(userContentType);
+
+  return {
+    type: nonNull(responseName),
+
+    args: {
+      data: nonNull(userInputName),
+    },
+
+    description: 'Create a new user',
+
+    async resolve(parent, args, context) {
+      const { koaContext } = context;
+
+      koaContext.params = {};
+      koaContext.request.body = toPlainObject(args.data);
+
+      await strapi
+        .plugin('users-permissions')
+        .controller('user')
+        .create(koaContext);
+
+      checkBadRequest(koaContext.body);
+
+      return {
+        value: koaContext.body,
+        info: { args, resourceUID: 'plugin::users-permissions.user' },
+      };
+    },
+  };
+};

package/server/graphql/mutations/crud/user/delete-user.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const { checkBadRequest } = require('../../../utils');
+
+const usersPermissionsUserUID = 'plugin::users-permissions.user';
+
+module.exports = ({ nexus, strapi }) => {
+  const { nonNull } = nexus;
+  const { getEntityResponseName } = strapi.plugin('graphql').service('utils').naming;
+
+  const userContentType = strapi.getModel(usersPermissionsUserUID);
+
+  const responseName = getEntityResponseName(userContentType);
+
+  return {
+    type: nonNull(responseName),
+
+    args: {
+      id: nonNull('ID'),
+    },
+
+    description: 'Update an existing user',
+
+    async resolve(parent, args, context) {
+      const { koaContext } = context;
+
+      koaContext.params = { id: args.id };
+
+      await strapi
+        .plugin('users-permissions')
+        .controller('user')
+        .destroy(koaContext);
+
+      checkBadRequest(koaContext.body);
+
+      return {
+        value: koaContext.body,
+        info: { args, resourceUID: 'plugin::users-permissions.user' },
+      };
+    },
+  };
+};

package/server/graphql/mutations/crud/user/update-user.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const { toPlainObject } = require('lodash/fp');
+
+const { checkBadRequest } = require('../../../utils');
+
+const usersPermissionsUserUID = 'plugin::users-permissions.user';
+
+module.exports = ({ nexus, strapi }) => {
+  const { nonNull } = nexus;
+  const { getContentTypeInputName, getEntityResponseName } = strapi
+    .plugin('graphql')
+    .service('utils').naming;
+
+  const userContentType = strapi.getModel(usersPermissionsUserUID);
+
+  const userInputName = getContentTypeInputName(userContentType);
+  const responseName = getEntityResponseName(userContentType);
+
+  return {
+    type: nonNull(responseName),
+
+    args: {
+      id: nonNull('ID'),
+      data: nonNull(userInputName),
+    },
+
+    description: 'Update an existing user',
+
+    async resolve(parent, args, context) {
+      const { koaContext } = context;
+
+      koaContext.params = { id: args.id };
+      koaContext.request.body = toPlainObject(args.data);
+
+      await strapi
+        .plugin('users-permissions')
+        .controller('user')
+        .update(koaContext);
+
+      checkBadRequest(koaContext.body);
+
+      return {
+        value: koaContext.body,
+        info: { args, resourceUID: 'plugin::users-permissions.user' },
+      };
+    },
+  };
+};

package/server/graphql/mutations/index.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const userUID = 'plugin::users-permissions.user';
+const roleUID = 'plugin::users-permissions.role';
+
+module.exports = context => {
+  const { nexus, strapi } = context;
+
+  const { naming } = strapi.plugin('graphql').service('utils');
+
+  const user = strapi.getModel(userUID);
+  const role = strapi.getModel(roleUID);
+
+  const mutations = {
+    // CRUD (user & role)
+    [naming.getCreateMutationTypeName(role)]: require('./crud/role/create-role'),
+    [naming.getUpdateMutationTypeName(role)]: require('./crud/role/update-role'),
+    [naming.getDeleteMutationTypeName(role)]: require('./crud/role/delete-role'),
+    [naming.getCreateMutationTypeName(user)]: require('./crud/user/create-user'),
+    [naming.getUpdateMutationTypeName(user)]: require('./crud/user/update-user'),
+    [naming.getDeleteMutationTypeName(user)]: require('./crud/user/delete-user'),
+
+    // Other mutations
+    login: require('./auth/login'),
+    register: require('./auth/register'),
+    forgotPassword: require('./auth/forgot-password'),
+    resetPassword: require('./auth/reset-password'),
+    emailConfirmation: require('./auth/email-confirmation'),
+  };
+
+  return nexus.extendType({
+    type: 'Mutation',
+
+    definition(t) {
+      for (const [name, getConfig] of Object.entries(mutations)) {
+        const config = getConfig(context);
+
+        t.field(name, config);
+      }
+    },
+  });
+};

package/server/graphql/queries/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const me = require('./me');
+
+module.exports = ({ nexus }) => {
+  return nexus.extendType({
+    type: 'Query',
+
+    definition(t) {
+      t.field('me', me({ nexus }));
+    },
+  });
+};

package/server/graphql/queries/me.js

@@ -0,0 +1,17 @@
+'use strict';
+
+module.exports = () => ({
+  type: 'UsersPermissionsMe',
+
+  args: {},
+
+  resolve(parent, args, context) {
+    const { user } = context.state;
+
+    if (!user) {
+      throw new Error('Authentication requested');
+    }
+
+    return user;
+  },
+});

package/server/graphql/resolvers-configs.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const userUID = 'plugin::users-permissions.user';
+const roleUID = 'plugin::users-permissions.role';
+
+module.exports = ({ strapi }) => {
+  const { naming } = strapi.plugin('graphql').service('utils');
+
+  const user = strapi.getModel(userUID);
+  const role = strapi.getModel(roleUID);
+
+  const createRole = naming.getCreateMutationTypeName(role);
+  const updateRole = naming.getUpdateMutationTypeName(role);
+  const deleteRole = naming.getDeleteMutationTypeName(role);
+  const createUser = naming.getCreateMutationTypeName(user);
+  const updateUser = naming.getUpdateMutationTypeName(user);
+  const deleteUser = naming.getDeleteMutationTypeName(user);
+
+  return {
+    // Disabled auth for some operations
+    'Mutation.login': { auth: false },
+    'Mutation.register': { auth: false },
+    'Mutation.forgotPassword': { auth: false },
+    'Mutation.resetPassword': { auth: false },
+    'Mutation.emailConfirmation': { auth: false },
+
+    // Scoped auth for replaced CRUD operations
+    // Role
+    [`Mutation.${createRole}`]: { auth: { scope: [`${roleUID}.create`] } },
+    [`Mutation.${updateRole}`]: { auth: { scope: [`${roleUID}.update`] } },
+    [`Mutation.${deleteRole}`]: { auth: { scope: [`${roleUID}.delete`] } },
+    // User
+    [`Mutation.${createUser}`]: { auth: { scope: [`${userUID}.create`] } },
+    [`Mutation.${updateUser}`]: { auth: { scope: [`${userUID}.update`] } },
+    [`Mutation.${deleteUser}`]: { auth: { scope: [`${userUID}.delete`] } },
+  };
+};

package/server/graphql/types/create-role-payload.js

@@ -0,0 +1,11 @@
+'use strict';
+
+module.exports = ({ nexus }) => {
+  return nexus.objectType({
+    name: 'UsersPermissionsCreateRolePayload',
+
+    definition(t) {
+      t.nonNull.boolean('ok');
+    },
+  });
+};

package/server/graphql/types/delete-role-payload.js

@@ -0,0 +1,11 @@
+'use strict';
+
+module.exports = ({ nexus }) => {
+  return nexus.objectType({
+    name: 'UsersPermissionsDeleteRolePayload',
+
+    definition(t) {
+      t.nonNull.boolean('ok');
+    },
+  });
+};

package/server/graphql/types/index.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const typesFactories = [
+  require('./me'),
+  require('./me-role'),
+  require('./register-input'),
+  require('./login-input'),
+  require('./password-payload'),
+  require('./login-payload'),
+  require('./create-role-payload'),
+  require('./update-role-payload'),
+  require('./delete-role-payload'),
+];
+
+/**
+ * @param {object} context
+ * @param {object} context.nexus
+ * @param {object} context.strapi
+ * @return {any[]}
+ */
+module.exports = context => typesFactories.map(factory => factory(context));

package/server/graphql/types/login-input.js

@@ -0,0 +1,13 @@
+'use strict';
+
+module.exports = ({ nexus }) => {
+  return nexus.inputObjectType({
+    name: 'UsersPermissionsLoginInput',
+
+    definition(t) {
+      t.nonNull.string('identifier');
+      t.nonNull.string('password');
+      t.nonNull.string('provider', { default: 'local' });
+    },
+  });
+};

package/server/graphql/types/login-payload.js

@@ -0,0 +1,12 @@
+'use strict';
+
+module.exports = ({ nexus }) => {
+  return nexus.objectType({
+    name: 'UsersPermissionsLoginPayload',
+
+    definition(t) {
+      t.string('jwt');
+      t.nonNull.field('user', { type: 'UsersPermissionsMe' });
+    },
+  });
+};