@webbio/strapi-plugin-page-builder 0.2.2 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webbio/strapi-plugin-page-builder",
-	"version": "0.2.2",
+	"version": "0.3.0",
 	"description": "This is the description of the plugin.",
 	"scripts": {
 		"develop": "tsc -p tsconfig.server.json -w",
@@ -21,14 +21,13 @@
 	},
 	"dependencies": {
 		"@strapi/design-system": "^1.11.0",
-		"@strapi/helper-plugin": "^4.13.6",
+		"@strapi/helper-plugin": "^4.15.0",
 		"@strapi/icons": "^1.11.0",
-		"@strapi/typescript-utils": "^4.13.6",
-		"@strapi/utils": "^4.13.6",
+		"@strapi/typescript-utils": "^4.15.0",
+		"@strapi/utils": "^4.15.0",
 		"react-select": "^5.7.4"
 	},
 	"devDependencies": {
-		"@strapi/typescript-utils": "^4.13.6",
 		"@types/react": "^18.2.21",
 		"@types/react-dom": "^18.2.7",
 		"@types/react-router-dom": "^5.3.3",
@@ -40,7 +39,7 @@
 		"typescript": "5.1.6"
 	},
 	"peerDependencies": {
-		"@strapi/strapi": "^4.13.6",
+		"@strapi/strapi": "^4.15.0",
 		"@webbio/strapi-plugin-slug": "^2.0.2",
 		"react": "^17.0.0 || ^18.0.0",
 		"react-dom": "^17.0.0 || ^18.0.0",

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

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

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 } from '../shared/utils/constants';
+import { PAGE_TYPE_UID, PAGE_UID, PLATFORM_UID } from '../shared/utils/constants';
 import permissions from './bootstrap/permissions';
 import collectionTypeLifecycles from './bootstrap/collection-type-lifecycles';
 
@@ -27,6 +27,7 @@ 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(
@@ -39,10 +40,26 @@ 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);
 			}
 		},
@@ -98,8 +115,6 @@ 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 &&

package/server/controllers/index.ts

@@ -2,10 +2,12 @@ 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
+	template,
+	platform
 };

package/server/controllers/platform.ts

@@ -0,0 +1,21 @@
+import { Strapi } from '@strapi/strapi';
+
+export default {
+	async findAll() {
+		return await (strapi as Strapi).service('plugin::page-builder.platform').findAll();
+	},
+
+	async findOneByUid(ctx: any) {
+		const uid = ctx?.params?.uid;
+
+		if (!uid) {
+			return ctx.badRequest('uid is missing.');
+		}
+
+		return await strapi.service('plugin::page-builder.platform').findOneByUid(uid);
+	},
+	async findPageTypesByPlatform(ctx: any) {
+		const platform = ctx?.params?.platform;
+		return await (strapi as Strapi).services['plugin::page-builder.platform'].findPageTypesByPlatform(platform);
+	}
+};

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

@@ -22,7 +22,7 @@ const getPageInfoFromUID = (strapi: Strapi) => {
 				}
 
         type Query {
-					get${collectionType.type}Pages(filters: ${collectionType.type}FiltersInput,pagination: PaginationArg, sort:[String], pageFilters: PageFiltersInput): ${collectionType.type}EntityResponseCollection
+					get${collectionType.type}Pages(filters: ${collectionType.type}FiltersInput,pagination: PaginationArg, pageFilters: PageFiltersInput): ${collectionType.type}EntityResponseCollection
         }
 
       `;
@@ -67,7 +67,6 @@ const getPageInfoFromUID = (strapi: Strapi) => {
 									hasPage: { $eq: true },
 									page: { ...transformedpageArgs.filters }
 								},
-								sort: transformedArgs.sort,
 								start: start,
 								limit: limit
 							});

package/server/routes/index.ts

@@ -52,6 +52,27 @@ 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,6 +86,11 @@
 			"type": "relation",
 			"relation": "oneToOne",
 			"target": "api::page-type.page-type"
+		},
+		"platform": {
+			"type": "relation",
+			"relation": "oneToOne",
+			"target": "api::platform.platform"
 		}
 	}
 }

package/server/schema/platform-start.json

@@ -0,0 +1,31 @@
+{
+	"draftAndPublish": false,
+	"displayName": "Platforms",
+	"singularName": "platform",
+	"pluralName": "platforms",
+	"description": "",
+	"plugin": "page-builder",
+	"pluginOptions": {},
+	"kind": "collectionType",
+	"collectionName": "platforms",
+	"attributes": {
+		"title": {
+			"type": "string",
+			"required": true,
+			"unique": true
+		},
+		"domain": {
+			"type": "string"
+		},
+		"template": {
+			"type": "relation",
+			"relation": "oneToMany",
+			"target": "api::template.template"
+		},
+		"pageTypes": {
+			"type": "relation",
+			"relation": "oneToMany",
+			"target": "api::page-type.page-type"
+		}
+	}
+}

package/server/services/builder.ts

@@ -4,13 +4,14 @@ 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 } from '../../shared/utils/constants';
+import { PAGE_UID, TEMPLATE_UID, PAGE_TYPE_UID, PLATFORM_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, PAGE_UID];
+const UIDS: Common.UID.ContentType[] = [TEMPLATE_UID, PAGE_TYPE_UID, PLATFORM_UID, PAGE_UID];
 
 export default {
 	async buildContentTypes() {
@@ -87,6 +88,10 @@ export default {
 			[TEMPLATE_UID]: {
 				create: this.getTemplateContentType(),
 				update: this.getTemplateContentType()
+			},
+			[PLATFORM_UID]: {
+				create: this.getPlatformContentType(),
+				update: this.getPlatformContentType()
 			}
 		};
 
@@ -94,25 +99,32 @@ export default {
 	},
 	getPageContentType(create?: boolean) {
 		const page = create ? pageStart : pageEnd;
-		const contentType = this.mergeCollectionTypeWithModules(page, PAGE_UID);
+		const contentType = this.mergeCollectionTypeWithOld(page, PAGE_UID);
 
 		return { uid: PAGE_UID, contentType };
 	},
 	getPageTypeContentType(create?: boolean) {
 		const pageType = create ? pageTypeStart : pageTypeEnd;
-		const contentType = this.mergeCollectionTypeWithModules(pageType, PAGE_TYPE_UID);
+		const contentType = this.mergeCollectionTypeWithOld(pageType, PAGE_TYPE_UID);
 
 		return { uid: PAGE_TYPE_UID, contentType };
 	},
 	getTemplateContentType() {
 		const template = templateStart;
-		const contentType = this.mergeCollectionTypeWithModules(template, TEMPLATE_UID);
+		const contentType = this.mergeCollectionTypeWithOld(template, TEMPLATE_UID);
 
 		return { uid: TEMPLATE_UID, contentType };
 	},
-	mergeCollectionTypeWithModules(collectionType: Record<string, any>, uid: Common.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) {
 		const { pluginOptions: oldPluginOptions, __schema__: oldSchema } = (strapi.contentType(uid) as any) || {};
-		const components = this.getConfigModuleComponents();
+		const modulesFromConfig = oldSchema.attributes.modules ? this.getConfigModuleComponents() : undefined;
 
 		return {
 			...collectionType,
@@ -124,7 +136,10 @@ export default {
 			attributes: {
 				...oldSchema?.attributes,
 				...collectionType.attributes,
-				modules: { ...collectionType.attributes.modules, components }
+				...(((collectionType.attributes.modules && collectionType.attributes.modules.length > 0) ||
+					modulesFromConfig) && {
+					modules: { ...collectionType.attributes.modules, components: modulesFromConfig }
+				})
 			}
 		};
 	},

package/server/services/index.ts

@@ -3,11 +3,13 @@ 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
+	template,
+	platform
 };

package/server/services/platform.ts

@@ -0,0 +1,36 @@
+import { Common } from '@strapi/strapi';
+import { PLATFORM_UID } from '../../shared/utils/constants';
+
+export default {
+	async findAll() {
+		return await strapi.entityService.findMany(PLATFORM_UID, { populate: '*' });
+	},
+	async findOneByUid(uid: Common.UID.ContentType) {
+		return await strapi.entityService.findMany(PLATFORM_UID, {
+			populate: '*',
+			filters: {
+				pagetype: {
+					uid
+				}
+			}
+		});
+	},
+	async findPageTypesByPlatform(platform: string) {
+		const results = await strapi.entityService.findMany(PLATFORM_UID, {
+			populate: {
+				pagetype: true
+			},
+			filters: {
+				title: {
+					$eq: platform
+				}
+			}
+		});
+
+		if ((results as any[]).length > 0) {
+			return results;
+		} else {
+			return null;
+		}
+	}
+};

package/shared/utils/constants.ts

@@ -1,4 +1,6 @@
 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/components/PageTypeFilter/index.tsx

@@ -1,17 +0,0 @@
-import React from 'react';
-import { useLocation } from 'react-router-dom';
-
-import { PageTypeFilter } from './page-type-filter';
-import { PAGE_UID } from '../../../../shared/utils/constants';
-
-const PageTypeFilterContainer = () => {
-	const { pathname } = useLocation();
-
-	if (pathname === `/content-manager/collectionType/${PAGE_UID}`) {
-		return <PageTypeFilter />;
-	}
-
-	return null;
-};
-
-export default PageTypeFilterContainer;

package/admin/src/components/PageTypeFilter/page-type-filter.tsx

@@ -1,130 +0,0 @@
-import React, { useEffect, useState } from 'react';
-import set from 'lodash/set';
-
-import { SingleSelectOption, SingleSelect } from '@strapi/design-system';
-import { useQueryParams } from '@strapi/helper-plugin';
-
-import { useGetPageTypes } from '../../api/page-type';
-import { PAGE_TYPE_NO_FILTER } from '../../constants';
-import { PAGE_TYPE_PAGE } from '../../../../shared/utils/constants';
-
-const PageTypeFilter = () => {
-	const [{ query }, setQuery] = useQueryParams();
-	const { data: pageTypes } = useGetPageTypes({});
-	const initialPageTypeUid = getInitialPageType(query, pageTypes);
-	const [selectedPageTypeUid, setSelectedPageTypeUid] = useState(initialPageTypeUid);
-
-	const removeFilters = () => {
-		const newAndFilters = query.filters?.$and?.filter(
-			(x?: Record<string, any>) => Object.keys(x || {})?.[0] !== 'pageType'
-		);
-		const filters = { ...query.filters, $and: newAndFilters };
-
-		if (newAndFilters && newAndFilters.length === 0) {
-			delete filters.$and;
-		}
-
-		setQuery({
-			page: 1,
-			filters
-		});
-	};
-
-	const handleFilterChange = (filters: Record<string, any>) => {
-		const currentFilters = query.filters?.$and ? query.filters : { ...query.filters, $and: [] }; // Make sure $and exists.
-		const pageTypeFilterIndex = currentFilters.$and.findIndex(
-			(x?: Record<string, any>) => Object.keys(x || {})?.[0] === 'pageType'
-		);
-
-		if (pageTypeFilterIndex > -1) {
-			set(currentFilters, `$and[${pageTypeFilterIndex}]`, filters); // If the pageType filter already exists, replace it
-		} else {
-			currentFilters.$and.push(filters);
-		}
-
-		setQuery({
-			page: 1,
-			filters: currentFilters
-		});
-	};
-
-	const handleSelect = (value: string) => {
-		setSelectedPageTypeUid(value);
-
-		if (value === 'all') {
-			removeFilters();
-			return;
-		}
-
-		if (value === PAGE_TYPE_PAGE) {
-			handleFilterChange(nullPageTypeQueryFilter);
-			return;
-		}
-
-		handleFilterChange(getPageTypeQueryFilter(value));
-	};
-
-	useEffect(() => {
-		setSelectedPageTypeUid(getInitialPageType(query, pageTypes));
-	}, [pageTypes]);
-
-	useEffect(() => {
-		if (!query?.filters) {
-			setSelectedPageTypeUid(null);
-		}
-	}, [query]);
-
-	return (
-		<SingleSelect placeholder="Select page type" onChange={handleSelect} size="S" value={selectedPageTypeUid}>
-			<SingleSelectOption key={PAGE_TYPE_NO_FILTER} value={PAGE_TYPE_NO_FILTER}>
-				All Pagetypes
-			</SingleSelectOption>
-			<SingleSelectOption key={PAGE_TYPE_PAGE} value={PAGE_TYPE_PAGE}>
-				Page
-			</SingleSelectOption>
-			{pageTypes?.map((pageType) => (
-				<SingleSelectOption key={pageType.uid} value={pageType.uid}>
-					{pageType.title || pageType.uid}
-				</SingleSelectOption>
-			))}
-		</SingleSelect>
-	);
-};
-
-export { PageTypeFilter };
-
-const getPageTypeQueryFilter = (pageType: string) => ({
-	pageType: {
-		uid: {
-			$eq: pageType
-		}
-	}
-});
-
-const nullPageTypeQueryFilter = {
-	pageType: {
-		uid: {
-			$null: true
-		}
-	}
-};
-
-const getInitialPageType = (query: any, pageTypes: any) => {
-	const pageTypeFromQuery = query?.filters?.$and?.find(
-		(x?: Record<string, any>) => Object.keys(x || {})?.[0] === 'pageType'
-	)?.pageType;
-
-	if (pageTypeFromQuery?.uid?.$null === 'true') {
-		return PAGE_TYPE_PAGE;
-	}
-
-	if (pageTypeFromQuery?.uid?.$eq) {
-		const matchingPageType = pageTypes?.find((pageType: any) => pageType?.uid === pageTypeFromQuery.uid.$eq);
-
-		if (matchingPageType) {
-			return matchingPageType.uid;
-		}
-	}
-
-	return PAGE_TYPE_NO_FILTER;
-};