@webbio/strapi-plugin-page-builder 0.3.3 → 0.3.4-legacy

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webbio/strapi-plugin-page-builder",
-	"version": "0.3.3",
+	"version": "0.3.4-legacy",
 	"description": "This is the description of the plugin.",
 	"scripts": {
 		"develop": "tsc -p tsconfig.server.json -w",
@@ -20,14 +20,16 @@
 		"url": "https://github.com/webbio/strapi-plugin-page-builder.git"
 	},
 	"dependencies": {
-		"@strapi/design-system": "^1.11.0",
-		"@strapi/helper-plugin": "^4.15.0",
-		"@strapi/icons": "^1.11.0",
-		"@strapi/typescript-utils": "^4.15.0",
-		"@strapi/utils": "^4.15.0",
-		"react-select": "^5.7.4"
+		"@strapi/design-system": "^1.19.0",
+		"@strapi/helper-plugin": "^4.25.22",
+		"@strapi/icons": "^1.19.0",
+		"@strapi/typescript-utils": "4.25.22",
+		"@strapi/utils": "4.25.22",
+		"react-select": "^5.7.4",
+		"slugify": "^1.6.6"
 	},
 	"devDependencies": {
+		"@strapi/typescript-utils": "4.25.22",
 		"@types/react": "^18.2.21",
 		"@types/react-dom": "^18.2.7",
 		"@types/react-router-dom": "^5.3.3",
@@ -39,8 +41,8 @@
 		"typescript": "5.1.6"
 	},
 	"peerDependencies": {
-		"@strapi/strapi": "^4.15.0",
-		"@webbio/strapi-plugin-slug": "^2.0.2",
+		"@strapi/strapi": "4.25.22",
+		"@webbio/strapi-plugin-slug": "^4.0.10",
 		"react": "^17.0.0 || ^18.0.0",
 		"react-dom": "^17.0.0 || ^18.0.0",
 		"react-router-dom": "^5.3.4",
@@ -59,7 +61,7 @@
 		}
 	],
 	"engines": {
-		"node": ">=14.19.1 <=18.x.x",
+		"node": ">=14.19.1 <=20.x.x",
 		"npm": ">=6.0.0"
 	},
 	"license": "MIT",

package/server/bootstrap/collection-type-lifecycles.ts

@@ -37,7 +37,7 @@ export default async ({ strapi }: { strapi: Strapi }) => {
 						data: {
 							updatedAt: data.updatedAt
 						}
-					} as Record<string, any>);
+					} as any);
 				}
 			} catch (error) {
 				console.log('[PAGEBUILDER PLUGIN] collection type lifecycle error: ', error);

package/server/bootstrap/permissions.ts

@@ -1,5 +1,5 @@
 import { Strapi } from '@strapi/strapi';
-import { PAGE_TYPE_UID, PLATFORM_UID } from '../../shared/utils/constants';
+import { PAGE_TYPE_UID } from '../../shared/utils/constants';
 
 export default async ({ strapi }: { strapi: Strapi }) => {
 	try {
@@ -7,84 +7,26 @@ export default async ({ strapi }: { strapi: Strapi }) => {
 			limit: -1
 		})) as Record<string, any>[];
 
-		const platforms = (await strapi.entityService?.findMany(PLATFORM_UID, {
-			limit: -1
-		})) as Record<string, any>[];
-
-		const platformPagePermissions = platforms.map((platform) => {
-			return pageTypes.map((pageType) => {
-				const name = `platform-is-${platform.title}-${pageType.uid}`;
-				const displayName = `${platform.title}-${pageType.title}`;
-
-				return {
-					plugin: 'page-builder',
-					name,
-					displayName,
-					category: `${platform.title} Page roles`,
-					handler: async () => {
-						return {
-							$and: [
-								{
-									'platform.id': {
-										$eq: platform.id
-									}
-								},
-								{
-									'pageType.uid': {
-										$eq: pageType.uid
-									}
-								},
-								{
-									uid: {
-										$eq: pageType.uid
-									}
-								}
-							]
-						};
-					}
-				};
-			});
-		});
-
-		const pageTypePermissions = pageTypes.map((pageType) => {
-			const name = `pageType-permission-${pageType.uid}`;
-			const displayName = `pageType ${pageType.title}`;
+		const pagePermissions = pageTypes.map((pageType) => {
+			const name = `page-type-is-${pageType.uid}`;
+			const displayName = pageType.title;
 
 			return {
 				plugin: 'page-builder',
 				name,
 				displayName,
-				category: `Platform pageType roles`,
-				handler: async () => {
-					return {
-						uid: {
-							$eq: pageType.uid
-						}
-					};
-				}
-			};
-		});
-
-		const platformCollectiontypePermissions = platforms.map((platform) => {
-			const name = `platform-is-${platform.title}`;
-			const displayName = platform.title;
-
-			return {
-				plugin: 'page-builder',
-				name,
-				displayName,
-				category: 'Platform CollectionType roles',
+				category: 'Page type',
 				handler: async () => {
 					return {
 						$or: [
 							{
-								'platform.id': {
-									$eq: platform.id
+								'pageType.uid': {
+									$eq: pageType.uid
 								}
 							},
 							{
-								id: {
-									$eq: platform.id
+								uid: {
+									$eq: pageType.uid
 								}
 							}
 						]
@@ -92,15 +34,8 @@ export default async ({ strapi }: { strapi: Strapi }) => {
 				}
 			};
 		});
-
-		const allPermissions = [
-			...platformPagePermissions.flat(),
-			...pageTypePermissions.flat(),
-			...platformCollectiontypePermissions
-		];
-
 		// @ts-ignore shitty types
-		await strapi.admin.services.permission.conditionProvider.registerMany(allPermissions);
+		await strapi.admin.services.permission.conditionProvider.registerMany(pagePermissions);
 	} catch {
 		console.log('Cannot set page permissions');
 	}

package/server/bootstrap.ts

@@ -1,6 +1,6 @@
 import { Common, Strapi } from '@strapi/strapi';
 import { errors } from '@strapi/utils';
-import { PAGE_TYPE_UID, PAGE_UID, PLATFORM_UID } from '../shared/utils/constants';
+import { PAGE_TYPE_UID, PAGE_UID } from '../shared/utils/constants';
 import permissions from './bootstrap/permissions';
 import collectionTypeLifecycles from './bootstrap/collection-type-lifecycles';
 
@@ -27,7 +27,6 @@ export default async ({ strapi }: { strapi: Strapi }) => {
 			let { data } = event.params;
 			const collectionTypeId = data?.collectionTypeId;
 			const pageTypeId = data?.pageType.connect?.[0]?.id || data.initialPageType;
-			const platformId = data?.platform.connect?.[0]?.id;
 
 			if (collectionTypeId && pageTypeId) {
 				const pageType: Record<string, any> | undefined | null = await strapi.entityService?.findOne(
@@ -40,26 +39,10 @@ export default async ({ strapi }: { strapi: Strapi }) => {
 
 				const page: Record<string, any>[] = collectionToConnect?.page as any;
 
-				const foundPlatforms: Record<string, any> | undefined | null = await strapi.entityService?.findMany(
-					PLATFORM_UID,
-					{
-						populate: '*',
-						filters: {
-							pagetype: {
-								uid: pageType?.uid
-							}
-						}
-					}
-				);
-
 				if (page && page.length > 0) {
 					throw new errors.ValidationError('You can only link one CollectionType to one page');
 				}
 
-				if (platformId && !foundPlatforms?.some((platform) => platform.id === platformId)) {
-					throw new errors.ValidationError('Platform not found');
-				}
-
 				data = updateCollectionTypeData(data, collectionTypeId, pageType?.uid);
 			}
 		},
@@ -115,6 +98,8 @@ export default async ({ strapi }: { strapi: Strapi }) => {
 				data = updateCollectionTypeData(data, collectionTypeId, pageType?.uid);
 			}
 
+			// needs to check if the collectionTypeData is already connected to another page
+			// if so, remove the hasPage for filtering
 			if (
 				data.collectionTypeData &&
 				originalEntity?.collectionTypeData?.[0]?.__type &&
@@ -137,32 +122,28 @@ export default async ({ strapi }: { strapi: Strapi }) => {
 			}
 		},
 		async afterUpdate(event) {
-			const data = event?.params?.data;
-
-			if (data.collectionTypeData?.__type && data.collectionTypeData.id) {
-				await strapi.entityService?.update(data.collectionTypeData.__type, data.collectionTypeData.id, {
-					data: {
-						id: data.collectionTypeData.id,
-						hasPage: true,
-						lifecycleState: {
-							exit: true
-						}
-					}
-				});
-			}
-		},
-		async afterCreate(event) {
-			const data = event?.params?.data;
-			if (data.collectionTypeData?.__type && data.collectionTypeData.id) {
-				await strapi.entityService?.update(data.collectionTypeData.__type, data.collectionTypeData.id, {
-					data: {
-						id: data.collectionTypeData.id,
-						hasPage: true,
-						lifecycleState: {
-							exit: true
+			try {
+				// Result not correctly typed within Strapi
+				const data = event?.['result'];
+				const hasCollectionTypeRelation =
+					data && data?.collectionTypeData?.[0] && data?.collectionTypeData[0].__type && data?.collectionTypeData[0].id;
+
+				if (hasCollectionTypeRelation) {
+					const isPublished = data.publishedAt !== undefined;
+					const pageData = isPublished ? { hasPage: !!data.publishedAt } : {};
+
+					await strapi.entityService?.update(data.collectionTypeData[0].__type, data.collectionTypeData[0].id, {
+						data: {
+							...pageData,
+							id: data.collectionTypeData[0].id,
+							lifecycleState: {
+								exit: true
+							}
 						}
-					}
-				});
+					});
+				}
+			} catch (error) {
+				console.error('Failed to save hasPage data', error);
 			}
 		},
 		async beforeDelete(event) {

package/server/controllers/index.ts

@@ -2,12 +2,10 @@ import page from './page';
 import pageType from './page-type';
 import collectionTypes from './collection-types';
 import template from './template';
-import platform from './platform';
 
 export default {
 	page,
 	'page-type': pageType,
 	'collection-types': collectionTypes,
-	template,
-	platform
+	template
 };

package/server/graphql/page-by-slug.ts

@@ -11,7 +11,7 @@ const getPageBySlug = (strapi: Strapi) => {
 				}
 
         type Query {
-          getPageBySlug(path: String, _domain: String, _locale: String, _publicationState: PublicationState): PageEntity
+          getPageBySlug(path: String, _locale: String, _publicationState: PublicationState): PageEntity
         }
 
       `;
@@ -24,63 +24,56 @@ const getPageBySlug = (strapi: Strapi) => {
 			Query: {
 				getPageBySlug: {
 					resolve: async (_parent: any, args: Record<string, any>, ctx: any) => {
-						try {
-							const filteredArgs = {
-								...filterUnderscoreArguments(args),
-								platform: { domain: args._domain }
-							};
-
-							const { toEntityResponse } = strapi.plugin('graphql').service('format').returnTypes;
-
-							const getPage = async () => {
-								const transformedArgs = transformArgs(filteredArgs, {
-									contentType: strapi.contentTypes[PAGE_UID],
-									usePagination: false
-								});
-
-								const results = await strapi.entityService?.findMany(PAGE_UID, {
-									filters: filteredArgs,
-									locale: args._locale,
-									publicationState: args._publicationState,
-									populate: '*'
-								});
-
-								const entityResponse = toEntityResponse(results?.[0] || {}, {
-									args: transformedArgs,
-									resourceUID: PAGE_UID
-								});
-
-								if (!entityResponse?.value || Object.keys(entityResponse.value).length === 0) {
-									throw new Error(ctx.koaContext.response.message);
-								}
-
-								const collectionTypeDataFilter = entityResponse?.value?.collectionTypeData?.filter(Boolean);
+						const filteredArgs = {
+							...filterUnderscoreArguments(args)
+						};
+
+						const { toEntityResponse } = strapi.plugin('graphql').service('format').returnTypes;
+
+						const getPage = async () => {
+							const transformedArgs = transformArgs(filteredArgs, {
+								contentType: strapi.contentTypes[PAGE_UID],
+								usePagination: false
+							});
+
+							const results = await strapi.entityService?.findMany(PAGE_UID, {
+								filters: transformedArgs,
+								locale: args._locale,
+								publicationState: args._publicationState,
+								populate: '*'
+							});
+
+							const entityResponse = toEntityResponse(results?.[0] || {}, {
+								args: transformedArgs,
+								resourceUID: PAGE_UID
+							});
+
+							if (!entityResponse?.value || Object.keys(entityResponse.value).length === 0) {
+								throw new Error(ctx.koaContext.response.message);
+							}
 
-								const collectionType: Record<string, any> | null =
-									collectionTypeDataFilter.length === 1 ? collectionTypeDataFilter?.[0] : null;
+							const collectionTypeDataFilter = entityResponse?.value?.collectionTypeData?.filter(Boolean);
 
-								const addedAttributes = {
-									collectionType: collectionType
-								};
+							const collectionType: Record<string, any> | null =
+								collectionTypeDataFilter.length === 1 ? collectionTypeDataFilter?.[0] : null;
 
-								const result = {
-									...entityResponse.value,
-									...addedAttributes
-								};
+							const addedAttributes = {
+								collectionType: collectionType
+							};
 
-								return result;
+							const result = {
+								...entityResponse.value,
+								...addedAttributes
 							};
 
-							const results: Record<string, any> = await getPage();
+							return result;
+						};
 
-							if (Object.values(results)?.filter(Boolean).length > 0) {
-								return results;
-							} else {
-								throw new Error(ctx.koaContext.response.message);
-							}
-						} catch (error) {
-							console.log('Error in getPageBySlug:', error);
+						const results: Record<string, any> = await getPage();
 
+						if (Object.values(results)?.filter(Boolean).length > 0) {
+							return results;
+						} else {
 							throw new Error(ctx.koaContext.response.message);
 						}
 					}

package/server/graphql/pages-by-uid.ts

@@ -16,16 +16,13 @@ const getPageInfoFromUID = (strapi: Strapi) => {
 			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, pageFilters: PageFiltersInput): ${collectionType.type}EntityResponseCollection
-        }
+			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}`;
@@ -67,6 +64,7 @@ const getPageInfoFromUID = (strapi: Strapi) => {
 									hasPage: { $eq: true },
 									page: { ...transformedpageArgs.filters }
 								},
+								sort: transformedArgs.sort,
 								start: start,
 								limit: limit
 							});

package/server/routes/index.ts

@@ -52,27 +52,6 @@ const routes = {
 				handler: 'template.findOneById'
 			}
 		]
-	},
-	platform: {
-		type: 'admin',
-		prefix: undefined,
-		routes: [
-			{
-				method: 'GET',
-				path: '/platform',
-				handler: 'platform.findAll'
-			},
-			{
-				method: 'GET',
-				path: '/platform/:uid',
-				handler: 'platform.findOneByUid'
-			},
-			{
-				method: 'GET',
-				path: '/platform/:platform/page-types',
-				handler: 'platform.findPageTypesByPlatform'
-			}
-		]
 	}
 };
 

package/server/schema/page-end.json

@@ -86,11 +86,6 @@
 			"type": "relation",
 			"relation": "oneToOne",
 			"target": "api::page-type.page-type"
-		},
-		"platform": {
-			"type": "relation",
-			"relation": "oneToOne",
-			"target": "api::platform.platform"
 		}
 	}
 }

package/server/services/builder.ts

@@ -4,14 +4,13 @@ import { Common } from '@strapi/strapi';
 import pageStart from '../schema/page-start.json';
 import pageEnd from '../schema/page-end.json';
 import pluginId from '../../admin/src/pluginId';
-import { PAGE_UID, TEMPLATE_UID, PAGE_TYPE_UID, PLATFORM_UID } from '../../shared/utils/constants';
+import { PAGE_UID, TEMPLATE_UID, PAGE_TYPE_UID } from '../../shared/utils/constants';
 import { reloadStrapiOnLoad } from '../utils/reload-strapi-on-load';
 import pageTypeStart from '../schema/page-type-start.json';
 import pageTypeEnd from '../schema/page-type-end.json';
 import templateStart from '../schema/template-start.json';
-import platformStart from '../schema/platform-start.json';
 
-const UIDS: Common.UID.ContentType[] = [TEMPLATE_UID, PAGE_TYPE_UID, PLATFORM_UID, PAGE_UID];
+const UIDS: Common.UID.ContentType[] = [TEMPLATE_UID, PAGE_TYPE_UID, PAGE_UID];
 
 export default {
 	async buildContentTypes() {
@@ -88,10 +87,6 @@ export default {
 			[TEMPLATE_UID]: {
 				create: this.getTemplateContentType(),
 				update: this.getTemplateContentType()
-			},
-			[PLATFORM_UID]: {
-				create: this.getPlatformContentType(),
-				update: this.getPlatformContentType()
 			}
 		};
 
@@ -99,30 +94,23 @@ export default {
 	},
 	getPageContentType(create?: boolean) {
 		const page = create ? pageStart : pageEnd;
-		const contentType = this.mergeCollectionTypeWithOld(page, PAGE_UID);
+		const contentType = this.mergeCollectionTypeWithModules(page, PAGE_UID);
 
 		return { uid: PAGE_UID, contentType };
 	},
 	getPageTypeContentType(create?: boolean) {
 		const pageType = create ? pageTypeStart : pageTypeEnd;
-		const contentType = this.mergeCollectionTypeWithOld(pageType, PAGE_TYPE_UID);
+		const contentType = this.mergeCollectionTypeWithModules(pageType, PAGE_TYPE_UID);
 
 		return { uid: PAGE_TYPE_UID, contentType };
 	},
 	getTemplateContentType() {
 		const template = templateStart;
-		const contentType = this.mergeCollectionTypeWithOld(template, TEMPLATE_UID);
+		const contentType = this.mergeCollectionTypeWithModules(template, TEMPLATE_UID);
 
 		return { uid: TEMPLATE_UID, contentType };
 	},
-	getPlatformContentType() {
-		const platform = platformStart;
-
-		const contentType = this.mergeCollectionTypeWithOld(platform, PLATFORM_UID);
-
-		return { uid: PLATFORM_UID, contentType };
-	},
-	mergeCollectionTypeWithOld(collectionType: Record<string, any>, uid: Common.UID.ContentType) {
+	mergeCollectionTypeWithModules(collectionType: Record<string, any>, uid: Common.UID.ContentType) {
 		const { pluginOptions: oldPluginOptions, __schema__: oldSchema } = (strapi.contentType(uid) as any) || {};
 		const modulesFromConfig = oldSchema?.attributes?.modules ? this.getConfigModuleComponents() : undefined;
 

package/server/services/index.ts

@@ -3,13 +3,11 @@ import builder from './builder';
 import pageType from './page-type';
 import collectionTypes from './collection-types';
 import template from './template';
-import platform from './platform';
 
 export default {
 	page,
 	builder,
 	'page-type': pageType,
 	'collection-types': collectionTypes,
-	template,
-	platform
+	template
 };

package/server/services/template.ts

@@ -8,7 +8,6 @@ export default {
 		return foundTemplates;
 	},
 	async findOne(id: number) {
-		const getpopulatedTemplate = getPopulatedEntity(TEMPLATE_UID, id);
-		return getpopulatedTemplate;
+		return await getPopulatedEntity(TEMPLATE_UID, id);
 	}
 };

package/server/utils/strapi.ts

@@ -14,17 +14,13 @@ export const getDeepPopulate = (uid: Common.UID.Component, populate?: any, depth
 	return Object.keys(attributes).reduce((populateAcc, attributeName) => {
 		const attribute = attributes[attributeName];
 
-		if (attribute.type === 'relation') {
-			return populateAcc;
-		}
-
 		if (attribute.type === 'component') {
 			populateAcc[attributeName] = {
 				populate: getDeepPopulate(attribute.component, null, depth + 1)
 			};
 		}
 
-		if (attribute.type === 'media') {
+		if (attribute.type === 'relation' || attribute.type === 'media') {
 			populateAcc[attributeName] = true;
 		}
 

package/shared/utils/constants.ts

@@ -1,6 +1,4 @@
 export const PAGE_UID = 'api::page.page';
 export const TEMPLATE_UID = 'api::template.template';
 export const PAGE_TYPE_UID = 'api::page-type.page-type';
-export const PLATFORM_UID = 'api::platform.platform';
 export const PAGE_TYPE_PAGE = 'page';
-export const PLATFORM = 'platform';

package/admin/src/api/platform.ts

@@ -1,34 +0,0 @@
-import { useQuery } from 'react-query';
-
-import { useFetchClient } from '@strapi/helper-plugin';
-
-import getRequestUrl from '../utils/getRequestUrl';
-import { PageType } from './page-type';
-
-export type Platform = {
-	id: number;
-	title?: string;
-	pageTypes?: PageType[];
-};
-
-const QUERY_KEY = 'platforms';
-
-const fetchPlatforms = async ({ fetchClient }: any): Promise<Platform[]> => {
-	const { get } = fetchClient;
-	const result = await get('/content-manager/collection-types/api::platform.platform');
-
-	return result?.data?.results.map((entity: any) => ({
-		id: entity.id,
-		title: entity.title,
-		pageTypes: entity.pageTypes
-	}));
-};
-
-export const useGetPlatforms = (params: any) => {
-	const fetchClient = useFetchClient();
-	params = {
-		...params,
-		fetchClient
-	};
-	return useQuery<Platform[], Error>(QUERY_KEY, () => fetchPlatforms(params));
-};

package/admin/src/components/EditView/Platform/platform-select.tsx

@@ -1,30 +0,0 @@
-import React from 'react';
-
-import { SingleSelect, SingleSelectOption } from '@strapi/design-system';
-
-import { Platform } from '../../../api/platform';
-import { PLATFORM } from '../../../../../shared/utils/constants';
-
-interface Props {
-	onChange: (platformId: string) => void;
-	selectedPlatform?: Platform | null;
-	platforms?: Platform[];
-}
-
-export const PlatformSelect = ({ onChange, platforms, selectedPlatform }: Props) => {
-	return (
-		<SingleSelect
-			label="Platform"
-			placeholder="Choose a platform"
-			value={selectedPlatform?.id || PLATFORM}
-			onChange={onChange}
-		>
-			<SingleSelectOption value={PLATFORM}>Platform</SingleSelectOption>
-			{platforms?.map((pageType: Platform) => (
-				<SingleSelectOption key={pageType?.id} value={pageType?.id}>
-					{pageType?.title}
-				</SingleSelectOption>
-			))}
-		</SingleSelect>
-	);
-};