@webbio/strapi-plugin-page-builder 0.12.3-platform → 0.12.4-platform

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@webbio/strapi-plugin-page-builder",
-    "version": "0.12.3-platform",
+    "version": "0.12.4-platform",
     "description": "This is the description of the plugin.",
     "scripts": {
         "develop": "tsc -p tsconfig.server.json -w",

package/dist/server/bootstrap/collection-type-lifecycles.js

@@ -9,7 +9,7 @@ exports.default = async ({ strapi }) => {
     const models = collectionTypesWithPageMorph.map((ct) => ct.uid);
     (_a = strapi.db) === null || _a === void 0 ? void 0 : _a.lifecycles.subscribe({
         models,
-        async beforeUpdate(event) {
+        async afterUpdate(event) {
             var _a, _b, _c, _d, _e, _f;
             try {
                 let { data, where } = event === null || event === void 0 ? void 0 : event.params;

package/dist/server/graphql/page-by-slug.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const filter_underscore_arguments_1 = require("../utils/filter-underscore-arguments");
+const constants_1 = require("../../shared/utils/constants");
+const getPageBySlug = (strapi) => {
+    const typeDefs = () => {
+        return `
+				extend type Page {
+					collectionType: GenericMorph
+				}
+
+        type Query {
+          getPageBySlug(path: String, _domain: String, _locale: String, _publicationState: PublicationState): PageEntity
+        }
+
+      `;
+    };
+    const resolvers = (strapi) => {
+        const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
+        return {
+            Query: {
+                getPageBySlug: {
+                    resolve: async (_parent, args, ctx) => {
+                        var _a;
+                        try {
+                            const filteredArgs = {
+                                ...(0, filter_underscore_arguments_1.filterUnderscoreArguments)(args),
+                                platform: { domain: args._domain }
+                            };
+                            const { toEntityResponse } = strapi.plugin('graphql').service('format').returnTypes;
+                            const getPage = async () => {
+                                var _a, _b, _c;
+                                const transformedArgs = transformArgs(filteredArgs, {
+                                    contentType: strapi.contentTypes[constants_1.PAGE_UID],
+                                    usePagination: false
+                                });
+                                const results = await ((_a = strapi.entityService) === null || _a === void 0 ? void 0 : _a.findMany(constants_1.PAGE_UID, {
+                                    filters: filteredArgs,
+                                    locale: args._locale,
+                                    publicationState: args._publicationState,
+                                    populate: '*'
+                                }));
+                                const entityResponse = toEntityResponse((results === null || results === void 0 ? void 0 : results[0]) || {}, {
+                                    args: transformedArgs,
+                                    resourceUID: constants_1.PAGE_UID
+                                });
+                                if (!(entityResponse === null || entityResponse === void 0 ? void 0 : entityResponse.value) || Object.keys(entityResponse.value).length === 0) {
+                                    throw new Error(ctx.koaContext.response.message);
+                                }
+                                const collectionTypeDataFilter = (_c = (_b = entityResponse === null || entityResponse === void 0 ? void 0 : entityResponse.value) === null || _b === void 0 ? void 0 : _b.collectionTypeData) === null || _c === void 0 ? void 0 : _c.filter(Boolean);
+                                const collectionType = collectionTypeDataFilter.length === 1 ? collectionTypeDataFilter === null || collectionTypeDataFilter === void 0 ? void 0 : collectionTypeDataFilter[0] : null;
+                                const addedAttributes = {
+                                    collectionType: collectionType
+                                };
+                                const result = {
+                                    ...entityResponse.value,
+                                    ...addedAttributes
+                                };
+                                return result;
+                            };
+                            const results = await getPage();
+                            if (((_a = Object.values(results)) === null || _a === void 0 ? void 0 : _a.filter(Boolean).length) > 0) {
+                                return results;
+                            }
+                            else {
+                                throw new Error(ctx.koaContext.response.message);
+                            }
+                        }
+                        catch (error) {
+                            console.log('Error in getPageBySlug:', error);
+                            throw new Error(ctx.koaContext.response.message);
+                        }
+                    }
+                }
+            }
+        };
+    };
+    const resolversConfig = {
+        'Query.getPageBySlug': {
+            auth: false
+        }
+    };
+    return {
+        typeDefs: typeDefs(),
+        resolvers: resolvers(strapi),
+        resolversConfig
+    };
+};
+exports.default = getPageBySlug;

package/dist/server/utils/graphql.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerGraphQLResolvers = void 0;
+const constants_1 = require("../../shared/utils/constants");
+const findPageByPath = (strapi) => {
+    const typeDefs = `
+  type Query {
+    findPageByPath(path: String, locale: I18NLocaleCode): PageEntityResponse 
+  }
+  `;
+    const resolvers = (strapi) => {
+        const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
+        const { toEntityResponse, toEntityResponseCollection } = strapi.plugin('graphql').service('format').returnTypes;
+        return {
+            Query: {
+                findPageByPath: {
+                    resolve: async (parent, args, ctx) => {
+                        const contentType = strapi.getModel(constants_1.PAGE_UID);
+                        const transformedArgs = transformArgs(args, { contentType });
+                        const queryResult = await strapi.entityService.findMany(contentType.uid, {
+                            filters: {
+                                path: {
+                                    $eq: transformedArgs.path
+                                }
+                            },
+                            locale: transformedArgs.locale
+                        });
+                        const result = queryResult === null || queryResult === void 0 ? void 0 : queryResult[0];
+                        return toEntityResponse(result, {
+                            args: transformedArgs,
+                            resourceUID: contentType.uid
+                        });
+                    }
+                }
+            }
+        };
+    };
+    const resolversConfig = {
+        'Query.findPageByPath': {
+            auth: false
+        }
+    };
+    return {
+        typeDefs,
+        resolvers: resolvers(strapi),
+        resolversConfig
+    };
+};
+const findPagePaths = (strapi) => {
+    const typeDefs = `
+  type PageByPath {
+    id: Int!
+    path: String!
+    title: String!
+    locale: String!
+    pageType: ENUM_PAGE_PAGETYPE
+    updatedAt: DateTime!
+    publishedAt: DateTime!
+  }
+
+  type Query {
+    findPagePaths(locale: String, pageType: String = "all"): [PageByPath]
+  }
+  `;
+    const resolvers = (strapi) => {
+        const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
+        return {
+            Query: {
+                findPagePaths: {
+                    resolve: async (parent, args, ctx) => {
+                        const contentType = strapi.getModel(constants_1.PAGE_UID);
+                        const transformedArgs = transformArgs(args, { contentType });
+                        const queryResult = await strapi.entityService.findMany(contentType.uid, {
+                            populate: '*',
+                            locale: transformedArgs.locale
+                        });
+                        const result = queryResult.filter((page) => page === null || page === void 0 ? void 0 : page.path);
+                        return result;
+                    }
+                }
+            }
+        };
+    };
+    const resolversConfig = {
+        'Query.findPagePaths': {
+            auth: false
+        }
+    };
+    return {
+        typeDefs,
+        resolvers: resolvers(strapi),
+        resolversConfig
+    };
+};
+const registerGraphQLResolvers = (strapi) => {
+    const extensionService = strapi.plugin('graphql').service('extension');
+    extensionService.use(findPageByPath(strapi));
+    extensionService.use(findPagePaths(strapi));
+};
+exports.registerGraphQLResolvers = registerGraphQLResolvers;

package/dist/server/utils/paginationValidation.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pagination = void 0;
+class Pagination {
+    static checkPagination(page, pageSize) {
+        const startPage = page === 1 ? 0 : page - 1;
+        const start = startPage * pageSize;
+        const limit = (startPage + 1) * pageSize;
+        return { start, limit };
+    }
+    static async getPaginationInfo(transformedpageArgs, transformArgs, start, pageSize, entityResponse, uid) {
+        var _a;
+        const total = await ((_a = strapi === null || strapi === void 0 ? void 0 : strapi.entityService) === null || _a === void 0 ? void 0 : _a.count(uid, {
+            filters: {
+                ...transformArgs.filters,
+                hasPage: { $eq: true },
+                page: { ...transformedpageArgs.filters }
+            }
+        }));
+        const pageCount = Math.ceil(total / pageSize);
+        const page = Math.floor(start / pageSize) + 1;
+        entityResponse.metaInfo = {
+            total,
+            pageCount,
+            page,
+            pageSize
+        };
+        return entityResponse;
+    }
+}
+exports.Pagination = Pagination;