@webbio/strapi-plugin-page-builder 0.3.7-platform → 0.3.8-legacy

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

@@ -1,105 +0,0 @@
-import { Strapi } from '@strapi/strapi';
-
-import { filterUnderscoreArguments } from '../utils/filter-underscore-arguments';
-import { PAGE_UID } from '../../shared/utils/constants';
-
-const getPageByPath = (strapi: Strapi) => {
-	const typeDefs = () => {
-		return `
-				extend type Page {
-					collectionType: GenericMorph
-				}
-
-        type Query {
-          getPageByPath(path: String, _domain: String, _locale: String, _publicationState: PublicationState): PageEntity
-        }
-
-      `;
-	};
-
-	const resolvers = (strapi: Strapi) => {
-		const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
-
-		return {
-			Query: {
-				getPageByPath: {
-					resolve: async (_parent: any, args: Record<string, any>, ctx: any) => {
-						try {
-							const filteredArgs = {
-								...filterUnderscoreArguments(args),
-								platform: { domain: args._domain }
-							};
-
-							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: filteredArgs,
-									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);
-							}
-						} catch (error) {
-							console.log('Error in getPageByPath:', error);
-
-							throw new Error(ctx.koaContext.response.message);
-						}
-					}
-				}
-			}
-		};
-	};
-
-	const resolversConfig = {
-		'Query.getPageByPath': {
-			auth: false
-		}
-	};
-
-	return {
-		typeDefs: typeDefs(),
-		resolvers: resolvers(strapi),
-		resolversConfig
-	};
-};
-
-export default getPageByPath;

package/server/schema/platform-start.json

@@ -1,31 +0,0 @@
-{
-	"draftAndPublish": false,
-	"displayName": "Platforms",
-	"singularName": "platform",
-	"pluralName": "platforms",
-	"description": "",
-	"plugin": "page-builder",
-	"pluginOptions": {},
-	"kind": "collectionType",
-	"collectionName": "platforms",
-	"attributes": {
-		"title": {
-			"type": "string",
-			"required": true,
-			"unique": true
-		},
-		"domain": {
-			"type": "string"
-		},
-		"template": {
-			"type": "relation",
-			"relation": "oneToMany",
-			"target": "api::template.template"
-		},
-		"pageTypes": {
-			"type": "relation",
-			"relation": "oneToMany",
-			"target": "api::page-type.page-type"
-		}
-	}
-}

package/server/services/platform.ts

@@ -1,36 +0,0 @@
-import { Common } from '@strapi/strapi';
-import { PLATFORM_UID } from '../../shared/utils/constants';
-
-export default {
-	async findAll() {
-		return await strapi.entityService.findMany(PLATFORM_UID, { populate: '*' });
-	},
-	async findOneByUid(uid: Common.UID.ContentType) {
-		return await strapi.entityService.findMany(PLATFORM_UID, {
-			populate: '*',
-			filters: {
-				pagetype: {
-					uid
-				}
-			}
-		});
-	},
-	async findPageTypesByPlatform(platform: string) {
-		const results = await strapi.entityService.findMany(PLATFORM_UID, {
-			populate: {
-				pagetype: true
-			},
-			filters: {
-				title: {
-					$eq: platform
-				}
-			}
-		});
-
-		if ((results as any[]).length > 0) {
-			return results;
-		} else {
-			return null;
-		}
-	}
-};