@strapi/plugin-users-permissions 0.0.0-next.cc6c39db185a337e2eafce8bcf06544351e92cc5 → 0.0.0-next.cca0790e58ec5d8f2f5ab275d475a147c679214e

package/dist/server/content-types/user/index.js

@@ -0,0 +1,84 @@
+'use strict';
+
+var schemaConfig = require('./schema-config.js');
+
+var user;
+var hasRequiredUser;
+function requireUser() {
+    if (hasRequiredUser) return user;
+    hasRequiredUser = 1;
+    const schemaConfig$1 = schemaConfig.__require();
+    user = {
+        collectionName: 'up_users',
+        info: {
+            name: 'user',
+            description: '',
+            singularName: 'user',
+            pluralName: 'users',
+            displayName: 'User'
+        },
+        options: {
+            timestamps: true
+        },
+        attributes: {
+            username: {
+                type: 'string',
+                minLength: 3,
+                unique: true,
+                configurable: false,
+                required: true
+            },
+            email: {
+                type: 'email',
+                minLength: 6,
+                configurable: false,
+                required: true
+            },
+            provider: {
+                type: 'string',
+                configurable: false
+            },
+            password: {
+                type: 'password',
+                minLength: 6,
+                configurable: false,
+                private: true,
+                searchable: false
+            },
+            resetPasswordToken: {
+                type: 'string',
+                configurable: false,
+                private: true,
+                searchable: false
+            },
+            confirmationToken: {
+                type: 'string',
+                configurable: false,
+                private: true,
+                searchable: false
+            },
+            confirmed: {
+                type: 'boolean',
+                default: false,
+                configurable: false
+            },
+            blocked: {
+                type: 'boolean',
+                default: false,
+                configurable: false
+            },
+            role: {
+                type: 'relation',
+                relation: 'manyToOne',
+                target: 'plugin::users-permissions.role',
+                inversedBy: 'users',
+                configurable: false
+            }
+        },
+        config: schemaConfig$1
+    };
+    return user;
+}
+
+exports.__require = requireUser;
+//# sourceMappingURL=index.js.map

package/dist/server/content-types/user/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../server/content-types/user/index.js"],"sourcesContent":["'use strict';\n\nconst schemaConfig = require('./schema-config');\n\nmodule.exports = {\n  collectionName: 'up_users',\n  info: {\n    name: 'user',\n    description: '',\n    singularName: 'user',\n    pluralName: 'users',\n    displayName: 'User',\n  },\n  options: {\n    timestamps: true,\n  },\n  attributes: {\n    username: {\n      type: 'string',\n      minLength: 3,\n      unique: true,\n      configurable: false,\n      required: true,\n    },\n    email: {\n      type: 'email',\n      minLength: 6,\n      configurable: false,\n      required: true,\n    },\n    provider: {\n      type: 'string',\n      configurable: false,\n    },\n    password: {\n      type: 'password',\n      minLength: 6,\n      configurable: false,\n      private: true,\n      searchable: false,\n    },\n    resetPasswordToken: {\n      type: 'string',\n      configurable: false,\n      private: true,\n      searchable: false,\n    },\n    confirmationToken: {\n      type: 'string',\n      configurable: false,\n      private: true,\n      searchable: false,\n    },\n    confirmed: {\n      type: 'boolean',\n      default: false,\n      configurable: false,\n    },\n    blocked: {\n      type: 'boolean',\n      default: false,\n      configurable: false,\n    },\n    role: {\n      type: 'relation',\n      relation: 'manyToOne',\n      target: 'plugin::users-permissions.role',\n      inversedBy: 'users',\n      configurable: false,\n    },\n  },\n\n  config: schemaConfig, // TODO: to move to content-manager options\n};\n"],"names":["schemaConfig","require$$0","user","collectionName","info","name","description","singularName","pluralName","displayName","options","timestamps","attributes","username","type","minLength","unique","configurable","required","email","provider","password","private","searchable","resetPasswordToken","confirmationToken","confirmed","default","blocked","role","relation","target","inversedBy","config"],"mappings":";;;;;;;;;AAEA,IAAA,MAAMA,cAAeC,GAAAA,sBAAAA,EAAAA;IAErBC,IAAiB,GAAA;QACfC,cAAgB,EAAA,UAAA;QAChBC,IAAM,EAAA;YACJC,IAAM,EAAA,MAAA;YACNC,WAAa,EAAA,EAAA;YACbC,YAAc,EAAA,MAAA;YACdC,UAAY,EAAA,OAAA;YACZC,WAAa,EAAA;AACd,SAAA;QACDC,OAAS,EAAA;YACPC,UAAY,EAAA;AACb,SAAA;QACDC,UAAY,EAAA;YACVC,QAAU,EAAA;gBACRC,IAAM,EAAA,QAAA;gBACNC,SAAW,EAAA,CAAA;gBACXC,MAAQ,EAAA,IAAA;gBACRC,YAAc,EAAA,KAAA;gBACdC,QAAU,EAAA;AACX,aAAA;YACDC,KAAO,EAAA;gBACLL,IAAM,EAAA,OAAA;gBACNC,SAAW,EAAA,CAAA;gBACXE,YAAc,EAAA,KAAA;gBACdC,QAAU,EAAA;AACX,aAAA;YACDE,QAAU,EAAA;gBACRN,IAAM,EAAA,QAAA;gBACNG,YAAc,EAAA;AACf,aAAA;YACDI,QAAU,EAAA;gBACRP,IAAM,EAAA,UAAA;gBACNC,SAAW,EAAA,CAAA;gBACXE,YAAc,EAAA,KAAA;gBACdK,OAAS,EAAA,IAAA;gBACTC,UAAY,EAAA;AACb,aAAA;YACDC,kBAAoB,EAAA;gBAClBV,IAAM,EAAA,QAAA;gBACNG,YAAc,EAAA,KAAA;gBACdK,OAAS,EAAA,IAAA;gBACTC,UAAY,EAAA;AACb,aAAA;YACDE,iBAAmB,EAAA;gBACjBX,IAAM,EAAA,QAAA;gBACNG,YAAc,EAAA,KAAA;gBACdK,OAAS,EAAA,IAAA;gBACTC,UAAY,EAAA;AACb,aAAA;YACDG,SAAW,EAAA;gBACTZ,IAAM,EAAA,SAAA;gBACNa,OAAS,EAAA,KAAA;gBACTV,YAAc,EAAA;AACf,aAAA;YACDW,OAAS,EAAA;gBACPd,IAAM,EAAA,SAAA;gBACNa,OAAS,EAAA,KAAA;gBACTV,YAAc,EAAA;AACf,aAAA;YACDY,IAAM,EAAA;gBACJf,IAAM,EAAA,UAAA;gBACNgB,QAAU,EAAA,WAAA;gBACVC,MAAQ,EAAA,gCAAA;gBACRC,UAAY,EAAA,OAAA;gBACZf,YAAc,EAAA;AACf;AACF,SAAA;QAEDgB,MAAQjC,EAAAA;AACV,KAAA;;;;;;"}

package/dist/server/content-types/user/index.mjs

@@ -0,0 +1,82 @@
+import { __require as requireSchemaConfig } from './schema-config.mjs';
+
+var user;
+var hasRequiredUser;
+function requireUser() {
+    if (hasRequiredUser) return user;
+    hasRequiredUser = 1;
+    const schemaConfig = requireSchemaConfig();
+    user = {
+        collectionName: 'up_users',
+        info: {
+            name: 'user',
+            description: '',
+            singularName: 'user',
+            pluralName: 'users',
+            displayName: 'User'
+        },
+        options: {
+            timestamps: true
+        },
+        attributes: {
+            username: {
+                type: 'string',
+                minLength: 3,
+                unique: true,
+                configurable: false,
+                required: true
+            },
+            email: {
+                type: 'email',
+                minLength: 6,
+                configurable: false,
+                required: true
+            },
+            provider: {
+                type: 'string',
+                configurable: false
+            },
+            password: {
+                type: 'password',
+                minLength: 6,
+                configurable: false,
+                private: true,
+                searchable: false
+            },
+            resetPasswordToken: {
+                type: 'string',
+                configurable: false,
+                private: true,
+                searchable: false
+            },
+            confirmationToken: {
+                type: 'string',
+                configurable: false,
+                private: true,
+                searchable: false
+            },
+            confirmed: {
+                type: 'boolean',
+                default: false,
+                configurable: false
+            },
+            blocked: {
+                type: 'boolean',
+                default: false,
+                configurable: false
+            },
+            role: {
+                type: 'relation',
+                relation: 'manyToOne',
+                target: 'plugin::users-permissions.role',
+                inversedBy: 'users',
+                configurable: false
+            }
+        },
+        config: schemaConfig
+    };
+    return user;
+}
+
+export { requireUser as __require };
+//# sourceMappingURL=index.mjs.map

package/dist/server/content-types/user/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../../../../server/content-types/user/index.js"],"sourcesContent":["'use strict';\n\nconst schemaConfig = require('./schema-config');\n\nmodule.exports = {\n  collectionName: 'up_users',\n  info: {\n    name: 'user',\n    description: '',\n    singularName: 'user',\n    pluralName: 'users',\n    displayName: 'User',\n  },\n  options: {\n    timestamps: true,\n  },\n  attributes: {\n    username: {\n      type: 'string',\n      minLength: 3,\n      unique: true,\n      configurable: false,\n      required: true,\n    },\n    email: {\n      type: 'email',\n      minLength: 6,\n      configurable: false,\n      required: true,\n    },\n    provider: {\n      type: 'string',\n      configurable: false,\n    },\n    password: {\n      type: 'password',\n      minLength: 6,\n      configurable: false,\n      private: true,\n      searchable: false,\n    },\n    resetPasswordToken: {\n      type: 'string',\n      configurable: false,\n      private: true,\n      searchable: false,\n    },\n    confirmationToken: {\n      type: 'string',\n      configurable: false,\n      private: true,\n      searchable: false,\n    },\n    confirmed: {\n      type: 'boolean',\n      default: false,\n      configurable: false,\n    },\n    blocked: {\n      type: 'boolean',\n      default: false,\n      configurable: false,\n    },\n    role: {\n      type: 'relation',\n      relation: 'manyToOne',\n      target: 'plugin::users-permissions.role',\n      inversedBy: 'users',\n      configurable: false,\n    },\n  },\n\n  config: schemaConfig, // TODO: to move to content-manager options\n};\n"],"names":["schemaConfig","require$$0","user","collectionName","info","name","description","singularName","pluralName","displayName","options","timestamps","attributes","username","type","minLength","unique","configurable","required","email","provider","password","private","searchable","resetPasswordToken","confirmationToken","confirmed","default","blocked","role","relation","target","inversedBy","config"],"mappings":";;;;;;;AAEA,IAAA,MAAMA,YAAeC,GAAAA,mBAAAA,EAAAA;IAErBC,IAAiB,GAAA;QACfC,cAAgB,EAAA,UAAA;QAChBC,IAAM,EAAA;YACJC,IAAM,EAAA,MAAA;YACNC,WAAa,EAAA,EAAA;YACbC,YAAc,EAAA,MAAA;YACdC,UAAY,EAAA,OAAA;YACZC,WAAa,EAAA;AACd,SAAA;QACDC,OAAS,EAAA;YACPC,UAAY,EAAA;AACb,SAAA;QACDC,UAAY,EAAA;YACVC,QAAU,EAAA;gBACRC,IAAM,EAAA,QAAA;gBACNC,SAAW,EAAA,CAAA;gBACXC,MAAQ,EAAA,IAAA;gBACRC,YAAc,EAAA,KAAA;gBACdC,QAAU,EAAA;AACX,aAAA;YACDC,KAAO,EAAA;gBACLL,IAAM,EAAA,OAAA;gBACNC,SAAW,EAAA,CAAA;gBACXE,YAAc,EAAA,KAAA;gBACdC,QAAU,EAAA;AACX,aAAA;YACDE,QAAU,EAAA;gBACRN,IAAM,EAAA,QAAA;gBACNG,YAAc,EAAA;AACf,aAAA;YACDI,QAAU,EAAA;gBACRP,IAAM,EAAA,UAAA;gBACNC,SAAW,EAAA,CAAA;gBACXE,YAAc,EAAA,KAAA;gBACdK,OAAS,EAAA,IAAA;gBACTC,UAAY,EAAA;AACb,aAAA;YACDC,kBAAoB,EAAA;gBAClBV,IAAM,EAAA,QAAA;gBACNG,YAAc,EAAA,KAAA;gBACdK,OAAS,EAAA,IAAA;gBACTC,UAAY,EAAA;AACb,aAAA;YACDE,iBAAmB,EAAA;gBACjBX,IAAM,EAAA,QAAA;gBACNG,YAAc,EAAA,KAAA;gBACdK,OAAS,EAAA,IAAA;gBACTC,UAAY,EAAA;AACb,aAAA;YACDG,SAAW,EAAA;gBACTZ,IAAM,EAAA,SAAA;gBACNa,OAAS,EAAA,KAAA;gBACTV,YAAc,EAAA;AACf,aAAA;YACDW,OAAS,EAAA;gBACPd,IAAM,EAAA,SAAA;gBACNa,OAAS,EAAA,KAAA;gBACTV,YAAc,EAAA;AACf,aAAA;YACDY,IAAM,EAAA;gBACJf,IAAM,EAAA,UAAA;gBACNgB,QAAU,EAAA,WAAA;gBACVC,MAAQ,EAAA,gCAAA;gBACRC,UAAY,EAAA,OAAA;gBACZf,YAAc,EAAA;AACf;AACF,SAAA;QAEDgB,MAAQjC,EAAAA;AACV,KAAA;;;;;;"}

package/dist/server/content-types/user/schema-config.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var schemaConfig;
+var hasRequiredSchemaConfig;
+function requireSchemaConfig() {
+    if (hasRequiredSchemaConfig) return schemaConfig;
+    hasRequiredSchemaConfig = 1;
+    schemaConfig = {
+        attributes: {
+            resetPasswordToken: {
+                hidden: true
+            },
+            confirmationToken: {
+                hidden: true
+            },
+            provider: {
+                hidden: true
+            }
+        }
+    };
+    return schemaConfig;
+}
+
+exports.__require = requireSchemaConfig;
+//# sourceMappingURL=schema-config.js.map

package/dist/server/content-types/user/schema-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-config.js","sources":["../../../../server/content-types/user/schema-config.js"],"sourcesContent":["'use strict';\n\nmodule.exports = {\n  attributes: {\n    resetPasswordToken: {\n      hidden: true,\n    },\n    confirmationToken: {\n      hidden: true,\n    },\n    provider: {\n      hidden: true,\n    },\n  },\n};\n"],"names":["schemaConfig","attributes","resetPasswordToken","hidden","confirmationToken","provider"],"mappings":";;;;;;;IAEAA,YAAiB,GAAA;QACfC,UAAY,EAAA;YACVC,kBAAoB,EAAA;gBAClBC,MAAQ,EAAA;AACT,aAAA;YACDC,iBAAmB,EAAA;gBACjBD,MAAQ,EAAA;AACT,aAAA;YACDE,QAAU,EAAA;gBACRF,MAAQ,EAAA;AACT;AACF;AACH,KAAA;;;;;;"}

package/dist/server/content-types/user/schema-config.mjs

@@ -0,0 +1,23 @@
+var schemaConfig;
+var hasRequiredSchemaConfig;
+function requireSchemaConfig() {
+    if (hasRequiredSchemaConfig) return schemaConfig;
+    hasRequiredSchemaConfig = 1;
+    schemaConfig = {
+        attributes: {
+            resetPasswordToken: {
+                hidden: true
+            },
+            confirmationToken: {
+                hidden: true
+            },
+            provider: {
+                hidden: true
+            }
+        }
+    };
+    return schemaConfig;
+}
+
+export { requireSchemaConfig as __require };
+//# sourceMappingURL=schema-config.mjs.map

package/dist/server/content-types/user/schema-config.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-config.mjs","sources":["../../../../server/content-types/user/schema-config.js"],"sourcesContent":["'use strict';\n\nmodule.exports = {\n  attributes: {\n    resetPasswordToken: {\n      hidden: true,\n    },\n    confirmationToken: {\n      hidden: true,\n    },\n    provider: {\n      hidden: true,\n    },\n  },\n};\n"],"names":["schemaConfig","attributes","resetPasswordToken","hidden","confirmationToken","provider"],"mappings":";;;;;IAEAA,YAAiB,GAAA;QACfC,UAAY,EAAA;YACVC,kBAAoB,EAAA;gBAClBC,MAAQ,EAAA;AACT,aAAA;YACDC,iBAAmB,EAAA;gBACjBD,MAAQ,EAAA;AACT,aAAA;YACDE,QAAU,EAAA;gBACRF,MAAQ,EAAA;AACT;AACF;AACH,KAAA;;;;;;"}

package/dist/server/controllers/auth.js

@@ -0,0 +1,429 @@
+'use strict';
+
+var require$$0 = require('crypto');
+var require$$0$1 = require('lodash');
+var require$$0$2 = require('lodash/fp');
+var require$$1 = require('@strapi/utils');
+var index = require('../utils/index.js');
+var auth$1 = require('./validation/auth.js');
+var require$$6 = require('grant');
+
+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;
+    const _ = require$$0$1;
+    const { concat, compact, isArray } = require$$0$2;
+    const utils = require$$1;
+    const { getService } = index.__require();
+    const { validateCallbackBody, validateRegisterBody, validateSendEmailConfirmationBody, validateForgotPasswordBody, validateResetPasswordBody, validateEmailConfirmationBody, validateChangePasswordBody } = auth$1.__require();
+    const { ApplicationError, ValidationError, ForbiddenError } = utils.errors;
+    const sanitizeUser = (user, ctx)=>{
+        const { auth } = ctx.state;
+        const userSchema = strapi.getModel('plugin::users-permissions.user');
+        return strapi.contentAPI.sanitize.output(user, userSchema, {
+            auth
+        });
+    };
+    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');
+                    }
+                    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');
+                    }
+                    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
+                });
+                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
+                });
+                // Update the user.
+                ctx.send({
+                    jwt: getService('jwt').issue({
+                        id: user.id
+                    }),
+                    user: await sanitizeUser(user, ctx)
+                });
+            },
+            async connect (ctx, next) {
+                const grant = require$$6.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 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