@webbio/strapi-plugin-page-builder 0.0.30 → 0.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webbio/strapi-plugin-page-builder",
-	"version": "0.0.30",
+	"version": "0.1.0",
 	"description": "This is the description of the plugin.",
 	"scripts": {
 		"develop": "tsc -p tsconfig.server.json -w",
@@ -20,17 +20,17 @@
 		"url": "https://github.com/webbio/strapi-plugin-page-builder.git"
 	},
 	"dependencies": {
-		"@strapi/design-system": "^1.8.2",
-		"@strapi/helper-plugin": "^4.12.0",
-		"@strapi/icons": "^1.8.2",
-		"@strapi/typescript-utils": "^4.12.0",
-		"@strapi/utils": "^4.12.0",
+		"@strapi/design-system": "^1.11.0",
+		"@strapi/helper-plugin": "^4.13.6",
+		"@strapi/icons": "^1.11.0",
+		"@strapi/typescript-utils": "^4.13.6",
+		"@strapi/utils": "^4.13.6",
 		"react-select": "^5.7.4"
 	},
 	"devDependencies": {
-		"@strapi/typescript-utils": "^4.12.0",
-		"@types/react": "^17.0.53",
-		"@types/react-dom": "^18.0.28",
+		"@strapi/typescript-utils": "^4.13.6",
+		"@types/react": "^18.2.21",
+		"@types/react-dom": "^18.2.7",
 		"@types/react-router-dom": "^5.3.3",
 		"@types/styled-components": "^5.1.26",
 		"react": "^18.2.0",
@@ -40,7 +40,7 @@
 		"typescript": "5.1.6"
 	},
 	"peerDependencies": {
-		"@strapi/strapi": "^4.12.0",
+		"@strapi/strapi": "^4.13.6",
 		"@webbio/strapi-plugin-slug": "^0.1.0",
 		"react": "^17.0.0 || ^18.0.0",
 		"react-dom": "^17.0.0 || ^18.0.0",

package/server/bootstrap.ts

@@ -1,14 +1,14 @@
 import { Strapi } from '@strapi/strapi';
 import { errors } from '@strapi/utils';
-
-import { PAGE_UID } from '../shared/utils/constants';
+import { PAGE_TYPE_UID, PAGE_UID } from '../shared/utils/constants';
 
 export default async ({ strapi }: { strapi: Strapi }) => {
 	// TODO: refactor to own function
 	try {
-		const pageTypes = await strapi.entityService.findMany('api::page-type.page-type', {
+		const pageTypes = (await strapi.entityService?.findMany(PAGE_TYPE_UID, {
 			limit: -1
-		});
+		})) as Record<string, any>[];
+
 		const pagePermissions = pageTypes.map((pageType) => {
 			const name = `page-type-is-${pageType.uid}`;
 			const displayName = pageType.title;
@@ -54,7 +54,7 @@ export default async ({ strapi }: { strapi: Strapi }) => {
 		return data;
 	};
 
-	strapi.db.lifecycles.subscribe({
+	strapi.db?.lifecycles.subscribe({
 		// @ts-ignore
 		models: [PAGE_UID],
 		async beforeCreate(event) {
@@ -63,20 +63,26 @@ export default async ({ strapi }: { strapi: Strapi }) => {
 			const pageTypeId = data?.pageType.connect?.[0]?.id || data.initialPageType;
 
 			if (collectionTypeId && pageTypeId) {
-				const { uid } = await strapi.entityService.findOne('api::page-type.page-type', pageTypeId);
-				const collectionToConnect = await strapi.entityService.findOne(uid, collectionTypeId, {
+				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 }
 				});
 
-				if (collectionToConnect.page && collectionToConnect.page.length > 0) {
+				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, uid);
+				data = updateCollectionTypeData(data, collectionTypeId, pageType?.uid);
 			}
 		},
 		async beforeUpdate(event) {
 			let data = event?.params?.data;
+
 			const collectionTypeId = data?.collectionTypeId;
 			const pageTypeId = data?.pageType?.connect?.[0]?.id || data?.initialPageType;
 			const removedPageType = data?.pageType?.disconnect?.[0]?.id;
@@ -86,20 +92,91 @@ export default async ({ strapi }: { strapi: Strapi }) => {
 			}
 
 			if (collectionTypeId && pageTypeId && !removedPageType) {
-				const { uid } = await strapi.entityService.findOne('api::page-type.page-type', pageTypeId);
-				const collectionToConnect = await strapi.entityService.findOne(uid, collectionTypeId, {
+				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 }
 				});
 
-				if (
-					collectionToConnect.page &&
-					collectionToConnect.page.length > 0 &&
-					!collectionToConnect?.page.some((p) => p.id === data.id)
-				) {
+				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, uid);
+				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
+			// const foundPage = await strapi.entityService?.findOne(PAGE_UID, data.id, { populate: '*' });
+			// if (
+			// 	data.collectionTypeData &&
+			// 	foundPage &&
+			// 	foundPage.collectionTypeData &&
+			// 	+data.collectionTypeData.id !== foundPage.collectionTypeData[0].id
+			// ) {
+			// 	await strapi.entityService?.update(foundPage.collectionTypeData[0].__type, foundPage.collectionTypeData[0].id, {
+			// 		data: {
+			// 			id: foundPage.collectionTypeData[0].id,
+			// 			hasPage: false
+			// 		}
+			// 	});
+			// }
+		},
+		async afterUpdate(event) {
+			const data = event?.params?.data;
+			console.log(data);
+			if (data.collectionTypeData) {
+				await strapi.entityService?.update(data.collectionTypeData.__type, data.collectionTypeData.id, {
+					data: {
+						id: data.collectionTypeData.id,
+						hasPage: true
+					}
+				});
+			}
+		},
+		async afterCreate(event) {
+			const data = event?.params?.data;
+			if (data.collectionTypeData) {
+				await strapi.entityService?.update(data.collectionTypeData.__type, data.collectionTypeData.id, {
+					data: {
+						id: data.collectionTypeData.id,
+						hasPage: true
+					}
+				});
+			}
+		},
+		async beforeDelete(event) {
+			const foundPage = await strapi.entityService?.findOne(PAGE_UID, event.params.where.id, { populate: '*' });
+			if (foundPage && foundPage.collectionTypeData) {
+				await strapi.entityService?.update(foundPage.collectionTypeData[0].__type, foundPage.collectionTypeData[0].id, {
+					data: {
+						id: foundPage.collectionTypeData[0].id,
+						hasPage: false
+					}
+				});
+			}
+		},
+		async beforeDeleteMany(event) {
+			const pagesToUnConnect = event.params.where['$and'][0].id['$in'];
+
+			for (const pageId of pagesToUnConnect) {
+				const foundPage = await strapi.entityService?.findOne(PAGE_UID, pageId, { populate: '*' });
+				if (foundPage && foundPage.collectionTypeData) {
+					await strapi.entityService?.update(
+						foundPage.collectionTypeData[0].__type,
+						foundPage.collectionTypeData[0].id,
+						{
+							data: {
+								id: foundPage.collectionTypeData[0].id,
+								hasPage: false
+							}
+						}
+					);
+				}
 			}
 		}
 	});

package/server/controllers/collection-types.ts

@@ -1,9 +1,10 @@
+import { Strapi } from '@strapi/strapi';
+
 export default {
 	async hasPageRelation(ctx: any) {
 		const uid = ctx.params?.uid;
 
-		// @ts-ignore
-		return strapi.service('plugin::page-builder.collection-types').hasPageRelation(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 || {};
@@ -16,8 +17,7 @@ export default {
 			return undefined;
 		}
 
-		// @ts-ignore
-		return strapi.service('plugin::page-builder.collection-types').getTranslationPageLinks(uid, idsArr);
+		return (strapi as Strapi).service('plugin::page-builder.collection-types').getTranslationPageLinks(uid, idsArr);
 	}
 };
 

package/server/controllers/index.ts

@@ -1,9 +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
+	'collection-types': collectionTypes,
+	template
 };

package/server/controllers/page-type.ts

@@ -1,3 +1,5 @@
+import { Strapi } from '@strapi/strapi';
+
 export default {
 	async findOneByUid(ctx: any) {
 		const uid = ctx?.params?.uid;
@@ -6,7 +8,6 @@ export default {
 			return ctx.badRequest('uid is missing.');
 		}
 
-		// @ts-ignore strapi typings
-		return await strapi.service('plugin::page-builder.page-type').findOneByUid(uid);
+		return await (strapi as Strapi).service('plugin::page-builder.page-type').findOneByUid(uid);
 	}
 };

package/server/controllers/page.ts

@@ -1,20 +1,9 @@
 import { Strapi } from '@strapi/strapi';
 
-import { PAGE_UID } from '../../shared/utils/constants';
-
 export default {
 	async getPage(ctx) {
 		const id = ctx.params?.id;
 
 		return (strapi as Strapi).service('plugin::page-builder.page')?.getPage(id);
-	},
-
-	async findOneBySlug(ctx) {
-		const { slug = '' } = ctx.params;
-
-		const entity = await (strapi as Strapi).service(PAGE_UID)?.find({ filters: { slug } });
-		const sanitizedEntity = await this.sanitizeOutput(entity, ctx);
-
-		return this.transformResponse(sanitizedEntity);
 	}
 };

package/server/controllers/template.ts

@@ -0,0 +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();
+	}
+};

package/server/graphql/index.ts

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

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

@@ -36,7 +36,7 @@ const getPageBySlug = (strapi: Strapi) => {
 								usePagination: false
 							});
 
-							const results = await strapi.entityService.findMany(PAGE_UID, {
+							const results = await strapi.entityService?.findMany(PAGE_UID, {
 								filters: transformedArgs,
 								locale: args._locale,
 								publicationState: args._publicationState,

package/server/graphql/page-type.ts

@@ -1,3 +1,4 @@
+import { Common } from '@strapi/strapi';
 import { ICollectionTypeGL } from '../services/collection-types';
 
 const pageType = ({ nexus }) => {
@@ -15,11 +16,19 @@ const pageType = ({ nexus }) => {
 					type: 'Page',
 					resolve: async (root) => {
 						try {
-							const results = await strapi.entityService.findOne(collectionType.uid, root?.id, {
-								populate: '*'
-							});
+							const results = await strapi.entityService.findOne(
+								collectionType.uid as Common.UID.ContentType,
+								root?.id,
+								{
+									populate: '*'
+								}
+							);
 
-							return results.page?.[0] || null;
+							if (!results) {
+								return null;
+							}
+
+							return results.page?.[0];
 						} catch {
 							return null;
 						}

package/server/graphql/pages-by-uid.ts

@@ -0,0 +1,127 @@
+import { Strapi } from '@strapi/strapi';
+
+import { filterUnderscoreArguments } from '../utils/filter-underscore-arguments';
+import { PAGE_UID } from '../../shared/utils/constants';
+import { Pagination } from '../utils/paginationValidation';
+
+const getPageInfoFromUID = (strapi: Strapi) => {
+	// @ts-ignore service does exist
+	const collectionTypes: ICollectionTypeGL[] = strapi.service('plugin::page-builder.collection-types').withPageMorph();
+
+	const typeDefs = () => {
+		const metaInfo = `type MetaInfo {
+			total: Int
+			page: Int
+			pageCount: Int
+			pageSize: Int
+	}`;
+		const entityInfo = collectionTypes.map((collectionType) => {
+			return `
+				extend type ${collectionType.type}EntityResponseCollection {
+					metaInfo: MetaInfo
+				}
+
+        type Query {
+					get${collectionType.type}Pages(filters: ${collectionType.type}FiltersInput,pagination: PaginationArg, sort:[String], pageFilters: PageFiltersInput): ${collectionType.type}EntityResponseCollection
+        }
+
+      `;
+		});
+
+		return `${metaInfo} ${entityInfo}`;
+	};
+	const resolvers = (strapi: Strapi) => {
+		const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
+		const pageQuery = collectionTypes.map((collectionType) => {
+			return {
+				[`get${collectionType.type}Pages`]: {
+					resolve: async (_parent: any, args: Record<string, any>, ctx: any) => {
+						if (!args.pagination || !args.pagination.page || !args.pagination.pageSize) {
+							throw new Error('page and pageSize is required');
+						}
+
+						const { start, limit } = Pagination.checkPagination(args.pagination.page, args.pagination.pageSize);
+
+						const filteredArgs = {
+							...filterUnderscoreArguments(args)
+						};
+						const pageFilters = { filters: args.pageFilters };
+
+						const { toEntityResponseCollection } = strapi.plugin('graphql').service('format').returnTypes;
+
+						const getPage = async () => {
+							const transformedArgs = transformArgs(filteredArgs, {
+								contentType: strapi.contentTypes[collectionType.uid],
+								usePagination: true
+							});
+
+							const transformedpageArgs = transformArgs(pageFilters, {
+								contentType: strapi.contentTypes[PAGE_UID],
+								usePagination: true
+							});
+
+							const results = await (strapi as Strapi)?.entityService?.findMany(collectionType.uid, {
+								populate: '*',
+								filters: {
+									...transformedArgs.filters,
+									hasPage: { $eq: true },
+									page: { ...transformedpageArgs.filters }
+								},
+								sort: transformedArgs.sort,
+								start: start,
+								limit: limit
+							});
+
+							const entityResponse = toEntityResponseCollection(results || [], {
+								args: transformedArgs,
+								resourceUID: collectionType.uid
+							});
+
+							const entityResponsePaginated = Pagination.getPaginationInfo(
+								transformedpageArgs,
+								transformedArgs,
+								start,
+								args.pagination.pageSize,
+								entityResponse,
+								collectionType.uid
+							);
+
+							return entityResponsePaginated;
+						};
+
+						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);
+						}
+					}
+				}
+			};
+		});
+
+		return {
+			Query: Object.assign({}, ...pageQuery)
+		};
+	};
+
+	const resolversConfig = () => {
+		const configQuery = collectionTypes.map((collectionType) => {
+			return {
+				[`Query.get${collectionType.type}Pages`]: {
+					auth: false
+				}
+			};
+		});
+		return Object.assign({}, ...configQuery);
+	};
+
+	return {
+		typeDefs: typeDefs(),
+		resolvers: resolvers(strapi),
+		resolversConfig: resolversConfig()
+	};
+};
+
+export default getPageInfoFromUID;

package/server/register.ts

@@ -2,12 +2,14 @@ import { Strapi } from '@strapi/strapi';
 
 import getPageBySlug from './graphql/page-by-slug';
 import pageType from './graphql/page-type';
+import getPageInfoFromUID from './graphql/pages-by-uid';
 
 export default async ({ strapi }: { strapi: Strapi }) => {
 	const extensionService = strapi.plugin('graphql').service('extension');
 
 	extensionService.use(pageType);
 	extensionService.use(getPageBySlug(strapi));
+	extensionService.use(getPageInfoFromUID(strapi));
 
 	await strapi.services?.['plugin::page-builder.builder']?.buildContentTypes();
 };

package/server/routes/index.ts

@@ -36,6 +36,22 @@ const routes = {
 				handler: 'collection-types.getTranslationPageLinks'
 			}
 		]
+	},
+	template: {
+		type: 'admin',
+		prefix: undefined,
+		routes: [
+			{
+				method: 'GET',
+				path: '/template',
+				handler: 'template.findAll'
+			},
+			{
+				method: 'GET',
+				path: '/template/:id',
+				handler: 'template.findOneById'
+			}
+		]
 	}
 };
 

package/server/services/builder.ts

@@ -1,6 +1,5 @@
 import partition from 'lodash/partition';
-
-import { Service } from '@strapi/strapi/lib/types/core/common';
+import { Common } from '@strapi/strapi';
 
 import pageStart from '../schema/page-start.json';
 import pageEnd from '../schema/page-end.json';
@@ -11,7 +10,7 @@ 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 = [TEMPLATE_UID, PAGE_TYPE_UID, PAGE_UID];
+const UIDS: Common.UID.ContentType[] = [TEMPLATE_UID, PAGE_TYPE_UID, PAGE_UID];
 
 export default {
 	async buildContentTypes() {
@@ -43,8 +42,8 @@ export default {
 
 		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;
+	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)));
 
@@ -68,7 +67,10 @@ export default {
 
 		if ((updateTypes || []).length > 0) {
 			for await (const updateType of updateTypes) {
-				await ctb.editContentType(updateType.uid, { contentType: updateType.contentType, components: [] });
+				await ctb.editContentType(updateType.uid, {
+					contentType: updateType.contentType,
+					components: []
+				});
 			}
 		}
 	},
@@ -103,14 +105,13 @@ export default {
 		return { uid: PAGE_TYPE_UID, contentType };
 	},
 	getTemplateContentType() {
-		const pageType = templateStart;
-		const contentType = this.mergeCollectionTypeWithModules(pageType, TEMPLATE_UID);
+		const template = templateStart;
+		const contentType = this.mergeCollectionTypeWithModules(template, TEMPLATE_UID);
 
 		return { uid: TEMPLATE_UID, contentType };
 	},
-	mergeCollectionTypeWithModules(collectionType: Record<string, any>, uid: string) {
-		const { pluginOptions: oldPluginOptions, __schema__: oldSchema } = strapi.contentType(uid) || {};
-
+	mergeCollectionTypeWithModules(collectionType: Record<string, any>, uid: Common.UID.ContentType) {
+		const { pluginOptions: oldPluginOptions, __schema__: oldSchema } = (strapi.contentType(uid) as any) || {};
 		const components = this.getConfigModuleComponents();
 
 		return {
@@ -127,6 +128,6 @@ export default {
 		};
 	},
 	getConfigModuleComponents() {
-		return (strapi.config.get(`plugin.${pluginId}`)?.modules || []).filter(Boolean);
+		return ((strapi.config.get(`plugin.${pluginId}`) as Record<string, any>)?.modules || []).filter(Boolean);
 	}
 };

package/server/services/collection-types.ts

@@ -1,5 +1,5 @@
-import { Strapi } from '@strapi/strapi';
 import uniqBy from 'lodash/uniqBy';
+import { Common } from '@strapi/strapi';
 
 import { IGetTranslationPageLinks } from '../controllers/collection-types';
 import { PAGE_TYPE_UID } from '../../shared/utils/constants';
@@ -13,7 +13,7 @@ export interface ICollectionTypeGL {
 export default {
 	async hasPageRelation(uid: string): Promise<{ hasPageRelation: boolean }> {
 		const contentType = strapi.contentTypes?.[uid];
-		const pageTypesWithUid: any[] =
+		const pageTypesWithUid =
 			(await strapi.entityService.findMany(PAGE_TYPE_UID, {
 				filters: {
 					uid: {
@@ -26,7 +26,7 @@ export default {
 			hasPageRelation: Boolean(
 				contentType?.attributes?.page &&
 					contentType?.attributes?.page?.morphBy === 'collectionTypeData' &&
-					pageTypesWithUid.length > 0
+					(pageTypesWithUid as Record<string, any>[]).length > 0
 			)
 		};
 	},
@@ -52,9 +52,9 @@ export default {
 
 		return collectionTypes;
 	},
-	async getTranslationPageLinks(uid: string, ids: string[]) {
+	async getTranslationPageLinks(uid: Common.UID.ContentType, ids: string[]) {
 		try {
-			const entities = await (strapi as Strapi).entityService.findMany(uid, {
+			const entities = await strapi.entityService.findMany(uid, {
 				filters: {
 					id: { $in: ids }
 				},
@@ -65,7 +65,7 @@ export default {
 						}
 					}
 				}
-			});
+			} as any);
 
 			let pages: IGetTranslationPageLinks[] = [];
 

package/server/services/index.ts

@@ -2,10 +2,12 @@ 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
+	'collection-types': collectionTypes,
+	template
 };

package/server/services/page-type.ts

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

package/server/services/template.ts

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