@strapi/plugin-users-permissions 0.0.0-experimental.62ebf57bb35846666febb5ee2078fe02fe990f57 → 0.0.0-experimental.6340da17068c3bed7fb006e7bcc554c71129e282

package/dist/server/controllers/auth.js

@@ -0,0 +1,658 @@
+'use strict';
+
+var require$$0$2 = require('crypto');
+var require$$0$1 = require('lodash');
+var require$$0 = require('lodash/fp');
+var require$$1 = require('@strapi/utils');
+var index = require('../utils/index.js');
+var refreshCookieOptions = require('../utils/refresh-cookie-options.js');
+var auth$1 = require('./validation/auth.js');
+var require$$7 = require('grant');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var require$$0__default$2 = /*#__PURE__*/_interopDefault(require$$0$2);
+var require$$0__default$1 = /*#__PURE__*/_interopDefault(require$$0$1);
+var require$$0__default = /*#__PURE__*/_interopDefault(require$$0);
+var require$$1__default = /*#__PURE__*/_interopDefault(require$$1);
+var require$$7__default = /*#__PURE__*/_interopDefault(require$$7);
+
+var auth;
+var hasRequiredAuth;
+function requireAuth() {
+    if (hasRequiredAuth) return auth;
+    hasRequiredAuth = 1;
+    /**
+	 * Auth.js controller
+	 *
+	 * @description: A set of functions called "actions" for managing `Auth`.
+	 */ /* eslint-disable no-useless-escape */ const crypto = require$$0__default$2.default;
+    const _ = require$$0__default$1.default;
+    const { concat, compact, isArray } = require$$0__default.default;
+    const utils = require$$1__default.default;
+    const { getService } = index.__require();
+    const { buildRefreshCookieOptions } = refreshCookieOptions.__require();
+    const { validateCallbackBody, validateRegisterBody, validateSendEmailConfirmationBody, validateForgotPasswordBody, validateResetPasswordBody, validateEmailConfirmationBody, validateChangePasswordBody } = auth$1.__require();
+    const { ApplicationError, ValidationError, ForbiddenError } = utils.errors;
+    const { buildSessionMetadata, sanitizeSessionEntry, sortSessionsForDisplay } = utils;
+    const sanitizeUser = (user, ctx)=>{
+        const { auth } = ctx.state;
+        const userSchema = strapi.getModel('plugin::users-permissions.user');
+        return strapi.contentAPI.sanitize.output(user, userSchema, {
+            auth
+        });
+    };
+    const extractDeviceId = (requestBody)=>{
+        const { deviceId } = requestBody || {};
+        return typeof deviceId === 'string' && deviceId.length > 0 ? deviceId : undefined;
+    };
+    const buildSessionMetadataFromContext = (ctx)=>buildSessionMetadata({
+            ip: ctx.request.ip,
+            userAgent: ctx.request.headers['user-agent']
+        });
+    const sendRefreshAuthResponse = async (strapi1, ctx, user, { metadata } = {})=>{
+        const deviceId = extractDeviceId(ctx.request.body);
+        const tokenOptions = {
+            type: 'refresh',
+            ...metadata ? {
+                metadata
+            } : {}
+        };
+        const refresh = await strapi1.sessionManager('users-permissions').generateRefreshToken(String(user.id), deviceId, tokenOptions);
+        const access = await strapi1.sessionManager('users-permissions').generateAccessToken(refresh.token);
+        if ('error' in access) {
+            throw new ApplicationError('Invalid credentials');
+        }
+        const upSessions = strapi1.config.get('plugin::users-permissions.sessions');
+        const requestHttpOnly = ctx.request.header['x-strapi-refresh-cookie'] === 'httpOnly';
+        if (upSessions?.httpOnly || requestHttpOnly) {
+            const cookieName = upSessions.cookie?.name || 'strapi_up_refresh';
+            const isProduction = process.env.NODE_ENV === 'production';
+            ctx.cookies.set(cookieName, refresh.token, buildRefreshCookieOptions(upSessions, isProduction));
+            return ctx.send({
+                jwt: access.token,
+                user: await sanitizeUser(user, ctx)
+            });
+        }
+        return ctx.send({
+            jwt: access.token,
+            refreshToken: refresh.token,
+            user: await sanitizeUser(user, ctx)
+        });
+    };
+    const reissueTokensAfterPasswordChange = async (strapi1, ctx, user)=>{
+        const deviceId = extractDeviceId(ctx.request.body);
+        await strapi1.sessionManager('users-permissions').invalidateRefreshToken(String(user.id));
+        const newDeviceId = deviceId || crypto.randomUUID();
+        const refresh = await strapi1.sessionManager('users-permissions').generateRefreshToken(String(user.id), newDeviceId, {
+            type: 'refresh'
+        });
+        const access = await strapi1.sessionManager('users-permissions').generateAccessToken(refresh.token);
+        if ('error' in access) {
+            throw new ApplicationError('Invalid credentials');
+        }
+        return ctx.send({
+            jwt: access.token,
+            refreshToken: refresh.token,
+            user: await sanitizeUser(user, ctx)
+        });
+    };
+    const revokeLogoutSessions = async (strapi1, ctx, userId, { scope, deviceId, body })=>{
+        const sessionManager = strapi1.sessionManager('users-permissions');
+        const upSessions = strapi1.config.get('plugin::users-permissions.sessions');
+        if (scope === 'all') {
+            await sessionManager.invalidateRefreshToken(userId);
+            return;
+        }
+        if (deviceId) {
+            await sessionManager.invalidateRefreshToken(userId, deviceId);
+            return;
+        }
+        let currentSessionId = ctx.state.session?.id;
+        const cookieName = upSessions?.cookie?.name || 'strapi_up_refresh';
+        const refreshToken = ctx.cookies.get(cookieName) || (typeof body.refreshToken === 'string' ? body.refreshToken : undefined);
+        if (refreshToken) {
+            const validation = await sessionManager.validateRefreshToken(refreshToken);
+            if (validation.isValid) {
+                currentSessionId = validation.sessionId;
+            }
+        }
+        if (currentSessionId) {
+            await sessionManager.revokeSessionById(userId, currentSessionId);
+            return;
+        }
+        await sessionManager.invalidateRefreshToken(userId);
+    };
+    auth = ({ strapi: strapi1 })=>({
+            async callback (ctx) {
+                const provider = ctx.params.provider || 'local';
+                const params = ctx.request.body;
+                const store = strapi1.store({
+                    type: 'plugin',
+                    name: 'users-permissions'
+                });
+                const grantSettings = await store.get({
+                    key: 'grant'
+                });
+                const grantProvider = provider === 'local' ? 'email' : provider;
+                if (!_.get(grantSettings, [
+                    grantProvider,
+                    'enabled'
+                ])) {
+                    throw new ApplicationError('This provider is disabled');
+                }
+                if (provider === 'local') {
+                    await validateCallbackBody(params);
+                    const { identifier } = params;
+                    // Check if the user exists.
+                    const user = await strapi1.db.query('plugin::users-permissions.user').findOne({
+                        where: {
+                            provider,
+                            $or: [
+                                {
+                                    email: identifier.toLowerCase()
+                                },
+                                {
+                                    username: identifier
+                                }
+                            ]
+                        }
+                    });
+                    if (!user) {
+                        throw new ValidationError('Invalid identifier or password');
+                    }
+                    if (!user.password) {
+                        throw new ValidationError('Invalid identifier or password');
+                    }
+                    const validPassword = await getService('user').validatePassword(params.password, user.password);
+                    if (!validPassword) {
+                        throw new ValidationError('Invalid identifier or password');
+                    }
+                    const advancedSettings = await store.get({
+                        key: 'advanced'
+                    });
+                    const requiresConfirmation = _.get(advancedSettings, 'email_confirmation');
+                    if (requiresConfirmation && user.confirmed !== true) {
+                        throw new ApplicationError('Your account email is not confirmed');
+                    }
+                    if (user.blocked === true) {
+                        throw new ApplicationError('Your account has been blocked by an administrator');
+                    }
+                    const mode = strapi1.config.get('plugin::users-permissions.jwtManagement', 'legacy-support');
+                    if (mode === 'refresh') {
+                        return sendRefreshAuthResponse(strapi1, ctx, user, {
+                            metadata: buildSessionMetadataFromContext(ctx)
+                        });
+                    }
+                    return ctx.send({
+                        jwt: getService('jwt').issue({
+                            id: user.id
+                        }),
+                        user: await sanitizeUser(user, ctx)
+                    });
+                }
+                // Connect the user with the third-party provider.
+                try {
+                    const user = await getService('providers').connect(provider, ctx.query);
+                    if (user.blocked) {
+                        throw new ForbiddenError('Your account has been blocked by an administrator');
+                    }
+                    const mode = strapi1.config.get('plugin::users-permissions.jwtManagement', 'legacy-support');
+                    if (mode === 'refresh') {
+                        return sendRefreshAuthResponse(strapi1, ctx, user, {
+                            metadata: buildSessionMetadataFromContext(ctx)
+                        });
+                    }
+                    return ctx.send({
+                        jwt: getService('jwt').issue({
+                            id: user.id
+                        }),
+                        user: await sanitizeUser(user, ctx)
+                    });
+                } catch (error) {
+                    throw new ApplicationError(error.message);
+                }
+            },
+            async changePassword (ctx) {
+                if (!ctx.state.user) {
+                    throw new ApplicationError('You must be authenticated to reset your password');
+                }
+                const validations = strapi1.config.get('plugin::users-permissions.validationRules');
+                const { currentPassword, password } = await validateChangePasswordBody(ctx.request.body, validations);
+                const user = await strapi1.db.query('plugin::users-permissions.user').findOne({
+                    where: {
+                        id: ctx.state.user.id
+                    }
+                });
+                const validPassword = await getService('user').validatePassword(currentPassword, user.password);
+                if (!validPassword) {
+                    throw new ValidationError('The provided current password is invalid');
+                }
+                if (currentPassword === password) {
+                    throw new ValidationError('Your new password must be different than your current password');
+                }
+                await getService('user').edit(user.id, {
+                    password
+                });
+                const mode = strapi1.config.get('plugin::users-permissions.jwtManagement', 'legacy-support');
+                if (mode === 'refresh') {
+                    return reissueTokensAfterPasswordChange(strapi1, ctx, user);
+                }
+                return ctx.send({
+                    jwt: getService('jwt').issue({
+                        id: user.id
+                    }),
+                    user: await sanitizeUser(user, ctx)
+                });
+            },
+            async resetPassword (ctx) {
+                const validations = strapi1.config.get('plugin::users-permissions.validationRules');
+                const { password, passwordConfirmation, code } = await validateResetPasswordBody(ctx.request.body, validations);
+                if (password !== passwordConfirmation) {
+                    throw new ValidationError('Passwords do not match');
+                }
+                const user = await strapi1.db.query('plugin::users-permissions.user').findOne({
+                    where: {
+                        resetPasswordToken: code
+                    }
+                });
+                if (!user) {
+                    throw new ValidationError('Incorrect code provided');
+                }
+                await getService('user').edit(user.id, {
+                    resetPasswordToken: null,
+                    password
+                });
+                const mode = strapi1.config.get('plugin::users-permissions.jwtManagement', 'legacy-support');
+                if (mode === 'refresh') {
+                    return reissueTokensAfterPasswordChange(strapi1, ctx, user);
+                }
+                return ctx.send({
+                    jwt: getService('jwt').issue({
+                        id: user.id
+                    }),
+                    user: await sanitizeUser(user, ctx)
+                });
+            },
+            async refresh (ctx) {
+                const mode = strapi1.config.get('plugin::users-permissions.jwtManagement', 'legacy-support');
+                if (mode !== 'refresh') {
+                    return ctx.notFound();
+                }
+                const upSessions = strapi1.config.get('plugin::users-permissions.sessions');
+                const cookieName = upSessions?.cookie?.name || 'strapi_up_refresh';
+                // Check for refresh token in cookie first (if httpOnly is configured), then in body
+                let refreshToken = ctx.cookies.get(cookieName);
+                if (!refreshToken) {
+                    refreshToken = ctx.request.body?.refreshToken;
+                }
+                if (!refreshToken || typeof refreshToken !== 'string') {
+                    return ctx.badRequest('Missing refresh token');
+                }
+                const rotation = await strapi1.sessionManager('users-permissions').rotateRefreshToken(refreshToken);
+                if ('error' in rotation) {
+                    return ctx.unauthorized('Invalid refresh token');
+                }
+                const result = await strapi1.sessionManager('users-permissions').generateAccessToken(rotation.token);
+                if ('error' in result) {
+                    return ctx.unauthorized('Invalid refresh token');
+                }
+                const requestHttpOnly = ctx.request.header['x-strapi-refresh-cookie'] === 'httpOnly';
+                if (upSessions?.httpOnly || requestHttpOnly) {
+                    const isProduction = process.env.NODE_ENV === 'production';
+                    ctx.cookies.set(cookieName, rotation.token, buildRefreshCookieOptions(upSessions, isProduction));
+                    return ctx.send({
+                        jwt: result.token
+                    });
+                }
+                return ctx.send({
+                    jwt: result.token,
+                    refreshToken: rotation.token
+                });
+            },
+            async logout (ctx) {
+                const mode = strapi1.config.get('plugin::users-permissions.jwtManagement', 'legacy-support');
+                if (mode !== 'refresh') {
+                    return ctx.notFound();
+                }
+                if (!ctx.state.user) {
+                    return ctx.unauthorized('Missing authentication');
+                }
+                const userId = String(ctx.state.user.id);
+                const upSessions = strapi1.config.get('plugin::users-permissions.sessions');
+                const body = ctx.request.body || {};
+                const scope = typeof body.scope === 'string' ? body.scope : undefined;
+                const deviceId = extractDeviceId(body);
+                try {
+                    await revokeLogoutSessions(strapi1, ctx, userId, {
+                        scope,
+                        deviceId,
+                        body
+                    });
+                } catch (err) {
+                    strapi1.log.error('UP logout failed', err);
+                }
+                const requestHttpOnly = ctx.request.header['x-strapi-refresh-cookie'] === 'httpOnly';
+                if (upSessions?.httpOnly || requestHttpOnly) {
+                    const cookieName = upSessions.cookie?.name || 'strapi_up_refresh';
+                    ctx.cookies.set(cookieName, '', {
+                        expires: new Date(0)
+                    });
+                }
+                return ctx.send({
+                    ok: true
+                });
+            },
+            async getSessions (ctx) {
+                const mode = strapi1.config.get('plugin::users-permissions.jwtManagement', 'legacy-support');
+                if (mode !== 'refresh') {
+                    return ctx.notFound();
+                }
+                if (!ctx.state.user) {
+                    return ctx.unauthorized('Missing authentication');
+                }
+                const currentSessionId = ctx.state.session?.id;
+                const sessions = await strapi1.sessionManager('users-permissions').listSessions(String(ctx.state.user.id));
+                const data = sortSessionsForDisplay(sessions.map((session)=>sanitizeSessionEntry(session, currentSessionId)));
+                return ctx.send({
+                    data
+                });
+            },
+            async revokeSession (ctx) {
+                const mode = strapi1.config.get('plugin::users-permissions.jwtManagement', 'legacy-support');
+                if (mode !== 'refresh') {
+                    return ctx.notFound();
+                }
+                if (!ctx.state.user) {
+                    return ctx.unauthorized('Missing authentication');
+                }
+                const { sessionId } = ctx.params;
+                const revoked = await strapi1.sessionManager('users-permissions').revokeSessionById(String(ctx.state.user.id), sessionId);
+                if (!revoked) {
+                    return ctx.notFound('Session not found');
+                }
+                return ctx.send({
+                    data: {}
+                });
+            },
+            async connect (ctx, next) {
+                const grant = require$$7__default.default.koa();
+                const providers = await strapi1.store({
+                    type: 'plugin',
+                    name: 'users-permissions',
+                    key: 'grant'
+                }).get();
+                const apiPrefix = strapi1.config.get('api.rest.prefix');
+                const grantConfig = {
+                    defaults: {
+                        prefix: `${apiPrefix}/connect`
+                    },
+                    ...providers
+                };
+                const [requestPath] = ctx.request.url.split('?');
+                const provider = requestPath.split('/connect/')[1].split('/')[0];
+                if (!_.get(grantConfig[provider], 'enabled')) {
+                    throw new ApplicationError('This provider is disabled');
+                }
+                if (!strapi1.config.server.url.startsWith('http')) {
+                    strapi1.log.warn('You are using a third party provider for login. Make sure to set an absolute url in config/server.js. More info here: https://docs.strapi.io/developer-docs/latest/plugins/users-permissions.html#setting-up-the-server-url');
+                }
+                // Ability to pass OAuth callback dynamically
+                const queryCustomCallback = _.get(ctx, 'query.callback');
+                const dynamicSessionCallback = _.get(ctx, 'session.grant.dynamic.callback');
+                const customCallback = queryCustomCallback ?? dynamicSessionCallback;
+                // The custom callback is validated to make sure it's not redirecting to an unwanted actor.
+                if (customCallback !== undefined) {
+                    try {
+                        // We're extracting the callback validator from the plugin config since it can be user-customized
+                        const { validate: validateCallback } = strapi1.plugin('users-permissions').config('callback');
+                        await validateCallback(customCallback, grantConfig[provider]);
+                        grantConfig[provider].callback = customCallback;
+                    } catch (e) {
+                        throw new ValidationError('Invalid callback URL provided', {
+                            callback: customCallback
+                        });
+                    }
+                }
+                // Build a valid redirect URI for the current provider
+                grantConfig[provider].redirect_uri = getService('providers').buildRedirectUri(provider);
+                return grant(grantConfig)(ctx, next);
+            },
+            async forgotPassword (ctx) {
+                const { email } = await validateForgotPasswordBody(ctx.request.body);
+                const pluginStore = await strapi1.store({
+                    type: 'plugin',
+                    name: 'users-permissions'
+                });
+                const emailSettings = await pluginStore.get({
+                    key: 'email'
+                });
+                const advancedSettings = await pluginStore.get({
+                    key: 'advanced'
+                });
+                // Find the user by email.
+                const user = await strapi1.db.query('plugin::users-permissions.user').findOne({
+                    where: {
+                        email: email.toLowerCase()
+                    }
+                });
+                if (!user || user.blocked) {
+                    return ctx.send({
+                        ok: true
+                    });
+                }
+                // Generate random token.
+                const userInfo = await sanitizeUser(user, ctx);
+                const resetPasswordToken = crypto.randomBytes(64).toString('hex');
+                const resetPasswordSettings = _.get(emailSettings, 'reset_password.options', {});
+                const emailBody = await getService('users-permissions').template(resetPasswordSettings.message, {
+                    URL: advancedSettings.email_reset_password,
+                    SERVER_URL: strapi1.config.get('server.absoluteUrl'),
+                    ADMIN_URL: strapi1.config.get('admin.absoluteUrl'),
+                    USER: userInfo,
+                    TOKEN: resetPasswordToken
+                });
+                const emailObject = await getService('users-permissions').template(resetPasswordSettings.object, {
+                    USER: userInfo
+                });
+                const emailToSend = {
+                    to: user.email,
+                    from: resetPasswordSettings.from.email || resetPasswordSettings.from.name ? `${resetPasswordSettings.from.name} <${resetPasswordSettings.from.email}>` : undefined,
+                    replyTo: resetPasswordSettings.response_email,
+                    subject: emailObject,
+                    text: emailBody,
+                    html: emailBody
+                };
+                // NOTE: Update the user before sending the email so an Admin can generate the link if the email fails
+                await getService('user').edit(user.id, {
+                    resetPasswordToken
+                });
+                // Send an email to the user.
+                await strapi1.plugin('email').service('email').send(emailToSend);
+                ctx.send({
+                    ok: true
+                });
+            },
+            async register (ctx) {
+                const pluginStore = await strapi1.store({
+                    type: 'plugin',
+                    name: 'users-permissions'
+                });
+                const settings = await pluginStore.get({
+                    key: 'advanced'
+                });
+                if (!settings.allow_register) {
+                    throw new ApplicationError('Register action is currently disabled');
+                }
+                const { register } = strapi1.config.get('plugin::users-permissions');
+                const alwaysAllowedKeys = [
+                    'username',
+                    'password',
+                    'email'
+                ];
+                // Note that we intentionally do not filter allowedFields to allow a project to explicitly accept private or other Strapi field on registration
+                const allowedKeys = compact(concat(alwaysAllowedKeys, isArray(register?.allowedFields) ? register.allowedFields : []));
+                // Check if there are any keys in requestBody that are not in allowedKeys
+                const invalidKeys = Object.keys(ctx.request.body).filter((key)=>!allowedKeys.includes(key));
+                if (invalidKeys.length > 0) {
+                    // If there are invalid keys, throw an error
+                    throw new ValidationError(`Invalid parameters: ${invalidKeys.join(', ')}`);
+                }
+                const params = {
+                    ..._.pick(ctx.request.body, allowedKeys),
+                    provider: 'local'
+                };
+                const validations = strapi1.config.get('plugin::users-permissions.validationRules');
+                await validateRegisterBody(params, validations);
+                const role = await strapi1.db.query('plugin::users-permissions.role').findOne({
+                    where: {
+                        type: settings.default_role
+                    }
+                });
+                if (!role) {
+                    throw new ApplicationError('Impossible to find the default role');
+                }
+                const { email, username, provider } = params;
+                const identifierFilter = {
+                    $or: [
+                        {
+                            email: email.toLowerCase()
+                        },
+                        {
+                            username: email.toLowerCase()
+                        },
+                        {
+                            username
+                        },
+                        {
+                            email: username
+                        }
+                    ]
+                };
+                const conflictingUserCount = await strapi1.db.query('plugin::users-permissions.user').count({
+                    where: {
+                        ...identifierFilter,
+                        provider
+                    }
+                });
+                if (conflictingUserCount > 0) {
+                    throw new ApplicationError('Email or Username are already taken');
+                }
+                if (settings.unique_email) {
+                    const conflictingUserCount = await strapi1.db.query('plugin::users-permissions.user').count({
+                        where: {
+                            ...identifierFilter
+                        }
+                    });
+                    if (conflictingUserCount > 0) {
+                        throw new ApplicationError('Email or Username are already taken');
+                    }
+                }
+                const newUser = {
+                    ...params,
+                    role: role.id,
+                    email: email.toLowerCase(),
+                    username,
+                    confirmed: !settings.email_confirmation
+                };
+                const user = await getService('user').add(newUser);
+                const sanitizedUser = await sanitizeUser(user, ctx);
+                if (settings.email_confirmation) {
+                    try {
+                        await getService('user').sendConfirmationEmail(sanitizedUser);
+                    } catch (err) {
+                        strapi1.log.error(err);
+                        throw new ApplicationError('Error sending confirmation email');
+                    }
+                    return ctx.send({
+                        user: sanitizedUser
+                    });
+                }
+                const mode = strapi1.config.get('plugin::users-permissions.jwtManagement', 'legacy-support');
+                if (mode === 'refresh') {
+                    const deviceId = extractDeviceId(ctx.request.body) || crypto.randomUUID();
+                    const refresh = await strapi1.sessionManager('users-permissions').generateRefreshToken(String(user.id), deviceId, {
+                        type: 'refresh',
+                        metadata: buildSessionMetadataFromContext(ctx)
+                    });
+                    const access = await strapi1.sessionManager('users-permissions').generateAccessToken(refresh.token);
+                    if ('error' in access) {
+                        throw new ApplicationError('Invalid credentials');
+                    }
+                    return ctx.send({
+                        jwt: access.token,
+                        refreshToken: refresh.token,
+                        user: sanitizedUser
+                    });
+                }
+                const jwt = getService('jwt').issue(_.pick(user, [
+                    'id'
+                ]));
+                return ctx.send({
+                    jwt,
+                    user: sanitizedUser
+                });
+            },
+            async emailConfirmation (ctx, next, returnUser) {
+                const { confirmation: confirmationToken } = await validateEmailConfirmationBody(ctx.query);
+                const userService = getService('user');
+                const jwtService = getService('jwt');
+                const [user] = await userService.fetchAll({
+                    filters: {
+                        confirmationToken
+                    }
+                });
+                if (!user) {
+                    throw new ValidationError('Invalid token');
+                }
+                await userService.edit(user.id, {
+                    confirmed: true,
+                    confirmationToken: null
+                });
+                if (returnUser) {
+                    ctx.send({
+                        jwt: jwtService.issue({
+                            id: user.id
+                        }),
+                        user: await sanitizeUser(user, ctx)
+                    });
+                } else {
+                    const settings = await strapi1.store({
+                        type: 'plugin',
+                        name: 'users-permissions',
+                        key: 'advanced'
+                    }).get();
+                    ctx.redirect(settings.email_confirmation_redirection || '/');
+                }
+            },
+            async sendEmailConfirmation (ctx) {
+                const { email } = await validateSendEmailConfirmationBody(ctx.request.body);
+                const user = await strapi1.db.query('plugin::users-permissions.user').findOne({
+                    where: {
+                        email: email.toLowerCase()
+                    }
+                });
+                if (!user) {
+                    return ctx.send({
+                        email,
+                        sent: true
+                    });
+                }
+                if (user.confirmed) {
+                    throw new ApplicationError('Already confirmed');
+                }
+                if (user.blocked) {
+                    throw new ApplicationError('User blocked');
+                }
+                await getService('user').sendConfirmationEmail(user);
+                ctx.send({
+                    email: user.email,
+                    sent: true
+                });
+            }
+        });
+    return auth;
+}
+
+exports.__require = requireAuth;
+//# sourceMappingURL=auth.js.map