@webbio/strapi-plugin-page-builder 0.0.1

package/server/index.ts

@@ -0,0 +1,23 @@
+import register from './register';
+import bootstrap from './bootstrap';
+import destroy from './destroy';
+import config from './config';
+import contentTypes from './content-types';
+import controllers from './controllers';
+import routes from './routes';
+import middlewares from './middlewares';
+import policies from './policies';
+import services from './services';
+
+export default {
+	register,
+	bootstrap,
+	destroy,
+	config,
+	controllers,
+	routes,
+	services,
+	contentTypes,
+	policies,
+	middlewares
+};

package/server/middlewares/index.ts

@@ -0,0 +1 @@
+export default {};

package/server/policies/index.ts

@@ -0,0 +1 @@
+export default {};

package/server/register.ts

@@ -0,0 +1,5 @@
+import { Strapi } from '@strapi/strapi';
+
+export default async ({ strapi }: { strapi: Strapi }) => {
+	await strapi.services?.['plugin::page-builder.builder']?.buildContentTypes();
+};

package/server/routes/index.ts

@@ -0,0 +1,42 @@
+const routes = {
+	'page-type': {
+		type: 'admin',
+		prefix: undefined,
+		routes: [
+			{
+				method: 'GET',
+				path: '/page-types/:uid',
+				handler: 'page-type.findOneByUid'
+			}
+		]
+	},
+	page: {
+		type: 'admin',
+		prefix: undefined,
+		routes: [
+			{
+				method: 'GET',
+				path: '/page/:id',
+				handler: 'page.getPage'
+			}
+		]
+	},
+	'collection-types': {
+		type: 'admin',
+		prefix: undefined,
+		routes: [
+			{
+				method: 'GET',
+				path: '/collection-types/:uid',
+				handler: 'collection-types.hasPageRelation'
+			},
+			{
+				method: 'GET',
+				path: '/collection-types-page-links/:uid/:ids?',
+				handler: 'collection-types.getTranslationPageLinks'
+			}
+		]
+	}
+};
+
+export default routes;

package/server/schema/page-end.json

@@ -0,0 +1,97 @@
+{
+	"draftAndPublish": true,
+	"displayName": "Pagina's",
+	"singularName": "page",
+	"pluralName": "pages",
+	"description": "",
+	"plugin": "page-builder",
+	"pluginOptions": {
+		"i18n": {
+			"localized": true
+		}
+	},
+	"kind": "collectionType",
+	"collectionName": "pages",
+	"attributes": {
+		"collectionTypeData": {
+			"type": "relation",
+			"relation": "morphToMany",
+			"configurable": false
+		},
+		"title": {
+			"pluginOptions": {
+				"i18n": {
+					"localized": true
+				}
+			},
+			"type": "string",
+			"required": true
+		},
+		"slug": {
+			"pluginOptions": {
+				"i18n": {
+					"localized": true
+				},
+				"slug": {
+					"field": "slug",
+					"targetField": "title"
+				}
+			},
+			"type": "customField",
+			"customField": "plugin::slug.slug",
+			"required": true
+		},
+		"path": {
+			"pluginOptions": {
+				"i18n": {
+					"localized": true
+				}
+			},
+			"type": "string",
+			"required": false
+		},
+		"parent": {
+			"type": "relation",
+			"relation": "oneToOne",
+			"target": "api::page.page",
+			"private": false
+		},
+		"excerpt": {
+			"pluginOptions": {
+				"i18n": {
+					"localized": true
+				}
+			},
+			"type": "text"
+		},
+		"modules": {
+			"pluginOptions": {
+				"i18n": {
+					"localized": true
+				}
+			},
+			"type": "dynamiczone",
+			"components": []
+		},
+		"seo": {
+			"type": "component",
+			"pluginOptions": {
+				"i18n": {
+					"localized": true
+				}
+			},
+			"component": "shared.seo"
+		},
+		"template": {
+			"relation": "manyToOne",
+			"target": "api::template.template",
+			"targetAttribute": "pages",
+			"type": "relation"
+		},
+		"pageType": {
+			"type": "relation",
+			"relation": "oneToOne",
+			"target": "api::page-type.page-type"
+		}
+	}
+}

package/server/schema/page-start.json

@@ -0,0 +1,87 @@
+{
+	"draftAndPublish": true,
+	"displayName": "Pagina's",
+	"singularName": "page",
+	"pluralName": "pages",
+	"description": "",
+	"plugin": "page-builder",
+	"pluginOptions": {
+		"i18n": {
+			"localized": true
+		}
+	},
+	"kind": "collectionType",
+	"collectionName": "pages",
+	"attributes": {
+		"collectionTypeData": {
+			"type": "relation",
+			"relation": "morphToMany",
+			"configurable": false,
+			"private": false
+		},
+		"title": {
+			"pluginOptions": {
+				"i18n": {
+					"localized": true
+				}
+			},
+			"type": "string",
+			"required": true
+		},
+		"slug": {
+			"pluginOptions": {
+				"i18n": {
+					"localized": true
+				},
+				"slug": {
+					"field": "slug",
+					"targetField": "title"
+				}
+			},
+			"type": "customField",
+			"customField": "plugin::slug.slug",
+			"required": true
+		},
+		"path": {
+			"pluginOptions": {
+				"i18n": {
+					"localized": true
+				}
+			},
+			"type": "string",
+			"required": false
+		},
+		"parent": {
+			"type": "relation",
+			"relation": "oneToOne",
+			"target": "api::page.page",
+			"private": false
+		},
+		"excerpt": {
+			"pluginOptions": {
+				"i18n": {
+					"localized": true
+				}
+			},
+			"type": "text"
+		},
+		"modules": {
+			"pluginOptions": {
+				"i18n": {
+					"localized": true
+				}
+			},
+			"type": "dynamiczone",
+			"components": []
+		},
+		"seo": {
+			"type": "component",
+			"pluginOptions": {
+				"i18n": {
+					"localized": true
+				}
+			},
+			"component": "shared.seo"
+		}
+	}
+}

package/server/schema/page-type-end.json

@@ -0,0 +1,49 @@
+{
+	"draftAndPublish": false,
+	"displayName": "Pagina Types",
+	"singularName": "page-type",
+	"pluralName": "page-types",
+	"description": "",
+	"plugin": "page-builder",
+	"pluginOptions": {
+		"i18n": {
+			"localized": true
+		}
+	},
+	"kind": "collectionType",
+	"collectionName": "page_types",
+	"attributes": {
+		"uid": {
+			"type": "string",
+			"required": true,
+			"unique": true,
+			"pluginOptions": {
+				"i18n": {
+					"localized": true
+				}
+			}
+		},
+		"title": {
+			"type": "string",
+			"pluginOptions": {
+				"i18n": {
+					"localized": true
+				}
+			}
+		},
+		"modules": {
+			"type": "dynamiczone",
+			"components": [],
+			"pluginOptions": {
+				"i18n": {
+					"localized": true
+				}
+			}
+		},
+		"template": {
+			"type": "relation",
+			"relation": "oneToOne",
+			"target": "api::template.template"
+		}
+	}
+}

package/server/schema/page-type-start.json

@@ -0,0 +1,44 @@
+{
+	"draftAndPublish": false,
+	"displayName": "Pagina Types",
+	"singularName": "page-type",
+	"pluralName": "page-types",
+	"description": "",
+	"plugin": "page-builder",
+	"pluginOptions": {
+		"i18n": {
+			"localized": true
+		}
+	},
+	"kind": "collectionType",
+	"collectionName": "page_types",
+	"attributes": {
+		"uid": {
+			"type": "string",
+			"required": true,
+			"unique": true,
+			"pluginOptions": {
+				"i18n": {
+					"localized": true
+				}
+			}
+		},
+		"title": {
+			"type": "string",
+			"pluginOptions": {
+				"i18n": {
+					"localized": true
+				}
+			}
+		},
+		"modules": {
+			"type": "dynamiczone",
+			"components": [],
+			"pluginOptions": {
+				"i18n": {
+					"localized": true
+				}
+			}
+		}
+	}
+}

package/server/schema/template.json

@@ -0,0 +1,35 @@
+{
+	"draftAndPublish": false,
+	"displayName": "Templates",
+	"singularName": "template",
+	"pluralName": "templates",
+	"description": "",
+	"plugin": "page-builder",
+	"pluginOptions": {
+		"i18n": {
+			"localized": true
+		}
+	},
+	"kind": "collectionType",
+	"collectionName": "templates",
+	"attributes": {
+		"title": {
+			"type": "string",
+			"required": true,
+			"pluginOptions": {
+				"i18n": {
+					"localized": true
+				}
+			}
+		},
+		"modules": {
+			"type": "dynamiczone",
+			"components": [],
+			"pluginOptions": {
+				"i18n": {
+					"localized": true
+				}
+			}
+		}
+	}
+}

package/server/services/builder.ts

@@ -0,0 +1,121 @@
+import partition from 'lodash/partition';
+
+import { Service } from '@strapi/strapi/lib/types/core/common';
+
+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 { reloadStrapiOnLoad } from '../utils/reload-strapi-on-load';
+import pageTypeStart from '../schema/page-type-start.json';
+import pageTypeEnd from '../schema/page-type-end.json';
+import template from '../schema/template.json';
+
+const UIDS = [TEMPLATE_UID, PAGE_TYPE_UID, PAGE_UID];
+
+export default {
+	async buildContentTypes() {
+		this.listenToCreatedContentTypes();
+
+		await this.createContentTypes();
+
+		await this.updateContentTypes();
+	},
+	listenToCreatedContentTypes() {
+		strapi.eventHub.on('content-type.create', async (e) => {
+			if (e.contentType.uid === PAGE_UID) {
+				reloadStrapiOnLoad();
+			}
+		});
+	},
+
+	async createContentTypes() {
+		const newContentTypes = UIDS.filter((c) => !Boolean(strapi.contentType(c))).map(
+			(c) => this.getContentType(c)?.create
+		);
+
+		await this.synchronizeContentTypes(newContentTypes);
+	},
+	async updateContentTypes() {
+		const updateContentTypes = UIDS.filter((c) => Boolean(strapi.contentType(c))).map(
+			(c) => this.getContentType(c).update
+		);
+
+		await this.synchronizeContentTypes(updateContentTypes);
+	},
+	async synchronizeContentTypes(contentTypes: { uid: string; contentType: Record<string, any> }[]) {
+		const ctb = strapi.service('plugin::content-type-builder.content-types') as Service;
+
+		const [oldTypes, newTypes] = partition(contentTypes, (c) => Boolean(strapi.contentType(c.uid)));
+
+		if (newTypes.length > 0) {
+			console.log(
+				'[Plugin Page Builder]: Creating content types',
+				newTypes.map((x) => x.uid)
+			);
+		}
+
+		if (oldTypes.length > 0) {
+			console.log(
+				'[Plugin Page Builder]: Updating content types',
+				oldTypes.map((x) => x.uid)
+			);
+		}
+
+		if ((newTypes || []).length > 0) {
+			await ctb.createContentTypes(newTypes.map((c) => ({ contentType: c.contentType, components: [] })));
+		}
+
+		if ((oldTypes || []).length > 0) {
+			for (const oldType of oldTypes) {
+				await ctb.editContentType(oldType.uid, { contentType: oldType.contentType, components: [] });
+			}
+		}
+	},
+	getContentType(uid: string) {
+		const contentTypes = {
+			[PAGE_UID]: {
+				create: this.getPageContentType(true),
+				update: this.getPageContentType()
+			},
+			[PAGE_TYPE_UID]: {
+				create: this.getPageTypeContentType(true),
+				update: this.getPageTypeContentType()
+			},
+			[TEMPLATE_UID]: {
+				create: this.getTemplateContentType(),
+				update: this.getTemplateContentType()
+			}
+		};
+
+		return contentTypes?.[uid];
+	},
+	getPageContentType(create?: boolean) {
+		const page = create ? pageStart : pageEnd;
+		const contentType = this.addModulesToCollectionType(page);
+
+		return { uid: PAGE_UID, contentType };
+	},
+	getPageTypeContentType(create?: boolean) {
+		const pageType = create ? pageTypeStart : pageTypeEnd;
+		const contentType = this.addModulesToCollectionType(pageType);
+
+		return { uid: PAGE_TYPE_UID, contentType };
+	},
+	getTemplateContentType() {
+		const contentType = this.addModulesToCollectionType(template);
+
+		return { uid: TEMPLATE_UID, contentType };
+	},
+	addModulesToCollectionType(collectionType: Record<string, any>) {
+		const components = this.getConfigModuleComponents();
+
+		return {
+			...collectionType,
+			attributes: { ...collectionType.attributes, modules: { ...collectionType.attributes.modules, components } }
+		};
+	},
+	getConfigModuleComponents() {
+		return (strapi.config.get(`plugin.${pluginId}`)?.modules || []).filter(Boolean);
+	}
+};

package/server/services/collection-types.ts

@@ -0,0 +1,49 @@
+import { Strapi } from '@strapi/strapi';
+import uniqBy from 'lodash/uniqBy';
+
+import { IGetTranslationPageLinks } from '../controllers/collection-types';
+
+export default {
+	async hasPageRelation(uid: string): Promise<{ hasPageRelation: boolean }> {
+		const contentType = strapi.contentTypes?.[uid];
+
+		return {
+			hasPageRelation: Boolean(
+				contentType?.attributes?.page && contentType?.attributes?.page?.morphBy === 'collectionTypeData'
+			)
+		};
+	},
+	async getTranslationPageLinks(uid: string, ids: string[]) {
+		try {
+			const entities = await (strapi as Strapi).entityService.findMany(uid, {
+				filters: {
+					id: { $in: ids }
+				},
+				populate: {
+					page: {
+						populate: {
+							localizations: true
+						}
+					}
+				}
+			});
+
+			let pages: IGetTranslationPageLinks[] = [];
+
+			// Get all pages linked to the entity
+			entities?.forEach((x: any) => {
+				x?.page?.forEach((p: any) => {
+					pages.push({ id: p.id, locale: p.locale });
+
+					p.localizations.forEach((l: any) => {
+						pages.push({ id: l.id, locale: l.locale });
+					});
+				});
+			});
+
+			return uniqBy(pages, 'id');
+		} catch {
+			return [];
+		}
+	}
+};

package/server/services/index.ts

@@ -0,0 +1,11 @@
+import page from './page';
+import builder from './builder';
+import pageType from './page-type';
+import collectionTypes from './collection-types';
+
+export default {
+	page,
+	builder,
+	'page-type': pageType,
+	'collection-types': collectionTypes
+};

package/server/services/page-type.ts

@@ -0,0 +1,22 @@
+export default {
+	async findOneByUid(uid: string) {
+		const result = await strapi.entityService.findMany('api::page-type.page-type', {
+			populate: {
+				template: {
+					populate: {
+						modules: true
+					}
+				}
+			},
+			filters: {
+				uid
+			}
+		});
+
+		if (result.length > 0) {
+			return result[0];
+		} else {
+			return null;
+		}
+	}
+};

package/server/services/page.ts

@@ -0,0 +1,24 @@
+import { PAGE_UID } from '../../shared/utils/constants';
+
+export default {
+	async getPage(id: string) {
+		// @ts-ignore
+		const page = await strapi.db.query(PAGE_UID).findOne({
+			// @ts-ignore
+			select: 'id',
+			populate: {
+				// @ts-ignore
+				collectionTypeData: true,
+				pageType: true
+			},
+			where: {
+				id
+			}
+		});
+
+		return {
+			pageType: page.pageType,
+			collectionTypeData: page.collectionTypeData?.[0] ?? null
+		};
+	}
+};