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

package/server/bootstrap.ts

@@ -1,198 +1,198 @@
-import { Common, Strapi } from '@strapi/strapi';
-import { errors } from '@strapi/utils';
-import { PAGE_TYPE_UID, PAGE_UID } from '../shared/utils/constants';
-import permissions from './bootstrap/permissions';
-import collectionTypeLifecycles from './bootstrap/collection-type-lifecycles';
-
-export default async ({ strapi }: { strapi: Strapi }) => {
-	await permissions({ strapi });
-	await collectionTypeLifecycles({ strapi });
-
-	const updateCollectionTypeData = (data: any, collectionTypeId: number, uid: string) => {
-		data.collectionTypeData = {
-			id: collectionTypeId,
-			__type: uid,
-			__pivot: {
-				field: 'page'
-			}
-		};
-
-		return data;
-	};
-
-	strapi.db?.lifecycles.subscribe({
-		// @ts-ignore
-		models: [PAGE_UID],
-		async beforeCreate(event) {
-			let { data } = event.params;
-			const collectionTypeId = data?.collectionTypeId;
-			const pageTypeId = data?.pageType.connect?.[0]?.id || data.initialPageType;
-
-			if (collectionTypeId && pageTypeId) {
-				const pageType: Record<string, any> | undefined | null = await strapi.entityService?.findOne(
-					PAGE_TYPE_UID,
-					pageTypeId
-				);
-				const collectionToConnect = await strapi.entityService?.findOne(pageType?.uid, collectionTypeId, {
-					populate: { page: true }
-				});
-
-				const page: Record<string, any>[] = collectionToConnect?.page as any;
-
-				if (page && page.length > 0) {
-					throw new errors.ValidationError('You can only link one CollectionType to one page');
-				}
-
-				data = updateCollectionTypeData(data, collectionTypeId, pageType?.uid);
-			}
-		},
-		async beforeUpdate(event) {
-			let { data, where } = event?.params;
-
-			const collectionTypeId = data?.collectionTypeId;
-			const pageTypeId = data?.pageType?.connect?.[0]?.id || data?.initialPageType;
-			const removedPageType = data?.pageType?.disconnect?.[0]?.id;
-
-			const originalEntity = await strapi.entityService?.findOne(
-				event.model.uid as Common.UID.CollectionType,
-				data.id || where.id,
-				{
-					populate: {
-						collectionTypeData: true
-					}
-				} as Record<string, any>
-			);
-
-			if (removedPageType || collectionTypeId === null) {
-				data.collectionTypeData = undefined;
-
-				if (originalEntity?.collectionTypeData?.[0]?.__type && originalEntity?.collectionTypeData?.[0]?.id) {
-					strapi.entityService?.update(
-						originalEntity.collectionTypeData[0].__type,
-						originalEntity.collectionTypeData[0].id,
-						{
-							data: {
-								id: originalEntity.collectionTypeData.id,
-								hasPage: false
-							}
-						}
-					);
-				}
-			}
-
-			if (collectionTypeId && pageTypeId && !removedPageType) {
-				const pageType: Record<string, any> | undefined | null = await strapi.entityService?.findOne(
-					PAGE_TYPE_UID,
-					pageTypeId
-				);
-				const collectionToConnect = await strapi.entityService?.findOne(pageType?.uid, collectionTypeId, {
-					populate: { page: true }
-				});
-
-				const page: Record<string, any>[] = collectionToConnect?.page as any;
-
-				if (page && page?.length > 0 && !page.some((p) => p.id === data.id)) {
-					throw new errors.ValidationError('You can only link one CollectionType to one page');
-				}
-
-				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 &&
-				originalEntity?.collectionTypeData?.[0]?.id &&
-				Number(data.collectionTypeData.id) !== Number(originalEntity.collectionTypeData[0].id)
-			) {
-				await strapi.entityService?.update(
-					originalEntity.collectionTypeData[0].__type,
-					originalEntity.collectionTypeData[0].id,
-					{
-						data: {
-							id: originalEntity.collectionTypeData[0].id,
-							hasPage: false,
-							lifecycleState: {
-								exit: true
-							}
-						}
-					}
-				);
-			}
-		},
-		async afterUpdate(event) {
-			const data = event?.params?.data;
-
-			if (data.collectionTypeData?.__type && data.collectionTypeData.id) {
-				await strapi.entityService?.update(data.collectionTypeData.__type, data.collectionTypeData.id, {
-					data: {
-						id: data.collectionTypeData.id,
-						hasPage: true,
-						lifecycleState: {
-							exit: true
-						}
-					}
-				});
-			}
-		},
-		async afterCreate(event) {
-			const data = event?.params?.data;
-			if (data.collectionTypeData?.__type && data.collectionTypeData.id) {
-				await strapi.entityService?.update(data.collectionTypeData.__type, data.collectionTypeData.id, {
-					data: {
-						id: data.collectionTypeData.id,
-						hasPage: true,
-						lifecycleState: {
-							exit: true
-						}
-					}
-				});
-			}
-		},
-		async beforeDelete(event) {
-			const originalEntity = (await strapi.entityService?.findOne(PAGE_UID, event.params.where.id, {
-				populate: {
-					collectionTypeData: true
-				}
-			})) as Record<string, any> | undefined;
-
-			if (originalEntity?.collectionTypeData?.[0]?.__type && originalEntity?.collectionTypeData?.[0]?.id) {
-				await strapi.entityService?.update(
-					originalEntity.collectionTypeData[0].__type,
-					originalEntity.collectionTypeData[0].id,
-					{
-						data: {
-							id: originalEntity.collectionTypeData[0].id,
-							hasPage: false
-						}
-					}
-				);
-			}
-		},
-		async beforeDeleteMany(event) {
-			const pagesToDisconnect = event.params.where?.['$and']?.[0]?.id?.['$in'];
-
-			for (const pageId of pagesToDisconnect) {
-				const originalEntity = (await strapi.entityService?.findOne(PAGE_UID, pageId, {
-					populate: {
-						collectionTypeData: true
-					}
-				})) as Record<string, any> | undefined;
-
-				if (originalEntity?.collectionTypeData?.[0]?.__type && originalEntity?.collectionTypeData?.[0]?.id) {
-					await strapi.entityService?.update(
-						originalEntity.collectionTypeData[0].__type,
-						originalEntity.collectionTypeData[0].id,
-						{
-							data: {
-								id: originalEntity.collectionTypeData[0].id,
-								hasPage: false
-							}
-						}
-					);
-				}
-			}
-		}
-	});
-};
+import { Common, Strapi } from '@strapi/strapi';
+import { errors } from '@strapi/utils';
+import { PAGE_TYPE_UID, PAGE_UID } from '../shared/utils/constants';
+import permissions from './bootstrap/permissions';
+import collectionTypeLifecycles from './bootstrap/collection-type-lifecycles';
+
+export default async ({ strapi }: { strapi: Strapi }) => {
+	await permissions({ strapi });
+	await collectionTypeLifecycles({ strapi });
+
+	const updateCollectionTypeData = (data: any, collectionTypeId: number, uid: string) => {
+		data.collectionTypeData = {
+			id: collectionTypeId,
+			__type: uid,
+			__pivot: {
+				field: 'page'
+			}
+		};
+
+		return data;
+	};
+
+	strapi.db?.lifecycles.subscribe({
+		// @ts-ignore
+		models: [PAGE_UID],
+		async beforeCreate(event) {
+			let { data } = event.params;
+			const collectionTypeId = data?.collectionTypeId;
+			const pageTypeId = data?.pageType.connect?.[0]?.id || data.initialPageType;
+
+			if (collectionTypeId && pageTypeId) {
+				const pageType: Record<string, any> | undefined | null = await strapi.entityService?.findOne(
+					PAGE_TYPE_UID,
+					pageTypeId
+				);
+				const collectionToConnect = await strapi.entityService?.findOne(pageType?.uid, collectionTypeId, {
+					populate: { page: true }
+				});
+
+				const page: Record<string, any>[] = collectionToConnect?.page as any;
+
+				if (page && page.length > 0) {
+					throw new errors.ValidationError('You can only link one CollectionType to one page');
+				}
+
+				data = updateCollectionTypeData(data, collectionTypeId, pageType?.uid);
+			}
+		},
+		async beforeUpdate(event) {
+			let { data, where } = event?.params;
+
+			const collectionTypeId = data?.collectionTypeId;
+			const pageTypeId = data?.pageType?.connect?.[0]?.id || data?.initialPageType;
+			const removedPageType = data?.pageType?.disconnect?.[0]?.id;
+
+			const originalEntity = await strapi.entityService?.findOne(
+				event.model.uid as Common.UID.CollectionType,
+				data.id || where.id,
+				{
+					populate: {
+						collectionTypeData: true
+					}
+				} as Record<string, any>
+			);
+
+			if (removedPageType || collectionTypeId === null) {
+				data.collectionTypeData = undefined;
+
+				if (originalEntity?.collectionTypeData?.[0]?.__type && originalEntity?.collectionTypeData?.[0]?.id) {
+					strapi.entityService?.update(
+						originalEntity.collectionTypeData[0].__type,
+						originalEntity.collectionTypeData[0].id,
+						{
+							data: {
+								id: originalEntity.collectionTypeData.id,
+								hasPage: false
+							}
+						}
+					);
+				}
+			}
+
+			if (collectionTypeId && pageTypeId && !removedPageType) {
+				const pageType: Record<string, any> | undefined | null = await strapi.entityService?.findOne(
+					PAGE_TYPE_UID,
+					pageTypeId
+				);
+				const collectionToConnect = await strapi.entityService?.findOne(pageType?.uid, collectionTypeId, {
+					populate: { page: true }
+				});
+
+				const page: Record<string, any>[] = collectionToConnect?.page as any;
+
+				if (page && page?.length > 0 && !page.some((p) => p.id === data.id)) {
+					throw new errors.ValidationError('You can only link one CollectionType to one page');
+				}
+
+				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 &&
+				originalEntity?.collectionTypeData?.[0]?.id &&
+				Number(data.collectionTypeData.id) !== Number(originalEntity.collectionTypeData[0].id)
+			) {
+				await strapi.entityService?.update(
+					originalEntity.collectionTypeData[0].__type,
+					originalEntity.collectionTypeData[0].id,
+					{
+						data: {
+							id: originalEntity.collectionTypeData[0].id,
+							hasPage: false,
+							lifecycleState: {
+								exit: true
+							}
+						}
+					}
+				);
+			}
+		},
+		async afterUpdate(event) {
+			const data = event?.params?.data;
+
+			if (data.collectionTypeData?.__type && data.collectionTypeData.id) {
+				await strapi.entityService?.update(data.collectionTypeData.__type, data.collectionTypeData.id, {
+					data: {
+						id: data.collectionTypeData.id,
+						hasPage: true,
+						lifecycleState: {
+							exit: true
+						}
+					}
+				});
+			}
+		},
+		async afterCreate(event) {
+			const data = event?.params?.data;
+			if (data.collectionTypeData?.__type && data.collectionTypeData.id) {
+				await strapi.entityService?.update(data.collectionTypeData.__type, data.collectionTypeData.id, {
+					data: {
+						id: data.collectionTypeData.id,
+						hasPage: true,
+						lifecycleState: {
+							exit: true
+						}
+					}
+				});
+			}
+		},
+		async beforeDelete(event) {
+			const originalEntity = (await strapi.entityService?.findOne(PAGE_UID, event.params.where.id, {
+				populate: {
+					collectionTypeData: true
+				}
+			})) as Record<string, any> | undefined;
+
+			if (originalEntity?.collectionTypeData?.[0]?.__type && originalEntity?.collectionTypeData?.[0]?.id) {
+				await strapi.entityService?.update(
+					originalEntity.collectionTypeData[0].__type,
+					originalEntity.collectionTypeData[0].id,
+					{
+						data: {
+							id: originalEntity.collectionTypeData[0].id,
+							hasPage: false
+						}
+					}
+				);
+			}
+		},
+		async beforeDeleteMany(event) {
+			const pagesToDisconnect = event.params.where?.['$and']?.[0]?.id?.['$in'];
+
+			for (const pageId of pagesToDisconnect) {
+				const originalEntity = (await strapi.entityService?.findOne(PAGE_UID, pageId, {
+					populate: {
+						collectionTypeData: true
+					}
+				})) as Record<string, any> | undefined;
+
+				if (originalEntity?.collectionTypeData?.[0]?.__type && originalEntity?.collectionTypeData?.[0]?.id) {
+					await strapi.entityService?.update(
+						originalEntity.collectionTypeData[0].__type,
+						originalEntity.collectionTypeData[0].id,
+						{
+							data: {
+								id: originalEntity.collectionTypeData[0].id,
+								hasPage: false
+							}
+						}
+					);
+				}
+			}
+		}
+	});
+};

package/server/config/index.ts

@@ -1,4 +1,4 @@
-export default {
-	default: {},
-	validator() {}
-};
+export default {
+	default: {},
+	validator() {}
+};

package/server/content-types/index.ts

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

package/server/controllers/collection-types.ts

@@ -1,27 +1,27 @@
-import { Strapi } from '@strapi/strapi';
-
-export default {
-	async hasPageRelation(ctx: any) {
-		const uid = ctx.params?.uid;
-
-		return (strapi as Strapi).service('plugin::page-builder.collection-types').hasPageRelation(uid);
-	},
-	async getTranslationPageLinks(ctx: any): Promise<IGetTranslationPageLinks[] | undefined> {
-		const { uid, ids } = ctx.params || {};
-		const idsArr = (ids as string)
-			?.split(',')
-			.map(Number)
-			.filter((x) => !isNaN(x));
-
-		if (!uid || idsArr?.length === 0) {
-			return undefined;
-		}
-
-		return (strapi as Strapi).service('plugin::page-builder.collection-types').getTranslationPageLinks(uid, idsArr);
-	}
-};
-
-export interface IGetTranslationPageLinks {
-	id: number;
-	locale: string;
-}
+import { Strapi } from '@strapi/strapi';
+
+export default {
+	async hasPageRelation(ctx: any) {
+		const uid = ctx.params?.uid;
+
+		return (strapi as Strapi).service('plugin::page-builder.collection-types').hasPageRelation(uid);
+	},
+	async getTranslationPageLinks(ctx: any): Promise<IGetTranslationPageLinks[] | undefined> {
+		const { uid, ids } = ctx.params || {};
+		const idsArr = (ids as string)
+			?.split(',')
+			.map(Number)
+			.filter((x) => !isNaN(x));
+
+		if (!uid || idsArr?.length === 0) {
+			return undefined;
+		}
+
+		return (strapi as Strapi).service('plugin::page-builder.collection-types').getTranslationPageLinks(uid, idsArr);
+	}
+};
+
+export interface IGetTranslationPageLinks {
+	id: number;
+	locale: string;
+}

package/server/controllers/index.ts

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

package/server/controllers/page-type.ts

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

package/server/controllers/page.ts

@@ -1,9 +1,9 @@
-import { Strapi } from '@strapi/strapi';
-
-export default {
-	async getPage(ctx) {
-		const id = ctx.params?.id;
-
-		return (strapi as Strapi).service('plugin::page-builder.page')?.getPage(id);
-	}
-};
+import { Strapi } from '@strapi/strapi';
+
+export default {
+	async getPage(ctx) {
+		const id = ctx.params?.id;
+
+		return (strapi as Strapi).service('plugin::page-builder.page')?.getPage(id);
+	}
+};

package/server/controllers/template.ts

@@ -1,16 +1,16 @@
-import { Strapi } from '@strapi/strapi';
-
-export default {
-	async findOneById(ctx: any) {
-		const id = ctx?.params?.id;
-
-		if (!id) {
-			return ctx.badRequest('id is missing.');
-		}
-
-		return await (strapi as Strapi).service('plugin::page-builder.template').findOne(id);
-	},
-	async findAll() {
-		return await (strapi as Strapi).service('plugin::page-builder.template').findAll();
-	}
-};
+import { Strapi } from '@strapi/strapi';
+
+export default {
+	async findOneById(ctx: any) {
+		const id = ctx?.params?.id;
+
+		if (!id) {
+			return ctx.badRequest('id is missing.');
+		}
+
+		return await (strapi as Strapi).service('plugin::page-builder.template').findOne(id);
+	},
+	async findAll() {
+		return await (strapi as Strapi).service('plugin::page-builder.template').findAll();
+	}
+};

package/server/destroy.ts

@@ -1,5 +1,5 @@
-import { Strapi } from '@strapi/strapi';
-
-export default ({ strapi }: { strapi: Strapi }) => {
-	// destroy phase
-};
+import { Strapi } from '@strapi/strapi';
+
+export default ({ strapi }: { strapi: Strapi }) => {
+	// destroy phase
+};

package/server/graphql/index.ts

@@ -1,9 +1,9 @@
-import pageType from './page-type';
-import pageBySlug from './page-by-slug';
-import getPageInfoFromUID from './pages-by-uid';
-
-export default {
-	getPageInfoFromUID,
-	pageType,
-	pageBySlug
-};
+import pageType from './page-type';
+import pageBySlug from './page-by-slug';
+import getPageInfoFromUID from './pages-by-uid';
+
+export default {
+	getPageInfoFromUID,
+	pageType,
+	pageBySlug
+};