@webbio/strapi-plugin-page-builder 0.0.12 → 0.0.13

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
+		};
+	}
+};

package/server/utils/graphql.ts

@@ -0,0 +1,110 @@
+import { Strapi } from '@strapi/strapi';
+import { PAGE_UID } from '../../shared/utils/constants';
+
+const findPageByPath = (strapi: Strapi) => {
+	const typeDefs = `
+  type Query {
+    findPageByPath(path: String, locale: I18NLocaleCode): PageEntityResponse 
+  }
+  `;
+
+	const resolvers = (strapi: Strapi) => {
+		const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
+		const { toEntityResponse, toEntityResponseCollection } = strapi.plugin('graphql').service('format').returnTypes;
+
+		return {
+			Query: {
+				findPageByPath: {
+					resolve: async (parent: any, args: Record<string, any>, ctx: any) => {
+						const contentType = strapi.getModel(PAGE_UID);
+						const transformedArgs = transformArgs(args, { contentType });
+
+						const queryResult = await strapi.entityService.findMany(contentType.uid, {
+							filters: {
+								path: {
+									$eq: transformedArgs.path
+								}
+							},
+							locale: transformedArgs.locale
+						});
+
+						const result = queryResult?.[0];
+						return toEntityResponse(result, { args: transformedArgs, resourceUID: contentType.uid });
+					}
+				}
+			}
+		};
+	};
+
+	const resolversConfig = {
+		'Query.findPageByPath': {
+			auth: false
+		}
+	};
+
+	return {
+		typeDefs,
+		resolvers: resolvers(strapi),
+		resolversConfig
+	};
+};
+
+const findPagePaths = (strapi: Strapi) => {
+	const typeDefs = `
+  type PageByPath {
+    id: Int!
+    path: String!
+    title: String!
+    locale: String!
+    pageType: ENUM_PAGE_PAGETYPE
+    updatedAt: DateTime!
+    publishedAt: DateTime!
+  }
+
+  type Query {
+    findPagePaths(locale: String, pageType: String = "all"): [PageByPath]
+  }
+  `;
+
+	const resolvers = (strapi: Strapi) => {
+		const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
+
+		return {
+			Query: {
+				findPagePaths: {
+					resolve: async (parent: any, args: Record<string, any>, ctx: any) => {
+						const contentType = strapi.getModel(PAGE_UID);
+						const transformedArgs = transformArgs(args, { contentType });
+
+						const queryResult = await strapi.entityService.findMany(contentType.uid, {
+							populate: '*',
+							locale: transformedArgs.locale
+						});
+
+						const result = queryResult.filter((page) => page?.path);
+
+						return result;
+					}
+				}
+			}
+		};
+	};
+
+	const resolversConfig = {
+		'Query.findPagePaths': {
+			auth: false
+		}
+	};
+
+	return {
+		typeDefs,
+		resolvers: resolvers(strapi),
+		resolversConfig
+	};
+};
+
+export const registerGraphQLResolvers = (strapi: Strapi) => {
+	const extensionService = strapi.plugin('graphql').service('extension');
+	extensionService.use(findPageByPath(strapi));
+	extensionService.use(findPagePaths(strapi));
+};

package/server/utils/reload-strapi-on-load.ts

@@ -0,0 +1,13 @@
+const reloadStrapiOnLoad = () => {
+	console.log('[Plugin Page Builder]: Checking if strapi is loaded', strapi.isLoaded);
+
+	if (strapi.isLoaded) {
+		strapi.reload();
+
+		return;
+	}
+
+	setTimeout(reloadStrapiOnLoad, 1000);
+};
+
+export { reloadStrapiOnLoad };

package/shared/utils/constants.ts

@@ -0,0 +1,4 @@
+export const PAGE_UID = 'api::page.page';
+export const TEMPLATE_UID = 'api::template.template';
+export const PAGE_TYPE_UID = 'api::page-type.page-type';
+export const PAGE_TYPE_PAGE = 'page';

package/shared/utils/sleep.ts

@@ -0,0 +1 @@
+export const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));

package/strapi-admin.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./admin/src').default;

package/strapi-server.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./dist/server');

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+	"extends": "@strapi/typescript-utils/tsconfigs/admin",
+
+	"compilerOptions": {
+		"target": "ESNext",
+		"strict": true
+	},
+
+	"include": ["admin", "custom.d.ts"],
+
+	"exclude": [
+		"node_modules/",
+		"dist/",
+
+		// Do not include server files in the server compilation
+		"server/",
+		// Do not include test files
+		"**/*.test.ts"
+	]
+}

package/tsconfig.server.json

@@ -0,0 +1,25 @@
+{
+	"extends": "@strapi/typescript-utils/tsconfigs/server",
+
+	"compilerOptions": {
+		"outDir": "dist",
+		"rootDir": "."
+	},
+
+	"include": [
+		// Include the root directory
+		"server",
+		// Force the JSON files in the src folder to be included
+		"server/**/*.json"
+	],
+
+	"exclude": [
+		"node_modules/",
+		"dist/",
+
+		// Do not include admin files in the server compilation
+		"admin/",
+		// Do not include test files
+		"**/*.test.ts"
+	]
+}