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

package/server/routes/index.ts

@@ -1,42 +0,0 @@
-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

@@ -1,97 +0,0 @@
-{
-	"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

@@ -1,87 +0,0 @@
-{
-	"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

@@ -1,49 +0,0 @@
-{
-	"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

@@ -1,44 +0,0 @@
-{
-	"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

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

@@ -1,49 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

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

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