@webbio/strapi-plugin-page-builder 0.3.8-platform → 0.3.9-legacy

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webbio/strapi-plugin-page-builder",
-	"version": "0.3.8-platform",
+	"version": "0.3.9-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.5",
+		"@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';
 
@@ -26,8 +26,7 @@ export default async ({ strapi }: { strapi: Strapi }) => {
 		async beforeCreate(event) {
 			let { data } = event.params;
 			const collectionTypeId = data?.collectionTypeId;
-			const pageTypeId = data?.pageType.connect?.[0]?.id || data.initialPageType;
-			const platformId = data?.platform.connect?.[0]?.id;
+			const pageTypeId = data?.pageType?.connect?.[0]?.id || data.initialPageType;
 
 			if (collectionTypeId && pageTypeId) {
 				const pageType: Record<string, any> | undefined | null = await strapi.entityService?.findOne(
@@ -40,24 +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');
+				// Only block if a page with the same locale already exists
+				const existingPageWithSameLocale = page?.find((p: any) => p.locale === data.locale);
+				if (existingPageWithSameLocale) {
+					throw new errors.ValidationError('A page with this locale is already linked to this collection type');
 				}
 
 				data = updateCollectionTypeData(data, collectionTypeId, pageType?.uid);
@@ -89,7 +74,7 @@ export default async ({ strapi }: { strapi: Strapi }) => {
 						originalEntity.collectionTypeData[0].id,
 						{
 							data: {
-								id: originalEntity.collectionTypeData.id,
+								id: originalEntity.collectionTypeData[0].id,
 								hasPage: false
 							}
 						}
@@ -108,13 +93,18 @@ export default async ({ strapi }: { strapi: Strapi }) => {
 
 				const page: Record<string, any>[] = collectionToConnect?.page as any;
 
-				if (page && page?.length > 0 && !page.some((p) => p.id === data.id)) {
-					throw new errors.ValidationError('You can only link one CollectionType to one page');
+				const existingPageWithSameLocale = page?.find(
+					(p: any) => p.locale === data.locale && p.id !== data.id && p.id !== where?.id
+				);
+				if (existingPageWithSameLocale) {
+					throw new errors.ValidationError('A page with this locale is already linked to this collection type');
 				}
 
 				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 +127,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/collection-types.ts

@@ -6,11 +6,6 @@ export default {
 
 		return (strapi as Strapi).service('plugin::page-builder.collection-types').hasPageRelation(uid);
 	},
-	async hasPlatformRelation(ctx: any) {
-		const uid = ctx.params?.uid;
-
-		return (strapi as Strapi).service('plugin::page-builder.collection-types').hasPlatformRelation(uid);
-	},
 	async getTranslationPageLinks(ctx: any): Promise<IGetTranslationPageLinks[] | undefined> {
 		const { uid, ids } = ctx.params || {};
 		const idsArr = (ids as string)

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/controllers/page.ts

@@ -1,9 +1,32 @@
 import { Strapi } from '@strapi/strapi';
 
+import { PAGE_UID } from '../../shared/utils/constants';
+
 export default {
 	async getPage(ctx) {
 		const id = ctx.params?.id;
 
 		return (strapi as Strapi).service('plugin::page-builder.page')?.getPage(id);
+	},
+
+	async createPage(ctx) {
+		const { title, slug, locale, pageTypeId, collectionTypeId, modules } = ctx.request.body;
+
+		if (!locale) {
+			return ctx.badRequest('Locale is required');
+		}
+
+		const page = await (strapi as Strapi).entityService?.create(PAGE_UID, {
+			data: {
+				title,
+				slug,
+				locale,
+				modules: modules || [],
+				collectionTypeId,
+				pageType: pageTypeId ? { connect: [{ id: pageTypeId }] } : undefined
+			}
+		});
+
+		return page;
 	}
 };

package/server/graphql/index.ts

@@ -1,9 +1,9 @@
 import pageType from './page-type';
-import pageByPath from './page-by-path';
+import pageBySlug from './page-by-slug';
 import getPageInfoFromUID from './pages-by-uid';
 
 export default {
 	getPageInfoFromUID,
 	pageType,
-	pageByPath
+	pageBySlug
 };

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

@@ -0,0 +1,113 @@
+import { Strapi } from '@strapi/strapi';
+
+import { filterUnderscoreArguments } from '../utils/filter-underscore-arguments';
+import { PAGE_UID } from '../../shared/utils/constants';
+
+const getPageBySlug = (strapi: Strapi) => {
+	const typeDefs = () => {
+		return `
+				extend type Page {
+					collectionType: GenericMorph
+				}
+
+        type Query {
+          getPageBySlug(path: String, _locale: String, _publicationState: PublicationState): PageEntity
+        }
+
+      `;
+	};
+
+	const resolvers = (strapi: Strapi) => {
+		const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
+
+		return {
+			Query: {
+				getPageBySlug: {
+					resolve: async (_parent: any, args: Record<string, any>, ctx: any) => {
+						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);
+							}
+
+							// Get collectionTypeData from the entity response
+							const collectionTypeData = entityResponse?.value?.collectionTypeData;
+
+							// Filter out null/undefined items
+							const collectionTypeDataFilter = collectionTypeData?.filter(Boolean);
+
+							// Filter by locale if specified, then take the first item
+							let filteredByLocale = collectionTypeDataFilter;
+							if (args._locale && Array.isArray(collectionTypeDataFilter)) {
+								filteredByLocale = collectionTypeDataFilter.filter((item: any) => {
+									return item?.locale === args._locale;
+								});
+							}
+
+							// Take the first item (should be only one after locale filtering)
+							const collectionType: Record<string, any> | null =
+								filteredByLocale && Array.isArray(filteredByLocale) && filteredByLocale.length > 0
+									? filteredByLocale[0]
+									: null;
+
+							const addedAttributes = {
+								collectionType: collectionType
+							};
+
+							const result = {
+								...entityResponse.value,
+								...addedAttributes
+							};
+
+							return result;
+						};
+
+						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);
+						}
+					}
+				}
+			}
+		};
+	};
+
+	const resolversConfig = {
+		'Query.getPageBySlug': {
+			auth: false
+		}
+	};
+
+	return {
+		typeDefs: typeDefs(),
+		resolvers: resolvers(strapi),
+		resolversConfig
+	};
+};
+
+export default getPageBySlug;

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,8 +64,9 @@ const getPageInfoFromUID = (strapi: Strapi) => {
 									hasPage: { $eq: true },
 									page: { ...transformedpageArgs.filters }
 								},
-								start,
-								limit
+								sort: transformedArgs.sort,
+								start: start,
+								limit: limit
 							});
 
 							const entityResponse = toEntityResponseCollection(results || [], {

package/server/register.ts

@@ -1,6 +1,6 @@
 import { Strapi } from '@strapi/strapi';
 
-import getPageByPath from './graphql/page-by-path';
+import getPageBySlug from './graphql/page-by-slug';
 import pageType from './graphql/page-type';
 import getPageInfoFromUID from './graphql/pages-by-uid';
 
@@ -8,7 +8,7 @@ export default async ({ strapi }: { strapi: Strapi }) => {
 	const extensionService = strapi.plugin('graphql').service('extension');
 
 	extensionService.use(pageType);
-	extensionService.use(getPageByPath(strapi));
+	extensionService.use(getPageBySlug(strapi));
 	extensionService.use(getPageInfoFromUID(strapi));
 
 	await strapi.services?.['plugin::page-builder.builder']?.buildContentTypes();

package/server/routes/index.ts

@@ -18,6 +18,11 @@ const routes = {
 				method: 'GET',
 				path: '/page/:id',
 				handler: 'page.getPage'
+			},
+			{
+				method: 'POST',
+				path: '/page/create',
+				handler: 'page.createPage'
 			}
 		]
 	},
@@ -34,11 +39,6 @@ const routes = {
 				method: 'GET',
 				path: '/collection-types-page-links/:uid/:ids?',
 				handler: 'collection-types.getTranslationPageLinks'
-			},
-			{
-				method: 'GET',
-				path: '/collection-types/hasPlatform/:uid',
-				handler: 'collection-types.hasPlatformRelation'
 			}
 		]
 	},
@@ -57,27 +57,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;