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

package/server/schema/template-start.json

@@ -1,35 +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
-				}
-			}
-		}
-	}
-}
+{
+	"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

@@ -1,134 +1,137 @@
-import partition from 'lodash/partition';
-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 { 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';
-
-const UIDS: Common.UID.ContentType[] = [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)
-			.filter(Boolean);
-
-		await this.synchronizeContentTypes(newContentTypes);
-	},
-	async updateContentTypes() {
-		const updateContentTypes = UIDS.filter((c) => Boolean(strapi.contentType(c)))
-			.map((c) => this.getContentType(c).update)
-			.filter(Boolean);
-
-		await this.synchronizeContentTypes(updateContentTypes);
-	},
-	async synchronizeContentTypes(contentTypes: { uid: Common.UID.ContentType; contentType: Record<string, any> }[]) {
-		const ctb = strapi.service('plugin::content-type-builder.content-types');
-
-		const [updateTypes, 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 (updateTypes.length > 0) {
-			console.log(
-				'[Plugin Page Builder]: Updating content types',
-				updateTypes.map((x) => x.uid)
-			);
-		}
-
-		if ((newTypes || []).length > 0) {
-			await ctb.createContentTypes(newTypes.map((c) => ({ contentType: c.contentType, components: [] })));
-		}
-
-		if ((updateTypes || []).length > 0) {
-			for await (const updateType of updateTypes) {
-				await ctb.editContentType(updateType.uid, {
-					contentType: updateType.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.mergeCollectionTypeWithModules(page, PAGE_UID);
-
-		return { uid: PAGE_UID, contentType };
-	},
-	getPageTypeContentType(create?: boolean) {
-		const pageType = create ? pageTypeStart : pageTypeEnd;
-		const contentType = this.mergeCollectionTypeWithModules(pageType, PAGE_TYPE_UID);
-
-		return { uid: PAGE_TYPE_UID, contentType };
-	},
-	getTemplateContentType() {
-		const template = templateStart;
-		const contentType = this.mergeCollectionTypeWithModules(template, TEMPLATE_UID);
-
-		return { uid: TEMPLATE_UID, contentType };
-	},
-	mergeCollectionTypeWithModules(collectionType: Record<string, any>, uid: Common.UID.ContentType) {
-		const { pluginOptions: oldPluginOptions, __schema__: oldSchema } = (strapi.contentType(uid) as any) || {};
-		const components = this.getConfigModuleComponents();
-
-		return {
-			...collectionType,
-			displayName: oldSchema?.info?.displayName || collectionType?.displayName,
-			pluginOptions: {
-				...oldPluginOptions,
-				...collectionType?.pluginOptions
-			},
-			attributes: {
-				...oldSchema?.attributes,
-				...collectionType.attributes,
-				modules: { ...collectionType.attributes.modules, components }
-			}
-		};
-	},
-	getConfigModuleComponents() {
-		return ((strapi.config.get(`plugin.${pluginId}`) as Record<string, any>)?.modules || []).filter(Boolean);
-	}
-};
+import partition from 'lodash/partition';
+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 { 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';
+
+const UIDS: Common.UID.ContentType[] = [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)
+			.filter(Boolean);
+
+		await this.synchronizeContentTypes(newContentTypes);
+	},
+	async updateContentTypes() {
+		const updateContentTypes = UIDS.filter((c) => Boolean(strapi.contentType(c)))
+			.map((c) => this.getContentType(c).update)
+			.filter(Boolean);
+
+		await this.synchronizeContentTypes(updateContentTypes);
+	},
+	async synchronizeContentTypes(contentTypes: { uid: Common.UID.ContentType; contentType: Record<string, any> }[]) {
+		const ctb = strapi.service('plugin::content-type-builder.content-types');
+
+		const [updateTypes, 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 (updateTypes.length > 0) {
+			console.log(
+				'[Plugin Page Builder]: Updating content types',
+				updateTypes.map((x) => x.uid)
+			);
+		}
+
+		if ((newTypes || []).length > 0) {
+			await ctb.createContentTypes(newTypes.map((c) => ({ contentType: c.contentType, components: [] })));
+		}
+
+		if ((updateTypes || []).length > 0) {
+			for await (const updateType of updateTypes) {
+				await ctb.editContentType(updateType.uid, {
+					contentType: updateType.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.mergeCollectionTypeWithModules(page, PAGE_UID);
+
+		return { uid: PAGE_UID, contentType };
+	},
+	getPageTypeContentType(create?: boolean) {
+		const pageType = create ? pageTypeStart : pageTypeEnd;
+		const contentType = this.mergeCollectionTypeWithModules(pageType, PAGE_TYPE_UID);
+
+		return { uid: PAGE_TYPE_UID, contentType };
+	},
+	getTemplateContentType() {
+		const template = templateStart;
+		const contentType = this.mergeCollectionTypeWithModules(template, TEMPLATE_UID);
+
+		return { uid: TEMPLATE_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;
+
+		return {
+			...collectionType,
+			displayName: oldSchema?.info?.displayName || collectionType?.displayName,
+			pluginOptions: {
+				...oldPluginOptions,
+				...collectionType?.pluginOptions
+			},
+			attributes: {
+				...oldSchema?.attributes,
+				...collectionType.attributes,
+				...(((collectionType?.attributes?.modules && collectionType?.attributes?.modules?.length > 0) ||
+					modulesFromConfig) && {
+					modules: { ...collectionType?.attributes?.modules, components: modulesFromConfig }
+				})
+			}
+		};
+	},
+	getConfigModuleComponents() {
+		return ((strapi.config.get(`plugin.${pluginId}`) as Record<string, any>)?.modules || []).filter(Boolean);
+	}
+};

package/server/services/collection-types.ts

@@ -1,88 +1,88 @@
-import uniqBy from 'lodash/uniqBy';
-import { Common } from '@strapi/strapi';
-
-import { IGetTranslationPageLinks } from '../controllers/collection-types';
-import { PAGE_TYPE_UID } from '../../shared/utils/constants';
-
-export interface ICollectionTypeGL {
-	uid: string;
-	type: string;
-	inputType: string;
-}
-
-export default {
-	async hasPageRelation(uid: string): Promise<{ hasPageRelation: boolean }> {
-		const contentType = strapi.contentTypes?.[uid];
-		const pageTypesWithUid =
-			(await strapi.entityService.findMany(PAGE_TYPE_UID, {
-				filters: {
-					uid: {
-						$eq: uid
-					}
-				}
-			})) || [];
-
-		return {
-			hasPageRelation: Boolean(
-				contentType?.attributes?.page &&
-					contentType?.attributes?.page?.morphBy === 'collectionTypeData' &&
-					(pageTypesWithUid as Record<string, any>[]).length > 0
-			)
-		};
-	},
-	withPageMorph(): ICollectionTypeGL[] {
-		const { getTypeName, getFiltersInputTypeName } = strapi.plugin('graphql').service('utils').naming;
-
-		const collectionTypes = Object.entries(strapi.contentTypes)
-			.map((ct) => {
-				const uid: string = ct?.[0];
-				const contentType = ct?.[1] as Record<string, any>;
-				const type = contentType ? getTypeName(contentType) : undefined;
-				const hasPageMorph = contentType?.attributes?.page?.morphBy === 'collectionTypeData';
-
-				if (uid && type && hasPageMorph) {
-					return {
-						uid,
-						type: getTypeName(contentType),
-						inputType: getFiltersInputTypeName(contentType)
-					};
-				}
-			})
-			.filter(Boolean) as ICollectionTypeGL[];
-
-		return collectionTypes;
-	},
-	async getTranslationPageLinks(uid: Common.UID.ContentType, ids: string[]) {
-		try {
-			const entities = await strapi.entityService.findMany(uid, {
-				filters: {
-					id: { $in: ids }
-				},
-				populate: {
-					page: {
-						populate: {
-							localizations: true
-						}
-					}
-				}
-			} as any);
-
-			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 [];
-		}
-	}
-};
+import uniqBy from 'lodash/uniqBy';
+import { Common } from '@strapi/strapi';
+
+import { IGetTranslationPageLinks } from '../controllers/collection-types';
+import { PAGE_TYPE_UID } from '../../shared/utils/constants';
+
+export interface ICollectionTypeGL {
+	uid: string;
+	type: string;
+	inputType: string;
+}
+
+export default {
+	async hasPageRelation(uid: string): Promise<{ hasPageRelation: boolean }> {
+		const contentType = strapi.contentTypes?.[uid];
+		const pageTypesWithUid =
+			(await strapi.entityService.findMany(PAGE_TYPE_UID, {
+				filters: {
+					uid: {
+						$eq: uid
+					}
+				}
+			})) || [];
+
+		return {
+			hasPageRelation: Boolean(
+				contentType?.attributes?.page &&
+					contentType?.attributes?.page?.morphBy === 'collectionTypeData' &&
+					(pageTypesWithUid as Record<string, any>[]).length > 0
+			)
+		};
+	},
+	withPageMorph(): ICollectionTypeGL[] {
+		const { getTypeName, getFiltersInputTypeName } = strapi.plugin('graphql').service('utils').naming;
+
+		const collectionTypes = Object.entries(strapi.contentTypes)
+			.map((ct) => {
+				const uid: string = ct?.[0];
+				const contentType = ct?.[1] as Record<string, any>;
+				const type = contentType ? getTypeName(contentType) : undefined;
+				const hasPageMorph = contentType?.attributes?.page?.morphBy === 'collectionTypeData';
+
+				if (uid && type && hasPageMorph) {
+					return {
+						uid,
+						type: getTypeName(contentType),
+						inputType: getFiltersInputTypeName(contentType)
+					};
+				}
+			})
+			.filter(Boolean) as ICollectionTypeGL[];
+
+		return collectionTypes;
+	},
+	async getTranslationPageLinks(uid: Common.UID.ContentType, ids: string[]) {
+		try {
+			const entities = await strapi.entityService.findMany(uid, {
+				filters: {
+					id: { $in: ids }
+				},
+				populate: {
+					page: {
+						populate: {
+							localizations: true
+						}
+					}
+				}
+			} as any);
+
+			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

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

package/server/services/page-type.ts

@@ -1,26 +1,26 @@
-import { PAGE_TYPE_UID } from '../../shared/utils/constants';
-
-export default {
-	async findOneByUid(uid: string) {
-		const results = await strapi.entityService?.findMany(PAGE_TYPE_UID, {
-			populate: {
-				template: {
-					populate: {
-						modules: true
-					}
-				}
-			},
-			filters: {
-				uid
-			}
-		});
-
-		const result = (results as any[]).length > 0 ? results?.[0] : undefined;
-
-		if (result) {
-			return result;
-		} else {
-			return null;
-		}
-	}
-};
+import { PAGE_TYPE_UID } from '../../shared/utils/constants';
+
+export default {
+	async findOneByUid(uid: string) {
+		const results = await strapi.entityService?.findMany(PAGE_TYPE_UID, {
+			populate: {
+				template: {
+					populate: {
+						modules: true
+					}
+				}
+			},
+			filters: {
+				uid
+			}
+		});
+
+		const result = (results as any[]).length > 0 ? results?.[0] : undefined;
+
+		if (result) {
+			return result;
+		} else {
+			return null;
+		}
+	}
+};

package/server/services/page.ts

@@ -1,24 +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
-		};
-	}
-};
+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
+		};
+	}
+};

package/server/services/template.ts

@@ -1,14 +1,13 @@
-import { getPopulatedEntity } from '../utils/strapi';
-import { TEMPLATE_UID } from '../../shared/utils/constants';
-
-export default {
-	async findAll() {
-		const foundTemplates = await strapi.entityService.findMany(TEMPLATE_UID);
-
-		return foundTemplates;
-	},
-	async findOne(id: number) {
-		const getpopulatedTemplate = getPopulatedEntity(TEMPLATE_UID, id);
-		return getpopulatedTemplate;
-	}
-};
+import { getPopulatedEntity } from '../utils/strapi';
+import { TEMPLATE_UID } from '../../shared/utils/constants';
+
+export default {
+	async findAll() {
+		const foundTemplates = await strapi.entityService.findMany(TEMPLATE_UID);
+
+		return foundTemplates;
+	},
+	async findOne(id: number) {
+		return await getPopulatedEntity(TEMPLATE_UID, id);
+	}
+};