@strapi/plugin-users-permissions 0.0.0-next.f5312617ca16b870c2bf1adcea2c69b676979e29 → 0.0.0-next.f5d21551ed005f524bfc4760b274f1be154e26a8

package/server/controllers/content-manager-user.js

@@ -2,8 +2,7 @@
 
 const _ = require('lodash');
 const { contentTypes: contentTypesUtils } = require('@strapi/utils');
-const { ApplicationError, ValidationError, NotFoundError, ForbiddenError } =
-  require('@strapi/utils').errors;
+const { ApplicationError, NotFoundError, ForbiddenError } = require('@strapi/utils').errors;
 const { validateCreateUserBody, validateUpdateUserBody } = require('./validation/user');
 
 const { UPDATED_BY_ATTRIBUTE, CREATED_BY_ATTRIBUTE } = contentTypesUtils.constants;
@@ -133,8 +132,8 @@ module.exports = {
 
     await validateUpdateUserBody(ctx.request.body);
 
-    if (_.has(body, 'password') && !password && user.provider === 'local') {
-      throw new ValidationError('password.notNull');
+    if (_.has(body, 'password') && (password == null || password === '')) {
+      delete body.password;
     }
 
     if (_.has(body, 'username')) {

package/server/controllers/validation/auth.js

@@ -14,6 +14,14 @@ const createRegisterSchema = (config) =>
     password: yup
       .string()
       .required()
+      .test(function (value) {
+        if (!value) return true;
+        const isValid = new TextEncoder().encode(value).length <= 72;
+        if (!isValid) {
+          return this.createError({ message: 'Password must be less than 73 bytes' });
+        }
+        return true;
+      })
       .test(async function (value) {
         if (typeof config?.validatePassword === 'function') {
           try {
@@ -49,6 +57,14 @@ const createResetPasswordSchema = (config) =>
       password: yup
         .string()
         .required()
+        .test(function (value) {
+          if (!value) return true;
+          const isValid = new TextEncoder().encode(value).length <= 72;
+          if (!isValid) {
+            return this.createError({ message: 'Password must be less than 73 bytes' });
+          }
+          return true;
+        })
         .test(async function (value) {
           if (typeof config?.validatePassword === 'function') {
             try {
@@ -62,7 +78,6 @@ const createResetPasswordSchema = (config) =>
           }
           return true;
         }),
-
       passwordConfirmation: yup
         .string()
         .required()
@@ -78,6 +93,14 @@ const createChangePasswordSchema = (config) =>
       password: yup
         .string()
         .required()
+        .test(function (value) {
+          if (!value) return true;
+          const isValid = new TextEncoder().encode(value).length <= 72;
+          if (!isValid) {
+            return this.createError({ message: 'Password must be less than 73 bytes' });
+          }
+          return true;
+        })
         .test(async function (value) {
           if (typeof config?.validatePassword === 'function') {
             try {

package/server/controllers/validation/user.js

@@ -29,7 +29,18 @@ const createUserBodySchema = yup.object().shape({
 const updateUserBodySchema = yup.object().shape({
   email: yup.string().email().min(1),
   username: yup.string().min(1),
-  password: yup.string().min(1),
+  password: yup
+    .mixed()
+    .test(
+      'password-validation',
+      'Password must be at least 1 character',
+      function validatePassword(value) {
+        if (value == null || value === '') {
+          return true;
+        }
+        return typeof value === 'string' && value.length >= 1;
+      }
+    ),
   role: yup.lazy((value) =>
     typeof value === 'object'
       ? yup.object().shape({

package/server/graphql/types/index.js

@@ -10,6 +10,7 @@ const typesFactories = [
   require('./create-role-payload'),
   require('./update-role-payload'),
   require('./delete-role-payload'),
+  require('./user-input'),
 ];
 
 /**

package/server/graphql/types/me.js

@@ -6,6 +6,7 @@ module.exports = ({ nexus }) => {
 
     definition(t) {
       t.nonNull.id('id');
+      t.nonNull.id('documentId');
       t.nonNull.string('username');
       t.string('email');
       t.boolean('confirmed');

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

@@ -0,0 +1,20 @@
+'use strict';
+
+const usersPermissionsUserUID = 'plugin::users-permissions.user';
+
+module.exports = ({ nexus, strapi }) => {
+  const { getContentTypeInputName } = strapi.plugin('graphql').service('utils').naming;
+
+  const userContentType = strapi.getModel(usersPermissionsUserUID);
+  const userInputName = getContentTypeInputName(userContentType);
+
+  return nexus.extendInputType({
+    type: userInputName,
+
+    definition(t) {
+      // Manually add the private password field back to the data
+      // input type as it is used for CRUD operations on users
+      t.string('password');
+    },
+  });
+};

package/server/register.js

@@ -15,7 +15,7 @@ module.exports = ({ strapi }) => {
   }
 
   if (strapi.plugin('documentation')) {
-    const specPath = path.join(__dirname, '../documentation/content-api.yaml');
+    const specPath = path.join(__dirname, '../../documentation/content-api.yaml');
     const spec = fs.readFileSync(specPath, 'utf8');
 
     strapi

package/server/routes/content-api/auth.js

@@ -1,82 +1,118 @@
 'use strict';
 
-module.exports = [
-  {
-    method: 'GET',
-    path: '/connect/(.*)',
-    handler: 'auth.connect',
-    config: {
-      middlewares: ['plugin::users-permissions.rateLimit'],
-      prefix: '',
+const { UsersPermissionsRouteValidator } = require('./validation');
+
+module.exports = (strapi) => {
+  const validator = new UsersPermissionsRouteValidator(strapi);
+
+  return [
+    {
+      method: 'GET',
+      path: '/connect/(.*)',
+      handler: 'auth.connect',
+      config: {
+        middlewares: ['plugin::users-permissions.rateLimit'],
+        prefix: '',
+      },
     },
-  },
-  {
-    method: 'POST',
-    path: '/auth/local',
-    handler: 'auth.callback',
-    config: {
-      middlewares: ['plugin::users-permissions.rateLimit'],
-      prefix: '',
+    {
+      method: 'POST',
+      path: '/auth/local',
+      handler: 'auth.callback',
+      config: {
+        middlewares: ['plugin::users-permissions.rateLimit'],
+        prefix: '',
+      },
+      request: {
+        body: { 'application/json': validator.loginBodySchema },
+      },
+      response: validator.authResponseSchema,
     },
-  },
-  {
-    method: 'POST',
-    path: '/auth/local/register',
-    handler: 'auth.register',
-    config: {
-      middlewares: ['plugin::users-permissions.rateLimit'],
-      prefix: '',
+    {
+      method: 'POST',
+      path: '/auth/local/register',
+      handler: 'auth.register',
+      config: {
+        middlewares: ['plugin::users-permissions.rateLimit'],
+        prefix: '',
+      },
+      request: {
+        body: { 'application/json': validator.registerBodySchema },
+      },
+      response: validator.authRegisterResponseSchema,
     },
-  },
-  {
-    method: 'GET',
-    path: '/auth/:provider/callback',
-    handler: 'auth.callback',
-    config: {
-      prefix: '',
+    {
+      method: 'GET',
+      path: '/auth/:provider/callback',
+      handler: 'auth.callback',
+      config: {
+        prefix: '',
+      },
+      request: {
+        params: {
+          provider: validator.providerParam,
+        },
+      },
+      response: validator.authResponseSchema,
     },
-  },
-  {
-    method: 'POST',
-    path: '/auth/forgot-password',
-    handler: 'auth.forgotPassword',
-    config: {
-      middlewares: ['plugin::users-permissions.rateLimit'],
-      prefix: '',
+    {
+      method: 'POST',
+      path: '/auth/forgot-password',
+      handler: 'auth.forgotPassword',
+      config: {
+        middlewares: ['plugin::users-permissions.rateLimit'],
+        prefix: '',
+      },
+      request: {
+        body: { 'application/json': validator.forgotPasswordBodySchema },
+      },
+      response: validator.forgotPasswordResponseSchema,
     },
-  },
-  {
-    method: 'POST',
-    path: '/auth/reset-password',
-    handler: 'auth.resetPassword',
-    config: {
-      middlewares: ['plugin::users-permissions.rateLimit'],
-      prefix: '',
+    {
+      method: 'POST',
+      path: '/auth/reset-password',
+      handler: 'auth.resetPassword',
+      config: {
+        middlewares: ['plugin::users-permissions.rateLimit'],
+        prefix: '',
+      },
+      request: {
+        body: { 'application/json': validator.resetPasswordBodySchema },
+      },
+      response: validator.authResponseSchema,
     },
-  },
-  {
-    method: 'GET',
-    path: '/auth/email-confirmation',
-    handler: 'auth.emailConfirmation',
-    config: {
-      prefix: '',
+    {
+      method: 'GET',
+      path: '/auth/email-confirmation',
+      handler: 'auth.emailConfirmation',
+      config: {
+        prefix: '',
+      },
     },
-  },
-  {
-    method: 'POST',
-    path: '/auth/send-email-confirmation',
-    handler: 'auth.sendEmailConfirmation',
-    config: {
-      prefix: '',
+    {
+      method: 'POST',
+      path: '/auth/send-email-confirmation',
+      handler: 'auth.sendEmailConfirmation',
+      config: {
+        prefix: '',
+      },
+      request: {
+        body: { 'application/json': validator.sendEmailConfirmationBodySchema },
+      },
+      response: validator.sendEmailConfirmationResponseSchema,
     },
-  },
-  {
-    method: 'POST',
-    path: '/auth/change-password',
-    handler: 'auth.changePassword',
-    config: {
-      middlewares: ['plugin::users-permissions.rateLimit'],
-      prefix: '',
+    {
+      method: 'POST',
+      path: '/auth/change-password',
+      handler: 'auth.changePassword',
+      config: {
+        middlewares: ['plugin::users-permissions.rateLimit'],
+        prefix: '',
+      },
+      request: {
+        body: { 'application/json': validator.changePasswordBodySchema },
+      },
+      response: validator.authResponseSchema,
     },
-  },
-];
+  ];
+};

package/server/routes/content-api/index.js

@@ -5,7 +5,14 @@ const userRoutes = require('./user');
 const roleRoutes = require('./role');
 const permissionsRoutes = require('./permissions');
 
-module.exports = {
-  type: 'content-api',
-  routes: [...authRoutes, ...userRoutes, ...roleRoutes, ...permissionsRoutes],
+module.exports = (strapi) => {
+  return {
+    type: 'content-api',
+    routes: [
+      ...authRoutes(strapi),
+      ...userRoutes(strapi),
+      ...roleRoutes(strapi),
+      ...permissionsRoutes(strapi),
+    ],
+  };
 };

package/server/routes/content-api/permissions.js

@@ -1,9 +1,16 @@
 'use strict';
 
-module.exports = [
-  {
-    method: 'GET',
-    path: '/permissions',
-    handler: 'permissions.getPermissions',
-  },
-];
+const { UsersPermissionsRouteValidator } = require('./validation');
+
+module.exports = (strapi) => {
+  const validator = new UsersPermissionsRouteValidator(strapi);
+
+  return [
+    {
+      method: 'GET',
+      path: '/permissions',
+      handler: 'permissions.getPermissions',
+      response: validator.permissionsResponseSchema,
+    },
+  ];
+};

package/server/routes/content-api/role.js

@@ -1,29 +1,59 @@
 'use strict';
 
-module.exports = [
-  {
-    method: 'GET',
-    path: '/roles/:id',
-    handler: 'role.findOne',
-  },
-  {
-    method: 'GET',
-    path: '/roles',
-    handler: 'role.find',
-  },
-  {
-    method: 'POST',
-    path: '/roles',
-    handler: 'role.createRole',
-  },
-  {
-    method: 'PUT',
-    path: '/roles/:role',
-    handler: 'role.updateRole',
-  },
-  {
-    method: 'DELETE',
-    path: '/roles/:role',
-    handler: 'role.deleteRole',
-  },
-];
+const { UsersPermissionsRouteValidator } = require('./validation');
+
+module.exports = (strapi) => {
+  const validator = new UsersPermissionsRouteValidator(strapi);
+
+  return [
+    {
+      method: 'GET',
+      path: '/roles/:id',
+      handler: 'role.findOne',
+      request: {
+        params: {
+          id: validator.roleIdParam,
+        },
+      },
+      response: validator.roleResponseSchema,
+    },
+    {
+      method: 'GET',
+      path: '/roles',
+      handler: 'role.find',
+      response: validator.rolesResponseSchema,
+    },
+    {
+      method: 'POST',
+      path: '/roles',
+      handler: 'role.createRole',
+      request: {
+        body: { 'application/json': validator.createRoleBodySchema },
+      },
+      response: validator.roleSuccessResponseSchema,
+    },
+    {
+      method: 'PUT',
+      path: '/roles/:role',
+      handler: 'role.updateRole',
+      request: {
+        params: {
+          role: validator.roleIdParam,
+        },
+        body: { 'application/json': validator.updateRoleBodySchema },
+      },
+      response: validator.roleSuccessResponseSchema,
+    },
+    {
+      method: 'DELETE',
+      path: '/roles/:role',
+      handler: 'role.deleteRole',
+      request: {
+        params: {
+          role: validator.roleIdParam,
+        },
+      },
+      response: validator.roleSuccessResponseSchema,
+    },
+  ];
+};

package/server/routes/content-api/user.js

@@ -1,60 +1,117 @@
 'use strict';
 
-module.exports = [
-  {
-    method: 'GET',
-    path: '/users/count',
-    handler: 'user.count',
-    config: {
-      prefix: '',
+const z = require('zod/v4');
+const { UsersPermissionsRouteValidator } = require('./validation');
+
+module.exports = (strapi) => {
+  const validator = new UsersPermissionsRouteValidator(strapi);
+
+  return [
+    {
+      method: 'GET',
+      path: '/users/count',
+      handler: 'user.count',
+      config: {
+        prefix: '',
+      },
+      request: {
+        query: {
+          filters: validator.filters.optional(),
+        },
+      },
+      response: z.number(),
     },
-  },
-  {
-    method: 'GET',
-    path: '/users',
-    handler: 'user.find',
-    config: {
-      prefix: '',
+    {
+      method: 'GET',
+      path: '/users',
+      handler: 'user.find',
+      config: {
+        prefix: '',
+      },
+      request: {
+        query: {
+          fields: validator.queryFields.optional(),
+          populate: validator.queryPopulate.optional(),
+          sort: validator.querySort.optional(),
+          pagination: validator.pagination.optional(),
+          filters: validator.filters.optional(),
+        },
+      },
+      response: z.array(validator.userSchema),
     },
-  },
-  {
-    method: 'GET',
-    path: '/users/me',
-    handler: 'user.me',
-    config: {
-      prefix: '',
+    {
+      method: 'GET',
+      path: '/users/me',
+      handler: 'user.me',
+      config: {
+        prefix: '',
+      },
+      request: {
+        query: {
+          fields: validator.queryFields.optional(),
+          populate: validator.queryPopulate.optional(),
+        },
+      },
+      response: validator.userSchema,
     },
-  },
-  {
-    method: 'GET',
-    path: '/users/:id',
-    handler: 'user.findOne',
-    config: {
-      prefix: '',
+    {
+      method: 'GET',
+      path: '/users/:id',
+      handler: 'user.findOne',
+      config: {
+        prefix: '',
+      },
+      request: {
+        params: {
+          id: validator.userIdParam,
+        },
+        query: {
+          fields: validator.queryFields.optional(),
+          populate: validator.queryPopulate.optional(),
+        },
+      },
+      response: validator.userSchema,
     },
-  },
-  {
-    method: 'POST',
-    path: '/users',
-    handler: 'user.create',
-    config: {
-      prefix: '',
+    {
+      method: 'POST',
+      path: '/users',
+      handler: 'user.create',
+      config: {
+        prefix: '',
+      },
+      request: {
+        body: { 'application/json': validator.createUserBodySchema },
+      },
+      response: validator.userSchema,
     },
-  },
-  {
-    method: 'PUT',
-    path: '/users/:id',
-    handler: 'user.update',
-    config: {
-      prefix: '',
+    {
+      method: 'PUT',
+      path: '/users/:id',
+      handler: 'user.update',
+      config: {
+        prefix: '',
+      },
+      request: {
+        params: {
+          id: validator.userIdParam,
+        },
+        body: { 'application/json': validator.updateUserBodySchema },
+      },
+      response: validator.userSchema,
     },
-  },
-  {
-    method: 'DELETE',
-    path: '/users/:id',
-    handler: 'user.destroy',
-    config: {
-      prefix: '',
+    {
+      method: 'DELETE',
+      path: '/users/:id',
+      handler: 'user.destroy',
+      config: {
+        prefix: '',
+      },
+      request: {
+        params: {
+          id: validator.userIdParam,
+        },
+      },
+      response: validator.userSchema,
     },
-  },
-];
+  ];
+};