@webbio/strapi-plugin-page-builder 0.3.2 → 0.3.4-platform

package/package.json

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

package/server/bootstrap/permissions.ts

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

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

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