@webbio/strapi-plugin-page-builder 0.10.9-platform → 0.11.10-platform

package/dist/server/services/email.js

@@ -0,0 +1,132 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const AWS = __importStar(require("@aws-sdk/client-ses"));
+const txtMail_email_template_text_1 = require("./private-content/mail-template/txtMail.email.template.text");
+const constants_1 = require("../../shared/utils/constants");
+exports.default = {
+    async sendMail(options) {
+        const { from, to, subject, text, variables } = options;
+        const emailData = (0, txtMail_email_template_text_1.txtEmail)(text, variables);
+        try {
+            const client = new AWS.SES();
+            await client.sendEmail({
+                Source: from,
+                Destination: {
+                    ToAddresses: [to]
+                },
+                Message: {
+                    Subject: { Data: subject },
+                    Body: {
+                        Text: { Data: emailData }
+                    }
+                }
+            });
+        }
+        catch (error) {
+            console.error(error);
+        }
+    },
+    async sendAdminMail(user) {
+        const foundUser = await strapi.entityService.findOne(constants_1.USER_PERMISSION_USER_PLUGIN, user.id, {
+            populate: { platform: { populate: { platformEmails: { populate: '*' } } } }
+        });
+        await this.sendMail({
+            // @ts-ignore we all love strapi typings
+            from: foundUser.platform.platformEmails.adminEmail.fromEmail,
+            // @ts-ignore
+            to: foundUser.platform.platformEmails.adminEmail.toEmail,
+            // @ts-ignore
+            subject: foundUser.platform.platformEmails.adminEmail.subject,
+            // @ts-ignore
+            text: foundUser.platform.platformEmails.adminEmail.message,
+            variables: {
+                firstName: user.firstName,
+                lastName: user.lastName
+            }
+        });
+    },
+    async sendConfirmationEmail(user) {
+        const foundUser = await strapi.entityService.findOne(constants_1.USER_PERMISSION_USER_PLUGIN, user.id, {
+            populate: { platform: { populate: { platformEmails: { populate: '*' } } } }
+        });
+        if (foundUser && foundUser.platform) {
+            const jwtService = strapi.plugin('users-permissions').service('jwt');
+            const confirmationToken = await jwtService.issue(
+            // @ts-ignore
+            { userId: user.id, platformId: foundUser.platform.id }, { expiresIn: '1d' });
+            await strapi.entityService.update(constants_1.USER_PERMISSION_USER_PLUGIN, user.id, {
+                // @ts-ignore
+                data: { confirmationToken: confirmationToken }
+            });
+            // @ts-ignore
+            const confirmEmailUrl = `${strapi.config.server.url}/api/page-builder/activate/${confirmationToken}`;
+            await this.sendMail({
+                // @ts-ignore
+                from: foundUser.platform.platformEmails.accountCreatedMail.fromEmail,
+                // @ts-ignore
+                to: foundUser.email,
+                // @ts-ignore
+                subject: foundUser.platform.platformEmails.accountCreatedMail.subject,
+                // @ts-ignore
+                text: foundUser.platform.platformEmails.accountCreatedMail.message,
+                variables: {
+                    // @ts-ignore
+                    firstName: foundUser.firstName,
+                    // @ts-ignore
+                    lastName: foundUser.lastName,
+                    confirmEmailUrl
+                }
+            });
+        }
+    },
+    async sendForgotPasswordMail(user) {
+        if (user && user.platform) {
+            const jwtService = strapi.plugin('users-permissions').service('jwt');
+            const resetPasswordToken = await jwtService.issue({ userId: user.id, platformId: user.platform.id }, { expiresIn: '1d' });
+            await strapi.entityService.update(constants_1.USER_PERMISSION_USER_PLUGIN, user.id, {
+                // @ts-ignore
+                data: { resetPasswordToken }
+            });
+            // @ts-ignore
+            const searchParams = new URLSearchParams({ token: resetPasswordToken });
+            const resetPasswordUrl = `${user.platform.domain}/wachtwoord-resetten/?${searchParams.toString()}`;
+            await this.sendMail({
+                // @ts-ignore
+                from: user.platform.platformEmails.resetPasswordMail.fromEmail,
+                to: user.email,
+                // @ts-ignore
+                subject: user.platform.platformEmails.resetPasswordMail.subject,
+                // @ts-ignore
+                text: user.platform.platformEmails.resetPasswordMail.message,
+                variables: {
+                    firstName: user === null || user === void 0 ? void 0 : user.firstName,
+                    lastName: user === null || user === void 0 ? void 0 : user.lastName,
+                    resetPasswordUrl
+                }
+            });
+        }
+    }
+};

package/dist/server/services/index.js

@@ -9,11 +9,15 @@ const page_type_1 = __importDefault(require("./page-type"));
 const collection_types_1 = __importDefault(require("./collection-types"));
 const template_1 = __importDefault(require("./template"));
 const platform_1 = __importDefault(require("./platform"));
+const email_1 = __importDefault(require("./email"));
+const private_content_1 = __importDefault(require("./private-content"));
 exports.default = {
     page: page_1.default,
     builder: builder_1.default,
     'page-type': page_type_1.default,
     'collection-types': collection_types_1.default,
     template: template_1.default,
-    platform: platform_1.default
+    platform: platform_1.default,
+    email: email_1.default,
+    'private-content': private_content_1.default
 };

package/dist/server/services/private-content/components/admin-email.json

@@ -0,0 +1,22 @@
+{
+    "collectionName": "components_internal_admin_emails",
+    "info": {
+        "displayName": "AdminEmail",
+        "description": ""
+    },
+    "options": {},
+    "attributes": {
+        "toEmail": {
+            "type": "string"
+        },
+        "fromEmail": {
+            "type": "string"
+        },
+        "subject": {
+            "type": "string"
+        },
+        "message": {
+            "type": "text"
+        }
+    }
+}

package/dist/server/services/private-content/components/email.json

@@ -0,0 +1,22 @@
+{
+    "collectionName": "components_internal_emails",
+    "info": {
+        "displayName": "email",
+        "description": ""
+    },
+    "options": {},
+    "attributes": {
+        "nameSender": {
+            "type": "string"
+        },
+        "fromEmail": {
+            "type": "string"
+        },
+        "subject": {
+            "type": "string"
+        },
+        "message": {
+            "type": "text"
+        }
+    }
+}

package/dist/server/services/private-content/components/platform-email.json

@@ -0,0 +1,30 @@
+{
+    "collectionName": "components_internal_platform_emails",
+    "info": {
+        "displayName": "PlatformEmail"
+    },
+    "options": {},
+    "attributes": {
+        "resetPasswordMail": {
+            "type": "component",
+            "repeatable": false,
+            "component": "internal.email"
+        },
+        "accountCreatedMail": {
+            "type": "component",
+            "repeatable": false,
+            "component": "internal.email"
+        },
+        "accountAcceptedMail": {
+            "type": "component",
+            "repeatable": false,
+            "component": "internal.email"
+        },
+        "adminEmail": {
+            "displayName": "AdminEmail",
+            "type": "component",
+            "repeatable": false,
+            "component": "internal.admin-email"
+        }
+    }
+}

package/dist/server/services/private-content/constants/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACTIONS = exports.CONTENT_ENTITY_MANAGER = exports.USER_ROLE = exports.USER_CONTENT_MANAGER = exports.USER_MODEL = exports.CREATED_BY_ATTRIBUTE = exports.UPDATED_BY_ATTRIBUTE = void 0;
+const utils_1 = require("@strapi/utils");
+_a = utils_1.contentTypes.constants, exports.UPDATED_BY_ATTRIBUTE = _a.UPDATED_BY_ATTRIBUTE, exports.CREATED_BY_ATTRIBUTE = _a.CREATED_BY_ATTRIBUTE;
+exports.USER_MODEL = 'plugin::users-permissions.user';
+exports.USER_CONTENT_MANAGER = 'plugin::users-permissions.contentmanageruser';
+exports.USER_ROLE = 'plugin::users-permissions.role';
+exports.CONTENT_ENTITY_MANAGER = 'plugin::content-manager.entity-manager';
+exports.ACTIONS = {
+    read: 'plugin::content-manager.explorer.read',
+    create: 'plugin::content-manager.explorer.create',
+    edit: 'plugin::content-manager.explorer.update',
+    delete: 'plugin::content-manager.explorer.delete'
+};

package/dist/server/services/private-content/graphql/index.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendGraphQL = void 0;
+const types_1 = require("./types");
+const register_1 = require("./resolvers/register");
+const login_1 = require("./resolvers/login");
+const forgot_password_1 = require("./resolvers/forgot-password");
+const reset_password_1 = require("./resolvers/reset-password");
+const findOnePage_1 = require("./resolvers/findOnePage");
+const findPage_1 = require("./resolvers/findPage");
+const extendGraphQL = () => {
+    const extensionService = strapi.plugin('graphql').service('extension');
+    const extension = () => ({
+        typeDefs: `
+			${types_1.RegisterInput}
+
+      ${types_1.LoginInput}
+
+			${types_1.RegisterResponse}
+
+			${types_1.LoginResponse}
+
+			${types_1.User}
+
+			${types_1.Mutations}
+
+			${types_1.ForgotPasswordInput}
+
+			${types_1.ForgotPasswordResponse}
+
+			${types_1.ResetPasswordInput}
+
+			${types_1.ResetPasswordResponse}
+
+			${types_1.ResetPasswordInput}
+
+			${types_1.ResetPasswordResponse}
+
+			${types_1.Queries}
+
+      `,
+        resolvers: {
+            Query: {
+                page: findOnePage_1.page,
+                pages: findPage_1.pages
+            },
+            Mutation: {
+                platformLogin: login_1.platformLogin,
+                platformRegister: register_1.platformRegister,
+                platformForgotPassword: forgot_password_1.platformForgotPassword,
+                platformResetPassword: reset_password_1.platformResetPassword
+            }
+        },
+        resolversConfig: {
+            'Mutation.platformLogin': {
+                auth: false
+            },
+            'Mutation.platformRegister': {
+                auth: false
+            },
+            'Mutation.platformForgotPassword': {
+                auth: false
+            },
+            'Mutation.platformResetPassword': {
+                auth: false
+            },
+            'Query.page': {
+                auth: false
+            },
+            'Query.pages': {
+                auth: false
+            }
+        }
+    });
+    extensionService.use(extension);
+};
+exports.extendGraphQL = extendGraphQL;

package/dist/server/services/private-content/graphql/resolvers/findOnePage.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.page = void 0;
+const fp_1 = require("lodash/fp");
+const utils_1 = require("@strapi/utils");
+const constants_1 = require("../../../../../shared/utils/constants");
+const apollo_server_koa_1 = require("apollo-server-koa");
+exports.page = {
+    async resolve(parent, args, ctx) {
+        var _a, _b, _c, _d;
+        const uid = constants_1.PAGE_UID;
+        const { toEntityResponse } = strapi.plugin('graphql').service('format').returnTypes;
+        const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
+        const populatedArgs = { ...args, populate: { platform: true } };
+        const transformedArgs = transformArgs(populatedArgs, strapi.contentType(constants_1.PAGE_UID));
+        const sanitizedQuery = await utils_1.sanitize.contentAPI.query(populatedArgs, strapi.contentType(constants_1.PAGE_UID));
+        const value = await strapi.entityService.findOne(uid, args.id, (0, fp_1.omit)('id', sanitizedQuery));
+        // @ts-ignore Strapi types are the best
+        if (!((_a = value === null || value === void 0 ? void 0 : value.platform) === null || _a === void 0 ? void 0 : _a.isPrivate) && !(value === null || value === void 0 ? void 0 : value.isPrivate)) {
+            return toEntityResponse(value, { args: transformedArgs, resourceUID: uid });
+        }
+        if (
+        // @ts-ignore Strapi types are the best
+        (((_b = value === null || value === void 0 ? void 0 : value.platform) === null || _b === void 0 ? void 0 : _b.isPrivate) === true && ctx.koaContext.req.headers.authorization) ||
+            ((value === null || value === void 0 ? void 0 : value.isPrivate) === true && ctx.koaContext.req.headers.authorization)) {
+            const auth = ctx.koaContext.req.headers.authorization;
+            const token = auth.split(' ');
+            const jwtService = strapi.plugin('users-permissions').service('jwt');
+            const decodedToken = await jwtService.verify(token[1]);
+            if (decodedToken) {
+                const user = ctx.state.user;
+                // @ts-ignore Strapi types are the best
+                if (((_c = user === null || user === void 0 ? void 0 : user.platform) === null || _c === void 0 ? void 0 : _c.id) === ((_d = value === null || value === void 0 ? void 0 : value.platform) === null || _d === void 0 ? void 0 : _d.id)) {
+                    return toEntityResponse(value, { args: transformedArgs, resourceUID: uid });
+                }
+            }
+        }
+        return new apollo_server_koa_1.ForbiddenError('Forbidden access');
+    }
+};

package/dist/server/services/private-content/graphql/resolvers/findPage.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pages = void 0;
+const utils_1 = require("@strapi/utils");
+const constants_1 = require("../../../../../shared/utils/constants");
+exports.pages = {
+    async resolve(parent, args, ctx) {
+        const uid = constants_1.PAGE_UID;
+        const { toEntityResponseCollection } = strapi.plugin('graphql').service('format').returnTypes;
+        const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
+        const populatedArgs = { ...args, populate: { platform: true } };
+        const transformedArgs = transformArgs(populatedArgs, strapi.contentType(constants_1.PAGE_UID));
+        const sanitizedQuery = await utils_1.sanitize.contentAPI.query(populatedArgs, strapi.contentType(constants_1.PAGE_UID));
+        const value = await strapi.entityService.findMany(uid, sanitizedQuery);
+        const user = ctx.state.user;
+        if (user && ctx.koaContext.req.headers.authorization) {
+            const auth = ctx.koaContext.req.headers.authorization;
+            const token = auth.split(' ');
+            const jwtService = strapi.plugin('users-permissions').service('jwt');
+            const decodedToken = await jwtService.verify(token[1]);
+            if (decodedToken) {
+                // @ts-ignore
+                const filteredItems = value.filter((item) => {
+                    var _a, _b;
+                    // @ts-ignore
+                    if (((_a = item.platform) === null || _a === void 0 ? void 0 : _a.isPrivate) === true && user.platform.id === item.platform.id) {
+                        return item;
+                    }
+                    if ((item === null || item === void 0 ? void 0 : item.isPrivate) === true && user.platform.id === item.platform.id) {
+                        return item;
+                    }
+                    // @ts-ignore
+                    if (((_b = item.platform) === null || _b === void 0 ? void 0 : _b.isPrivate) !== true && (item === null || item === void 0 ? void 0 : item.isPrivate) !== true) {
+                        return item;
+                    }
+                });
+                return toEntityResponseCollection(filteredItems, { args: transformedArgs, resourceUID: uid });
+            }
+        }
+        // @ts-ignore
+        const filteredItems = value.filter((item) => { var _a; return ((_a = item.platform) === null || _a === void 0 ? void 0 : _a.isPrivate) !== true && (item === null || item === void 0 ? void 0 : item.isPrivate) !== true; });
+        return toEntityResponseCollection(filteredItems, { args: transformedArgs, resourceUID: uid });
+    }
+};

package/dist/server/services/private-content/graphql/resolvers/forgot-password.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.platformForgotPassword = void 0;
+const utils_1 = require("@strapi/utils");
+const constants_1 = require("../../constants");
+const schemas_1 = require("../../schemas");
+const { UnauthorizedError } = utils_1.errors;
+exports.platformForgotPassword = {
+    async resolve(parent, args, context) {
+        await (0, schemas_1.validateForgotPasswordSchema)(args.input);
+        const { email, domain } = args.input;
+        const user = await strapi.query(constants_1.USER_MODEL).findOne({
+            populate: { platform: { populate: { platformEmails: { populate: true } } } },
+            where: {
+                email: email.toLowerCase(),
+                platform: {
+                    domain: domain.toLowerCase()
+                }
+            }
+        });
+        if (!user) {
+            {
+                message: 'Email has been sent';
+            }
+        }
+        await strapi.service('plugin::page-builder.email').sendForgotPasswordMail(user);
+        return {
+            message: 'Email has been sent'
+        };
+    }
+};

package/dist/server/services/private-content/graphql/resolvers/login.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.platformLogin = void 0;
+const utils_1 = require("@strapi/utils");
+const constants_1 = require("../../constants");
+const schemas_1 = require("../../schemas");
+const { UnauthorizedError } = utils_1.errors;
+exports.platformLogin = {
+    async resolve(parent, args, context) {
+        await (0, schemas_1.validateLoginSchema)(args.input);
+        const { email, password, domain } = args.input;
+        const user = await strapi.query(constants_1.USER_MODEL).findOne({
+            where: {
+                email: email.toLowerCase(),
+                platform: {
+                    domain: domain.toLowerCase()
+                }
+            },
+            populate: {
+                platform: true
+            }
+        });
+        if (user == null) {
+            throw new UnauthorizedError('Invalid email or password');
+        }
+        const isPasswordValid = await strapi
+            .service('plugin::users-permissions.user')
+            .validatePassword(password, user.password);
+        if (isPasswordValid === false) {
+            throw new UnauthorizedError('Invalid email or password');
+        }
+        if (user.confirmed === false) {
+            throw new UnauthorizedError('Email is not confirmed');
+        }
+        if (user.activateUser === false) {
+            throw new UnauthorizedError('Account is not activated');
+        }
+        const sanitizedUser = utils_1.sanitize.contentAPI.output(user, strapi.getModel(constants_1.USER_MODEL), {
+            auth: false
+        });
+        const jwt = await strapi
+            .service('plugin::users-permissions.jwt')
+            .issue({ id: user.id, platformId: user.platform.id });
+        return {
+            user: sanitizedUser,
+            jwt
+        };
+    }
+};

package/dist/server/services/private-content/graphql/resolvers/register.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.platformRegister = void 0;
+const utils_1 = require("@strapi/utils");
+const utils_2 = require("@strapi/utils");
+const constants_1 = require("../../constants");
+const schemas_1 = require("../../schemas");
+const { ApplicationError, NotFoundError } = utils_2.errors;
+exports.platformRegister = {
+    async resolve(parent, args, context) {
+        const pluginStore = await strapi.store({ type: 'plugin', name: 'users-permissions' });
+        const settings = await pluginStore.get({ key: 'advanced' });
+        await (0, schemas_1.validateRegisterSchema)(args.input);
+        const { email, domain } = args.input;
+        const platform = await strapi.query('api::platform.platform').findOne({
+            where: {
+                domain: domain.toLowerCase()
+            }
+        });
+        if (!platform) {
+            throw new NotFoundError('Platform not found');
+        }
+        const role = await strapi
+            .query('plugin::users-permissions.role')
+            .findOne({ where: { type: settings.default_role } });
+        if (!role) {
+            throw new ApplicationError('Impossible to find the default role');
+        }
+        const conflictingUserCount = await strapi.query(constants_1.USER_MODEL).count({
+            where: {
+                $and: [
+                    {
+                        email: email.toLowerCase()
+                    },
+                    {
+                        platform: {
+                            id: platform.id
+                        }
+                    }
+                ]
+            }
+        });
+        if (conflictingUserCount > 0) {
+            throw new ApplicationError('Email is already taken');
+        }
+        const userData = {
+            ...args.input,
+            role: role.id,
+            categories: args.input.categories,
+            platform: platform.id,
+            email: email.toLowerCase(),
+            provider: 'local',
+            confirmed: false,
+            activateUser: false
+        };
+        const createdUser = await strapi.entityService.create(constants_1.USER_MODEL, {
+            data: userData
+        });
+        const userModel = strapi.getModel(constants_1.USER_MODEL);
+        const sanitizedUser = utils_1.sanitize.contentAPI.output(createdUser, userModel, {
+            auth: false
+        });
+        await strapi.service('plugin::page-builder.email').sendConfirmationEmail(createdUser);
+        return {
+            user: sanitizedUser
+        };
+    }
+};

package/dist/server/services/private-content/graphql/resolvers/reset-password.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.platformResetPassword = void 0;
+const utils_1 = require("@strapi/utils");
+const constants_1 = require("../../constants");
+const schemas_1 = require("../../schemas");
+exports.platformResetPassword = {
+    async resolve(parent, args, context) {
+        await (0, schemas_1.validateResetPasswordSchema)(args.input);
+        const { password, resetPasswordToken } = args.input;
+        const jwtService = strapi.plugin('users-permissions').service('jwt');
+        const decodedToken = await jwtService.verify(resetPasswordToken);
+        if (decodedToken) {
+            const user = await strapi.query(constants_1.USER_MODEL).findOne({
+                where: {
+                    id: decodedToken.userId,
+                    resetPasswordToken: resetPasswordToken
+                }
+            });
+            if (user && user.resetPasswordToken && user.resetPasswordToken === resetPasswordToken) {
+                if (password) {
+                    await strapi.entityService.update(constants_1.USER_MODEL, user.id, {
+                        data: {
+                            // @ts-ignore
+                            password: password,
+                            resetPasswordToken: null
+                        }
+                    });
+                }
+                const userModel = strapi.getModel(constants_1.USER_MODEL);
+                const sanitizedUser = utils_1.sanitize.contentAPI.output(user, userModel, {
+                    auth: false
+                });
+                return {
+                    user: sanitizedUser
+                };
+            }
+        }
+        throw new Error('Time of token has expired request a new password change');
+    }
+};