@webbio/strapi-plugin-page-builder 0.0.31 → 0.1.0

package/README.md

@@ -26,8 +26,9 @@ De collectiontypes `Page`, `Template` en `PageType` worden aangemaakt of bijgewe
 ## Page Types
 
 Maak voor elke pagina type een Page Type aan. Deze kan, maar hoeft niet, gekoppeld worden aan een collection type. Je moet altijd een UID invoeren, als je wenst geen koppeling te maken met een collection type, vul hier alsnog iets in. Het kan zijn dat dit deel van de plugin nog niet werkt, hier is nog niet mee getest.
+hasPage moet toegevoegd worden aan de collectiontype. Dit komt doordat er gefilterd moet kunnen worden middels graphql. Er is een custom manier gebouwd om ervoor te zorgen dat pages gefilterd kan worden.
 
-Voor elk collection type die een page type is, moet deze property toegevoegd worden:
+Voor elk collection type die een page type is, moet deze properties toegevoegd worden:
 
 ```
 "page": {
@@ -35,7 +36,11 @@ Voor elk collection type die een page type is, moet deze property toegevoegd wor
   "relation": "morphMany",
   "target": "api::page.page",
   "morphBy": "collectionTypeData"
-}
+},
+"hasPage": {
+      "type": "boolean",
+      "default": false
+    }
 ```
 
 Zodra dit goed is ingesteld, kan je via deze collectie types direct een pagina aanmaken.
@@ -48,10 +53,36 @@ Op een page kan je in de Edit View een page type selecteren. Op basis daarvan wo
 
 Een template is niets anders dan een sjabloon die je eenmalig kan toevoegen op een pagina. Dit kan via een page type gaan maar kan ook zonder de page type. Een modal zal eerst nog vragen of je zeker bent van je keuze, alle modules zullen vervangen worden.
 
+## Platform
+
+Om wijzigignen aan te brengen in een platform, moeten deze in de schema aangepast worden van de api. `/src/api/platform/content-types/platform/schema.json`
+
+Voor elk collectiontype die je wil toevoegen aan het platform, moet deze relatie toegevoegd worden:
+
+```
+    "collectiontype": {
+      "type": "relation",
+      "relation": "oneToMany",
+      "target": "UID van collection type",
+      "mappedBy": "platform"
+    }
+```
+
+bijvoorbeeld :
+
+```
+    "faqs": {
+      "type": "relation",
+      "relation": "oneToMany",
+      "target": "api::faq.faq",
+      "mappedBy": "platform"
+    }
+```
+
+Een platform zit altijd aan een pagina gekoppeld. Deze moet handmatig in de pagina toegevoegd worden.
+
 # Known bugs
 
-- Bij het dupliceren van een collectiontype met een gekoppelde pagina, wordt ook de nieuwe collectiontype gekoppeld aan die pagina. Dit moet niet gebeuren.
-- Bij het inladen van een template worden diepere waarden niet meegenomen.
 - Bij het opslaan van een collectietype wil de gekoppelde pagina of type in het ui wel eens verdwijnen.
 - Na het ontkoppelen en opslaan van een collectie item op een pagina, staat deze nog als "Geselecteerd" in de dropdown.
 

package/admin/src/components/EditView/CollectionTypeSearch/index.tsx

@@ -32,6 +32,12 @@ export const CollectionTypeSearch = ({ uid }: Props) => {
 	const isPagePageType = !uid;
 	const searchEntitiesIsEnabled = !isPagePageType;
 
+	useEffect(() => {
+		if (form.isCreatingEntry) {
+			setSelected(null);
+		}
+	}, []);
+
 	const getItems = async (inputValue?: string): Promise<IReactSelectValue[]> => {
 		const searchEntities = await getSearchEntities({
 			fetchClient,

package/admin/src/components/EditView/CollectionTypeSettings/CreatePageButton/index.tsx

@@ -1,4 +1,4 @@
-import React from 'react';
+import React, { useEffect } from 'react';
 import { useHistory } from 'react-router-dom';
 
 import { Plus } from '@strapi/icons';
@@ -15,7 +15,7 @@ export const CreatePageButton = () => {
 	const history = useHistory();
 	const { layout, initialData } = useCMEditViewDataManager();
 
-	const { post, get } = useFetchClient();
+	const { post, get, put } = useFetchClient();
 	const url = `/content-manager/collectionType/${PAGE_UID}/create`;
 
 	const handleCreatePage = async (e: React.MouseEvent<HTMLAnchorElement>) => {
@@ -41,8 +41,10 @@ export const CreatePageButton = () => {
 				layoutUid: layout.uid,
 				relatedEntityId: createLocalizedPage ? linkedPages.data?.[0]?.id : undefined
 			});
-
 			if (newPage?.id) {
+				await put(`/content-manager/collection-types/${layout.uid}/${initialData.id}`, {
+					hasPage: true
+				});
 				history.push(`/content-manager/collectionType/${PAGE_UID}/${newPage.id}?plugins[i18n][locale]=${locale}`);
 			}
 		} catch (error) {

package/admin/src/components/EditView/CollectionTypeSettings/index.tsx

@@ -1,4 +1,4 @@
-import React from 'react';
+import React, { useEffect } from 'react';
 
 import { useCMEditViewDataManager } from '@strapi/helper-plugin';
 import { Flex } from '@strapi/design-system';
@@ -10,7 +10,7 @@ import { PAGE_TYPE_PAGE, PAGE_UID } from '../../../../../shared/utils/constants'
 import S from '../Details/styles';
 
 export const CollectionTypeSettings = () => {
-	const { layout, isCreatingEntry, initialData } = useCMEditViewDataManager();
+	const { layout, isCreatingEntry, initialData, onChange } = useCMEditViewDataManager();
 
 	const isUserCreatedContentType = layout.uid.startsWith('api::');
 	const linkedPage = initialData.page?.[0];
@@ -18,12 +18,23 @@ export const CollectionTypeSettings = () => {
 	const showCreatePageButton = isUserCreatedContentType && !isCreatingEntry && !linkedPage;
 	const url = generateLink(linkedPage?.id, initialData?.locale);
 
+	useEffect(() => {
+		if (isCreatingEntry) {
+			onChange({
+				target: {
+					name: 'page',
+					value: null
+				}
+			});
+		}
+	}, []);
+
 	if (isCreatingEntry) {
 		return null;
 	}
 
 	return (
-		<Wrapper title="Settings">
+		<Wrapper title="Gekoppelde pagina">
 			<Flex direction="column" gap={4} width="100%" alignItems="start">
 				{showCreatePageButton && <CreatePageButton />}
 

package/admin/src/components/EditView/PageSettings/index.tsx

@@ -3,7 +3,6 @@ import React, { useEffect, useMemo, useState } from 'react';
 import { useCMEditViewDataManager } from '@strapi/helper-plugin';
 import { Stack, Flex } from '@strapi/design-system';
 import { Cog, Cross } from '@strapi/icons';
-
 import { TemplateSelect } from '../Template/TemplateSelect';
 import { PageTypeSelect } from '../page-type-select';
 import { CollectionTypeSearch } from '../CollectionTypeSearch';
@@ -14,9 +13,10 @@ import S from '../Details/styles';
 
 export const PageSettings = () => {
 	const { isCreatingEntry, initialData, onChange, modifiedData } = useCMEditViewDataManager();
-	const { data: pageTypes } = useGetPageTypes({});
-
+	const { data: pageTypesData } = useGetPageTypes({});
+	const [pageTypes, setPageTypes] = useState(pageTypesData);
 	const [selectedPageType, setSelectedPageType] = useState<PageType | undefined | null>(initialData?.initialPageType);
+	const [hasSelectedPlatform, setHasSelectedPlatform] = useState<boolean>(true);
 	const [isEditting, setIsEditting] = useState(false);
 	const showEditFields = useMemo(
 		() => isCreatingEntry || !selectedPageType?.id || !initialData.collectionTypeTitle || isEditting,
@@ -35,6 +35,7 @@ export const PageSettings = () => {
 
 	useEffect(() => {
 		setSelectedPageType(initialData?.initialPageType);
+
 		setIsEditting(false);
 	}, [initialData]);
 
@@ -65,18 +66,24 @@ export const PageSettings = () => {
 				value: pageType.id
 			};
 			setFormValue('pageType', [formPageType]);
+			setHasSelectedPlatform(false);
 		} else {
 			removePageType();
 		}
 	};
 
 	return (
-		<Wrapper title="Settings">
+		<Wrapper title="Gekoppelde type">
 			<Flex direction="column" gap={4} width="100%">
 				{showEditFields ? (
 					<Stack spacing={4} width="100%">
-						<PageTypeSelect pageTypes={pageTypes} selectedPageType={selectedPageType} onChange={handleSelectPageType} />
-						<TemplateSelect />
+						<PageTypeSelect
+							pageTypes={pageTypes}
+							selectedPageType={selectedPageType}
+							onChange={handleSelectPageType}
+							disabled={hasSelectedPlatform}
+						/>
+						<TemplateSelect disabled={hasSelectedPlatform} />
 						{selectedPageType?.uid && <CollectionTypeSearch uid={selectedPageType.uid} />}
 					</Stack>
 				) : (

package/admin/src/components/EditView/Template/TemplateSelect/index.tsx

@@ -5,7 +5,11 @@ import { Template } from '../../../../api/template';
 import TemplateConfirmModal from '../TemplateConfirmModal';
 import { useTemplateModules } from './use-template-modules';
 
-export const TemplateSelect = () => {
+interface Props {
+	disabled: boolean;
+}
+
+export const TemplateSelect = ({ disabled }: Props) => {
 	const { onChange, modifiedData } = useCMEditViewDataManager();
 	const [selectedTemplate, setSelectedTemplate] = useState<Template | null>(null);
 	const { templates, replaceContentTypeModules } = useTemplateModules(onChange);
@@ -44,6 +48,7 @@ export const TemplateSelect = () => {
 				placeholder="Choose a template"
 				value={selectedTemplate?.id || 0}
 				onChange={handleSelectChange}
+				disabled={disabled}
 			>
 				<SingleSelectOption value={0}>None</SingleSelectOption>
 				{templates?.map((template) => (

package/admin/src/components/EditView/Template/TemplateSelect/use-template-modules.ts

@@ -31,7 +31,7 @@ const sanatizeContentTypeModules = (onChange: OnChangeFormType, modules: Record<
 	});
 };
 
-const replaceContentTypeModules = async (id: number,   fetchClient: any, onChange: OnChangeFormType) => {
+const replaceContentTypeModules = async (id: number, fetchClient: any, onChange: OnChangeFormType) => {
 	const { get } = fetchClient;
 	const result = await get(getRequestUrl(`/template/${id}`));
 	return sanatizeContentTypeModules(onChange, result.data.modules);

package/admin/src/components/EditView/page-type-select.tsx

@@ -9,15 +9,17 @@ interface Props {
 	onChange: (pageTypeId: string) => void;
 	selectedPageType?: PageType | null;
 	pageTypes?: PageType[];
+	disabled: boolean;
 }
 
-export const PageTypeSelect = ({ onChange, pageTypes, selectedPageType }: Props) => {
+export const PageTypeSelect = ({ onChange, pageTypes, selectedPageType, disabled }: Props) => {
 	return (
 		<SingleSelect
 			label="Page type"
 			placeholder="Choose a page type"
 			value={selectedPageType?.id || PAGE_TYPE_PAGE}
 			onChange={onChange}
+			disabled={disabled}
 		>
 			<SingleSelectOption value={PAGE_TYPE_PAGE}>Page</SingleSelectOption>
 			{pageTypes?.map((pageType: PageType) => (

package/admin/src/constants.ts

@@ -1 +1,3 @@
 export const PAGE_TYPE_NO_FILTER = 'all';
+export const PLATFORM_NO_FILTER = 'allPlatforms';
+export const PAGE_TYPE = 'pageType';

package/admin/src/index.tsx

@@ -28,7 +28,7 @@ export default {
 			Component: EditView
 		});
 		app.injectContentManagerComponent('listView', 'actions', {
-			name: 'page-type-filter',
+			name: 'page-filters',
 			Component: PageTypeFilter
 		});
 	},

package/dist/package.json

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

package/dist/server/bootstrap.js

@@ -3,11 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@strapi/utils");
 const constants_1 = require("../shared/utils/constants");
 exports.default = async ({ strapi }) => {
+    var _a, _b;
     // TODO: refactor to own function
     try {
-        const pageTypes = await strapi.entityService.findMany('api::page-type.page-type', {
+        const pageTypes = (await ((_a = strapi.entityService) === null || _a === void 0 ? void 0 : _a.findMany(constants_1.PAGE_TYPE_UID, {
             limit: -1
-        });
+        })));
         const pagePermissions = pageTypes.map((pageType) => {
             const name = `page-type-is-${pageType.uid}`;
             const displayName = pageType.title;
@@ -50,27 +51,28 @@ exports.default = async ({ strapi }) => {
         };
         return data;
     };
-    strapi.db.lifecycles.subscribe({
+    (_b = strapi.db) === null || _b === void 0 ? void 0 : _b.lifecycles.subscribe({
         // @ts-ignore
         models: [constants_1.PAGE_UID],
         async beforeCreate(event) {
-            var _a, _b;
+            var _a, _b, _c, _d;
             let { data } = event.params;
             const collectionTypeId = data === null || data === void 0 ? void 0 : data.collectionTypeId;
             const pageTypeId = ((_b = (_a = data === null || data === void 0 ? void 0 : data.pageType.connect) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.id) || data.initialPageType;
             if (collectionTypeId && pageTypeId) {
-                const { uid } = await strapi.entityService.findOne('api::page-type.page-type', pageTypeId);
-                const collectionToConnect = await strapi.entityService.findOne(uid, collectionTypeId, {
+                const pageType = await ((_c = strapi.entityService) === null || _c === void 0 ? void 0 : _c.findOne(constants_1.PAGE_TYPE_UID, pageTypeId));
+                const collectionToConnect = await ((_d = strapi.entityService) === null || _d === void 0 ? void 0 : _d.findOne(pageType === null || pageType === void 0 ? void 0 : pageType.uid, collectionTypeId, {
                     populate: { page: true }
-                });
-                if (collectionToConnect.page && collectionToConnect.page.length > 0) {
+                }));
+                const page = collectionToConnect === null || collectionToConnect === void 0 ? void 0 : collectionToConnect.page;
+                if (page && page.length > 0) {
                     throw new utils_1.errors.ValidationError('You can only link one CollectionType to one page');
                 }
-                data = updateCollectionTypeData(data, collectionTypeId, uid);
+                data = updateCollectionTypeData(data, collectionTypeId, pageType === null || pageType === void 0 ? void 0 : pageType.uid);
             }
         },
         async beforeUpdate(event) {
-            var _a, _b, _c, _d, _e, _f, _g;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
             let data = (_a = event === null || event === void 0 ? void 0 : event.params) === null || _a === void 0 ? void 0 : _a.data;
             const collectionTypeId = data === null || data === void 0 ? void 0 : data.collectionTypeId;
             const pageTypeId = ((_d = (_c = (_b = data === null || data === void 0 ? void 0 : data.pageType) === null || _b === void 0 ? void 0 : _b.connect) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.id) || (data === null || data === void 0 ? void 0 : data.initialPageType);
@@ -79,16 +81,83 @@ exports.default = async ({ strapi }) => {
                 data.collectionTypeData = undefined;
             }
             if (collectionTypeId && pageTypeId && !removedPageType) {
-                const { uid } = await strapi.entityService.findOne('api::page-type.page-type', pageTypeId);
-                const collectionToConnect = await strapi.entityService.findOne(uid, collectionTypeId, {
+                const pageType = await ((_h = strapi.entityService) === null || _h === void 0 ? void 0 : _h.findOne(constants_1.PAGE_TYPE_UID, pageTypeId));
+                const collectionToConnect = await ((_j = strapi.entityService) === null || _j === void 0 ? void 0 : _j.findOne(pageType === null || pageType === void 0 ? void 0 : pageType.uid, collectionTypeId, {
                     populate: { page: true }
-                });
-                if (collectionToConnect.page &&
-                    collectionToConnect.page.length > 0 &&
-                    !(collectionToConnect === null || collectionToConnect === void 0 ? void 0 : collectionToConnect.page.some((p) => p.id === data.id))) {
+                }));
+                const page = collectionToConnect === null || collectionToConnect === void 0 ? void 0 : collectionToConnect.page;
+                if (page && (page === null || page === void 0 ? void 0 : page.length) > 0 && !page.some((p) => p.id === data.id)) {
                     throw new utils_1.errors.ValidationError('You can only link one CollectionType to one page');
                 }
-                data = updateCollectionTypeData(data, collectionTypeId, uid);
+                data = updateCollectionTypeData(data, collectionTypeId, pageType === null || pageType === void 0 ? void 0 : pageType.uid);
+            }
+            // needs to check if the collectionTypeData is already connected to another page
+            // if so, remove the hasPage for filtering
+            // const foundPage = await strapi.entityService?.findOne(PAGE_UID, data.id, { populate: '*' });
+            // if (
+            // 	data.collectionTypeData &&
+            // 	foundPage &&
+            // 	foundPage.collectionTypeData &&
+            // 	+data.collectionTypeData.id !== foundPage.collectionTypeData[0].id
+            // ) {
+            // 	await strapi.entityService?.update(foundPage.collectionTypeData[0].__type, foundPage.collectionTypeData[0].id, {
+            // 		data: {
+            // 			id: foundPage.collectionTypeData[0].id,
+            // 			hasPage: false
+            // 		}
+            // 	});
+            // }
+        },
+        async afterUpdate(event) {
+            var _a, _b;
+            const data = (_a = event === null || event === void 0 ? void 0 : event.params) === null || _a === void 0 ? void 0 : _a.data;
+            console.log(data);
+            if (data.collectionTypeData) {
+                await ((_b = strapi.entityService) === null || _b === void 0 ? void 0 : _b.update(data.collectionTypeData.__type, data.collectionTypeData.id, {
+                    data: {
+                        id: data.collectionTypeData.id,
+                        hasPage: true
+                    }
+                }));
+            }
+        },
+        async afterCreate(event) {
+            var _a, _b;
+            const data = (_a = event === null || event === void 0 ? void 0 : event.params) === null || _a === void 0 ? void 0 : _a.data;
+            if (data.collectionTypeData) {
+                await ((_b = strapi.entityService) === null || _b === void 0 ? void 0 : _b.update(data.collectionTypeData.__type, data.collectionTypeData.id, {
+                    data: {
+                        id: data.collectionTypeData.id,
+                        hasPage: true
+                    }
+                }));
+            }
+        },
+        async beforeDelete(event) {
+            var _a, _b;
+            const foundPage = await ((_a = strapi.entityService) === null || _a === void 0 ? void 0 : _a.findOne(constants_1.PAGE_UID, event.params.where.id, { populate: '*' }));
+            if (foundPage && foundPage.collectionTypeData) {
+                await ((_b = strapi.entityService) === null || _b === void 0 ? void 0 : _b.update(foundPage.collectionTypeData[0].__type, foundPage.collectionTypeData[0].id, {
+                    data: {
+                        id: foundPage.collectionTypeData[0].id,
+                        hasPage: false
+                    }
+                }));
+            }
+        },
+        async beforeDeleteMany(event) {
+            var _a, _b;
+            const pagesToUnConnect = event.params.where['$and'][0].id['$in'];
+            for (const pageId of pagesToUnConnect) {
+                const foundPage = await ((_a = strapi.entityService) === null || _a === void 0 ? void 0 : _a.findOne(constants_1.PAGE_UID, pageId, { populate: '*' }));
+                if (foundPage && foundPage.collectionTypeData) {
+                    await ((_b = strapi.entityService) === null || _b === void 0 ? void 0 : _b.update(foundPage.collectionTypeData[0].__type, foundPage.collectionTypeData[0].id, {
+                        data: {
+                            id: foundPage.collectionTypeData[0].id,
+                            hasPage: false
+                        }
+                    }));
+                }
             }
         }
     });

package/dist/server/controllers/collection-types.js

@@ -4,7 +4,6 @@ exports.default = {
     async hasPageRelation(ctx) {
         var _a;
         const uid = (_a = ctx.params) === null || _a === void 0 ? void 0 : _a.uid;
-        // @ts-ignore
         return strapi.service('plugin::page-builder.collection-types').hasPageRelation(uid);
     },
     async getTranslationPageLinks(ctx) {
@@ -13,7 +12,6 @@ exports.default = {
         if (!uid || (idsArr === null || idsArr === void 0 ? void 0 : idsArr.length) === 0) {
             return undefined;
         }
-        // @ts-ignore
         return strapi.service('plugin::page-builder.collection-types').getTranslationPageLinks(uid, idsArr);
     }
 };

package/dist/server/controllers/page-type.js

@@ -7,7 +7,6 @@ exports.default = {
         if (!uid) {
             return ctx.badRequest('uid is missing.');
         }
-        // @ts-ignore strapi typings
         return await strapi.service('plugin::page-builder.page-type').findOneByUid(uid);
     }
 };

package/dist/server/controllers/page.js

@@ -1,17 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("../../shared/utils/constants");
 exports.default = {
     async getPage(ctx) {
         var _a, _b;
         const id = (_a = ctx.params) === null || _a === void 0 ? void 0 : _a.id;
         return (_b = strapi.service('plugin::page-builder.page')) === null || _b === void 0 ? void 0 : _b.getPage(id);
-    },
-    async findOneBySlug(ctx) {
-        var _a;
-        const { slug = '' } = ctx.params;
-        const entity = await ((_a = strapi.service(constants_1.PAGE_UID)) === null || _a === void 0 ? void 0 : _a.find({ filters: { slug } }));
-        const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
-        return this.transformResponse(sanitizedEntity);
     }
 };

package/dist/server/controllers/platform.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    async findAll() {
+        return await strapi.service('plugin::page-builder.platform').findAll();
+    },
+    async findOneByUid(ctx) {
+        var _a;
+        const uid = (_a = ctx === null || ctx === void 0 ? void 0 : ctx.params) === null || _a === void 0 ? void 0 : _a.uid;
+        if (!uid) {
+            return ctx.badRequest('uid is missing.');
+        }
+        return await strapi.service('plugin::page-builder.platform').findOneByUid(uid);
+    },
+    async findPageTypesByPlatform(ctx) {
+        var _a;
+        const platform = (_a = ctx === null || ctx === void 0 ? void 0 : ctx.params) === null || _a === void 0 ? void 0 : _a.platform;
+        return await strapi.services['plugin::page-builder.platform'].findPageTypesByPlatform(platform);
+    }
+};

package/dist/server/controllers/template.js

@@ -7,11 +7,9 @@ exports.default = {
         if (!id) {
             return ctx.badRequest('id is missing.');
         }
-        // @ts-ignore strapi typings
         return await strapi.service('plugin::page-builder.template').findOne(id);
     },
     async findAll() {
-        // @ts-ignore strapi typings
         return await strapi.service('plugin::page-builder.template').findAll();
     }
 };

package/dist/server/graphql/index.js

@@ -5,7 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const page_type_1 = __importDefault(require("./page-type"));
 const page_by_slug_1 = __importDefault(require("./page-by-slug"));
+const pages_by_uid_1 = __importDefault(require("./pages-by-uid"));
 exports.default = {
+    getPageInfoFromUID: pages_by_uid_1.default,
     pageType: page_type_1.default,
     pageBySlug: page_by_slug_1.default
 };

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

@@ -27,17 +27,17 @@ const getPageBySlug = (strapi) => {
                         };
                         const { toEntityResponse } = strapi.plugin('graphql').service('format').returnTypes;
                         const getPage = async () => {
-                            var _a, _b;
+                            var _a, _b, _c;
                             const transformedArgs = transformArgs(filteredArgs, {
                                 contentType: strapi.contentTypes[constants_1.PAGE_UID],
                                 usePagination: false
                             });
-                            const results = await strapi.entityService.findMany(constants_1.PAGE_UID, {
+                            const results = await ((_a = strapi.entityService) === null || _a === void 0 ? void 0 : _a.findMany(constants_1.PAGE_UID, {
                                 filters: transformedArgs,
                                 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
@@ -45,7 +45,7 @@ const getPageBySlug = (strapi) => {
                             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 = (_b = (_a = entityResponse === null || entityResponse === void 0 ? void 0 : entityResponse.value) === null || _a === void 0 ? void 0 : _a.collectionTypeData) === null || _b === void 0 ? void 0 : _b.filter(Boolean);
+                            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

package/dist/server/graphql/pages-by-uid.js

@@ -0,0 +1,105 @@
+"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 paginationValidation_1 = require("../utils/paginationValidation");
+const getPageInfoFromUID = (strapi) => {
+    // @ts-ignore service does exist
+    const collectionTypes = strapi.service('plugin::page-builder.collection-types').withPageMorph();
+    const typeDefs = () => {
+        const metaInfo = `type MetaInfo {
+			total: Int
+			page: Int
+			pageCount: Int
+			pageSize: Int
+	}`;
+        const entityInfo = collectionTypes.map((collectionType) => {
+            return `
+				extend type ${collectionType.type}EntityResponseCollection {
+					metaInfo: MetaInfo
+				}
+
+        type Query {
+					get${collectionType.type}Pages(filters: ${collectionType.type}FiltersInput,pagination: PaginationArg, sort:[String], pageFilters: PageFiltersInput): ${collectionType.type}EntityResponseCollection
+        }
+
+      `;
+        });
+        return `${metaInfo} ${entityInfo}`;
+    };
+    const resolvers = (strapi) => {
+        const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
+        const pageQuery = collectionTypes.map((collectionType) => {
+            return {
+                [`get${collectionType.type}Pages`]: {
+                    resolve: async (_parent, args, ctx) => {
+                        var _a;
+                        if (!args.pagination || !args.pagination.page || !args.pagination.pageSize) {
+                            throw new Error('page and pageSize is required');
+                        }
+                        const { start, limit } = paginationValidation_1.Pagination.checkPagination(args.pagination.page, args.pagination.pageSize);
+                        const filteredArgs = {
+                            ...(0, filter_underscore_arguments_1.filterUnderscoreArguments)(args)
+                        };
+                        const pageFilters = { filters: args.pageFilters };
+                        const { toEntityResponseCollection } = strapi.plugin('graphql').service('format').returnTypes;
+                        const getPage = async () => {
+                            var _a;
+                            const transformedArgs = transformArgs(filteredArgs, {
+                                contentType: strapi.contentTypes[collectionType.uid],
+                                usePagination: true
+                            });
+                            const transformedpageArgs = transformArgs(pageFilters, {
+                                contentType: strapi.contentTypes[constants_1.PAGE_UID],
+                                usePagination: true
+                            });
+                            const results = await ((_a = strapi === null || strapi === void 0 ? void 0 : strapi.entityService) === null || _a === void 0 ? void 0 : _a.findMany(collectionType.uid, {
+                                populate: '*',
+                                filters: {
+                                    ...transformedArgs.filters,
+                                    hasPage: { $eq: true },
+                                    page: { ...transformedpageArgs.filters }
+                                },
+                                sort: transformedArgs.sort,
+                                start: start,
+                                limit: limit
+                            }));
+                            const entityResponse = toEntityResponseCollection(results || [], {
+                                args: transformedArgs,
+                                resourceUID: collectionType.uid
+                            });
+                            const entityResponsePaginated = paginationValidation_1.Pagination.getPaginationInfo(transformedpageArgs, transformedArgs, start, args.pagination.pageSize, entityResponse, collectionType.uid);
+                            return entityResponsePaginated;
+                        };
+                        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);
+                        }
+                    }
+                }
+            };
+        });
+        return {
+            Query: Object.assign({}, ...pageQuery)
+        };
+    };
+    const resolversConfig = () => {
+        const configQuery = collectionTypes.map((collectionType) => {
+            return {
+                [`Query.get${collectionType.type}Pages`]: {
+                    auth: false
+                }
+            };
+        });
+        return Object.assign({}, ...configQuery);
+    };
+    return {
+        typeDefs: typeDefs(),
+        resolvers: resolvers(strapi),
+        resolversConfig: resolversConfig()
+    };
+};
+exports.default = getPageInfoFromUID;