@webbio/strapi-plugin-page-builder 0.0.21 → 0.0.23

package/server/queries/page.ts

@@ -0,0 +1,101 @@
+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 {
+					collectionTypeId: String
+					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 id = PAGE_UID;
+
+							const transformedArgs = transformArgs(filteredArgs, {
+								contentType: strapi.contentTypes[id],
+								usePagination: false
+							});
+
+							const results = await strapi.entityService.findMany(id, {
+								filters: transformedArgs,
+								locale: args._locale,
+								publicationState: args._publicationState,
+								populate: '*'
+							});
+
+							const entityResponse = toEntityResponse(results[0], {
+								args: transformedArgs,
+								resourceUID: id
+							});
+
+							if (!entityResponse?.value) {
+								return undefined;
+							}
+
+							const collectionTypeDataFilter = entityResponse?.value?.collectionTypeData?.filter(Boolean);
+
+							const collectionType = collectionTypeDataFilter.length === 1 ? collectionTypeDataFilter?.[0] : null;
+
+							const addedAttributes = {
+								collectionType,
+								collectionTypeId: collectionType?.id || null
+							};
+
+							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/register.ts

@@ -1,5 +1,11 @@
 import { Strapi } from '@strapi/strapi';
 
+import getPageBySlug from './queries/page';
+
 export default async ({ strapi }: { strapi: Strapi }) => {
+	const extensionService = strapi.plugin('graphql').service('extension');
+
+	extensionService.use(getPageBySlug(strapi));
+
 	await strapi.services?.['plugin::page-builder.builder']?.buildContentTypes();
 };

package/server/schema/page-end.json

@@ -82,12 +82,6 @@
 			},
 			"component": "shared.seo"
 		},
-		"template": {
-			"relation": "manyToOne",
-			"target": "api::template.template",
-			"targetAttribute": "pages",
-			"type": "relation"
-		},
 		"pageType": {
 			"type": "relation",
 			"relation": "oneToOne",

package/server/services/builder.ts

@@ -1,5 +1,4 @@
 import partition from 'lodash/partition';
-import isEqual from 'lodash/isEqual';
 
 import { Service } from '@strapi/strapi/lib/types/core/common';
 
@@ -11,9 +10,7 @@ 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 templateEnd from '../schema/template-end.json';
 
-// We use template twice, see Readme for more info
 const UIDS = [TEMPLATE_UID, PAGE_TYPE_UID, PAGE_UID];
 
 export default {
@@ -70,12 +67,8 @@ export default {
 		}
 
 		if ((updateTypes || []).length > 0) {
-			for (const updateType of updateTypes) {
+			for await (const updateType of updateTypes) {
 				await ctb.editContentType(updateType.uid, { contentType: updateType.contentType, components: [] });
-
-				if (updateType.uid === PAGE_UID) {
-					strapi.reload();
-				}
 			}
 		}
 	},
@@ -90,7 +83,7 @@ export default {
 				update: this.getPageTypeContentType()
 			},
 			[TEMPLATE_UID]: {
-				create: this.getTemplateContentType(true),
+				create: this.getTemplateContentType(),
 				update: this.getTemplateContentType()
 			}
 		};
@@ -101,10 +94,6 @@ export default {
 		const page = create ? pageStart : pageEnd;
 		const contentType = this.mergeCollectionTypeWithModules(page, PAGE_UID);
 
-		if (this.collectionTypesAreEqual(contentType, TEMPLATE_UID)) {
-			return undefined;
-		}
-
 		return { uid: PAGE_UID, contentType };
 	},
 	getPageTypeContentType(create?: boolean) {
@@ -113,8 +102,8 @@ export default {
 
 		return { uid: PAGE_TYPE_UID, contentType };
 	},
-	getTemplateContentType(create?: boolean) {
-		const pageType = create ? templateStart : templateEnd;
+	getTemplateContentType() {
+		const pageType = templateStart;
 		const contentType = this.mergeCollectionTypeWithModules(pageType, TEMPLATE_UID);
 
 		return { uid: TEMPLATE_UID, contentType };
@@ -137,14 +126,6 @@ export default {
 			}
 		};
 	},
-	collectionTypesAreEqual(collectionType: Record<string, any>, uid: string) {
-		const { pluginOptions: oldPluginOptions, __schema__: oldSchema } = strapi.contentType(uid) || {};
-
-		return (
-			isEqual(oldSchema.attributes, collectionType?.attributes) &&
-			isEqual(oldPluginOptions, collectionType?.pluginOptions)
-		);
-	},
 	getConfigModuleComponents() {
 		return (strapi.config.get(`plugin.${pluginId}`)?.modules || []).filter(Boolean);
 	}

package/server/utils/filter-underscore-arguments.ts

@@ -0,0 +1,12 @@
+export const filterUnderscoreArguments = (args: Record<string, any>) => {
+	const newArgs = {};
+	const objectArray = Object.keys(args);
+
+	objectArray.forEach((key) => {
+		if (!key.startsWith('_')) {
+			newArgs[key] = args[key];
+		}
+	});
+
+	return newArgs;
+};