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

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

@@ -1,98 +1,98 @@
-import { Strapi } from '@strapi/strapi';
-
-import { filterUnderscoreArguments } from '../utils/filter-underscore-arguments';
-import { PAGE_UID } from '../../shared/utils/constants';
-
-const getPageBySlug = (strapi: Strapi) => {
-	const typeDefs = () => {
-		return `
-				extend type Page {
-					collectionType: GenericMorph
-				}
-
-        type Query {
-          getPageBySlug(path: String, _locale: String, _publicationState: PublicationState): PageEntity
-        }
-
-      `;
-	};
-
-	const resolvers = (strapi: Strapi) => {
-		const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
-
-		return {
-			Query: {
-				getPageBySlug: {
-					resolve: async (_parent: any, args: Record<string, any>, ctx: any) => {
-						const filteredArgs = {
-							...filterUnderscoreArguments(args)
-						};
-
-						const { toEntityResponse } = strapi.plugin('graphql').service('format').returnTypes;
-
-						const getPage = async () => {
-							const transformedArgs = transformArgs(filteredArgs, {
-								contentType: strapi.contentTypes[PAGE_UID],
-								usePagination: false
-							});
-
-							const results = await strapi.entityService?.findMany(PAGE_UID, {
-								filters: transformedArgs,
-								locale: args._locale,
-								publicationState: args._publicationState,
-								populate: '*'
-							});
-
-							const entityResponse = toEntityResponse(results?.[0] || {}, {
-								args: transformedArgs,
-								resourceUID: PAGE_UID
-							});
-
-							if (!entityResponse?.value || Object.keys(entityResponse.value).length === 0) {
-								throw new Error(ctx.koaContext.response.message);
-							}
-
-							const collectionTypeDataFilter = entityResponse?.value?.collectionTypeData?.filter(Boolean);
-
-							const collectionType: Record<string, any> | null =
-								collectionTypeDataFilter.length === 1 ? collectionTypeDataFilter?.[0] : null;
-
-							const addedAttributes = {
-								collectionType: collectionType
-							};
-
-							const result = {
-								...entityResponse.value,
-								...addedAttributes
-							};
-
-							return result;
-						};
-
-						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);
-						}
-					}
-				}
-			}
-		};
-	};
-
-	const resolversConfig = {
-		'Query.getPageBySlug': {
-			auth: false
-		}
-	};
-
-	return {
-		typeDefs: typeDefs(),
-		resolvers: resolvers(strapi),
-		resolversConfig
-	};
-};
-
-export default getPageBySlug;
+import { Strapi } from '@strapi/strapi';
+
+import { filterUnderscoreArguments } from '../utils/filter-underscore-arguments';
+import { PAGE_UID } from '../../shared/utils/constants';
+
+const getPageBySlug = (strapi: Strapi) => {
+	const typeDefs = () => {
+		return `
+				extend type Page {
+					collectionType: GenericMorph
+				}
+
+        type Query {
+          getPageBySlug(path: String, _locale: String, _publicationState: PublicationState): PageEntity
+        }
+
+      `;
+	};
+
+	const resolvers = (strapi: Strapi) => {
+		const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
+
+		return {
+			Query: {
+				getPageBySlug: {
+					resolve: async (_parent: any, args: Record<string, any>, ctx: any) => {
+						const filteredArgs = {
+							...filterUnderscoreArguments(args)
+						};
+
+						const { toEntityResponse } = strapi.plugin('graphql').service('format').returnTypes;
+
+						const getPage = async () => {
+							const transformedArgs = transformArgs(filteredArgs, {
+								contentType: strapi.contentTypes[PAGE_UID],
+								usePagination: false
+							});
+
+							const results = await strapi.entityService?.findMany(PAGE_UID, {
+								filters: transformedArgs,
+								locale: args._locale,
+								publicationState: args._publicationState,
+								populate: '*'
+							});
+
+							const entityResponse = toEntityResponse(results?.[0] || {}, {
+								args: transformedArgs,
+								resourceUID: PAGE_UID
+							});
+
+							if (!entityResponse?.value || Object.keys(entityResponse.value).length === 0) {
+								throw new Error(ctx.koaContext.response.message);
+							}
+
+							const collectionTypeDataFilter = entityResponse?.value?.collectionTypeData?.filter(Boolean);
+
+							const collectionType: Record<string, any> | null =
+								collectionTypeDataFilter.length === 1 ? collectionTypeDataFilter?.[0] : null;
+
+							const addedAttributes = {
+								collectionType: collectionType
+							};
+
+							const result = {
+								...entityResponse.value,
+								...addedAttributes
+							};
+
+							return result;
+						};
+
+						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);
+						}
+					}
+				}
+			}
+		};
+	};
+
+	const resolversConfig = {
+		'Query.getPageBySlug': {
+			auth: false
+		}
+	};
+
+	return {
+		typeDefs: typeDefs(),
+		resolvers: resolvers(strapi),
+		resolversConfig
+	};
+};
+
+export default getPageBySlug;

package/server/graphql/page-type.ts

@@ -1,67 +1,67 @@
-import { Common } from '@strapi/strapi';
-import { ICollectionTypeGL } from '../services/collection-types';
-
-const pageType = ({ nexus }) => {
-	// @ts-ignore service does exist
-	const collectionTypes: ICollectionTypeGL[] = strapi.service('plugin::page-builder.collection-types').withPageMorph();
-
-	// Extends collectiontype types to include extra fields.
-	const collectionTypesNexus = collectionTypes.map((collectionType) =>
-		nexus.extendType({
-			type: collectionType.type,
-			definition(t: any) {
-				t.string('id', { resolve: (root) => root?.id || null });
-				t.string('uid', { resolve: () => collectionType?.uid || null });
-				t.field('page', {
-					type: 'Page',
-					resolve: async (root) => {
-						try {
-							const results = await strapi.entityService.findOne(
-								collectionType.uid as Common.UID.ContentType,
-								root?.id,
-								{
-									populate: '*'
-								}
-							);
-
-							if (!results) {
-								return null;
-							}
-
-							return results.page?.[0];
-						} catch {
-							return null;
-						}
-					}
-				});
-			}
-		})
-	);
-
-	// Extends the page type to include its id.
-	const pageTypeExtendNexus = nexus.extendType({
-		type: 'Page',
-		definition(t: any) {
-			t.string('id', { resolve: (root) => root?.id || null });
-		}
-	});
-
-	// Extends the inputTypes for collectiontypes so filtering on Page is possible.
-	// This however gives a problem when querying, for now we cannot use this.
-	// const collectionInputTypesNexus = collectionTypes.map((collectionType) =>
-	// 	nexus.extendInputType({
-	// 		type: collectionType.inputType,
-	// 		definition(t) {
-	// 			t.field('page', {
-	// 				type: 'PageFiltersInput',
-	// 			});
-	// 		}
-	// 	})
-	// );
-
-	return {
-		types: [pageTypeExtendNexus, ...collectionTypesNexus]
-	};
-};
-
-export default pageType;
+import { Common } from '@strapi/strapi';
+import { ICollectionTypeGL } from '../services/collection-types';
+
+const pageType = ({ nexus }) => {
+	// @ts-ignore service does exist
+	const collectionTypes: ICollectionTypeGL[] = strapi.service('plugin::page-builder.collection-types').withPageMorph();
+
+	// Extends collectiontype types to include extra fields.
+	const collectionTypesNexus = collectionTypes.map((collectionType) =>
+		nexus.extendType({
+			type: collectionType.type,
+			definition(t: any) {
+				t.string('id', { resolve: (root) => root?.id || null });
+				t.string('uid', { resolve: () => collectionType?.uid || null });
+				t.field('page', {
+					type: 'Page',
+					resolve: async (root) => {
+						try {
+							const results = await strapi.entityService.findOne(
+								collectionType.uid as Common.UID.ContentType,
+								root?.id,
+								{
+									populate: '*'
+								}
+							);
+
+							if (!results) {
+								return null;
+							}
+
+							return results.page?.[0];
+						} catch {
+							return null;
+						}
+					}
+				});
+			}
+		})
+	);
+
+	// Extends the page type to include its id.
+	const pageTypeExtendNexus = nexus.extendType({
+		type: 'Page',
+		definition(t: any) {
+			t.string('id', { resolve: (root) => root?.id || null });
+		}
+	});
+
+	// Extends the inputTypes for collectiontypes so filtering on Page is possible.
+	// This however gives a problem when querying, for now we cannot use this.
+	// const collectionInputTypesNexus = collectionTypes.map((collectionType) =>
+	// 	nexus.extendInputType({
+	// 		type: collectionType.inputType,
+	// 		definition(t) {
+	// 			t.field('page', {
+	// 				type: 'PageFiltersInput',
+	// 			});
+	// 		}
+	// 	})
+	// );
+
+	return {
+		types: [pageTypeExtendNexus, ...collectionTypesNexus]
+	};
+};
+
+export default pageType;

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

@@ -1,127 +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;
+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/index.ts

@@ -1,23 +1,23 @@
-import register from './register';
-import bootstrap from './bootstrap';
-import destroy from './destroy';
-import config from './config';
-import contentTypes from './content-types';
-import controllers from './controllers';
-import routes from './routes';
-import middlewares from './middlewares';
-import policies from './policies';
-import services from './services';
-
-export default {
-	register,
-	bootstrap,
-	destroy,
-	config,
-	controllers,
-	routes,
-	services,
-	contentTypes,
-	policies,
-	middlewares
-};
+import register from './register';
+import bootstrap from './bootstrap';
+import destroy from './destroy';
+import config from './config';
+import contentTypes from './content-types';
+import controllers from './controllers';
+import routes from './routes';
+import middlewares from './middlewares';
+import policies from './policies';
+import services from './services';
+
+export default {
+	register,
+	bootstrap,
+	destroy,
+	config,
+	controllers,
+	routes,
+	services,
+	contentTypes,
+	policies,
+	middlewares
+};

package/server/middlewares/index.ts

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

package/server/policies/index.ts

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

package/server/register.ts

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