@webbio/strapi-plugin-page-builder 0.3.2 → 0.3.3-legacy

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webbio/strapi-plugin-page-builder",
-	"version": "0.3.2",
+	"version": "0.3.3-legacy",
 	"description": "This is the description of the plugin.",
 	"scripts": {
 		"develop": "tsc -p tsconfig.server.json -w",
@@ -20,14 +20,16 @@
 		"url": "https://github.com/webbio/strapi-plugin-page-builder.git"
 	},
 	"dependencies": {
-		"@strapi/design-system": "^1.11.0",
-		"@strapi/helper-plugin": "^4.15.0",
+		"@strapi/design-system": "^1.13.1",
+		"@strapi/helper-plugin": "<4.15.0",
 		"@strapi/icons": "^1.11.0",
-		"@strapi/typescript-utils": "^4.15.0",
-		"@strapi/utils": "^4.15.0",
-		"react-select": "^5.7.4"
+		"@strapi/typescript-utils": "<4.15.0",
+		"@strapi/utils": "<4.15.0",
+		"react-select": "^5.7.4",
+		"slugify": "^1.6.6"
 	},
 	"devDependencies": {
+		"@strapi/typescript-utils": "<4.15.0",
 		"@types/react": "^18.2.21",
 		"@types/react-dom": "^18.2.7",
 		"@types/react-router-dom": "^5.3.3",
@@ -39,8 +41,8 @@
 		"typescript": "5.1.6"
 	},
 	"peerDependencies": {
-		"@strapi/strapi": "^4.15.0",
-		"@webbio/strapi-plugin-slug": "^2.0.2",
+		"@strapi/strapi": "<4.15.0",
+		"@webbio/strapi-plugin-slug": "^2.0.5",
 		"react": "^17.0.0 || ^18.0.0",
 		"react-dom": "^17.0.0 || ^18.0.0",
 		"react-router-dom": "^5.3.4",
@@ -59,7 +61,7 @@
 		}
 	],
 	"engines": {
-		"node": ">=14.19.1 <=18.x.x",
+		"node": ">=14.19.1 <=20.x.x",
 		"npm": ">=6.0.0"
 	},
 	"license": "MIT",

package/server/bootstrap/collection-type-lifecycles.ts

@@ -37,7 +37,7 @@ export default async ({ strapi }: { strapi: Strapi }) => {
 						data: {
 							updatedAt: data.updatedAt
 						}
-					} as Record<string, any>);
+					} as any);
 				}
 			} catch (error) {
 				console.log('[PAGEBUILDER PLUGIN] collection type lifecycle error: ', error);

package/server/bootstrap.ts

@@ -1,6 +1,6 @@
 import { Common, Strapi } from '@strapi/strapi';
 import { errors } from '@strapi/utils';
-import { PAGE_TYPE_UID, PAGE_UID, PLATFORM_UID } from '../shared/utils/constants';
+import { PAGE_TYPE_UID, PAGE_UID } from '../shared/utils/constants';
 import permissions from './bootstrap/permissions';
 import collectionTypeLifecycles from './bootstrap/collection-type-lifecycles';
 
@@ -27,7 +27,6 @@ export default async ({ strapi }: { strapi: Strapi }) => {
 			let { data } = event.params;
 			const collectionTypeId = data?.collectionTypeId;
 			const pageTypeId = data?.pageType.connect?.[0]?.id || data.initialPageType;
-			const platformId = data?.platform.connect?.[0]?.id;
 
 			if (collectionTypeId && pageTypeId) {
 				const pageType: Record<string, any> | undefined | null = await strapi.entityService?.findOne(
@@ -40,26 +39,10 @@ export default async ({ strapi }: { strapi: Strapi }) => {
 
 				const page: Record<string, any>[] = collectionToConnect?.page as any;
 
-				const foundPlatforms: Record<string, any> | undefined | null = await strapi.entityService?.findMany(
-					PLATFORM_UID,
-					{
-						populate: '*',
-						filters: {
-							pagetype: {
-								uid: pageType?.uid
-							}
-						}
-					}
-				);
-
 				if (page && page.length > 0) {
 					throw new errors.ValidationError('You can only link one CollectionType to one page');
 				}
 
-				if (platformId && !foundPlatforms?.some((platform) => platform.id === platformId)) {
-					throw new errors.ValidationError('Platform not found');
-				}
-
 				data = updateCollectionTypeData(data, collectionTypeId, pageType?.uid);
 			}
 		},
@@ -115,6 +98,8 @@ export default async ({ strapi }: { strapi: Strapi }) => {
 				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
 			if (
 				data.collectionTypeData &&
 				originalEntity?.collectionTypeData?.[0]?.__type &&
@@ -137,32 +122,28 @@ export default async ({ strapi }: { strapi: Strapi }) => {
 			}
 		},
 		async afterUpdate(event) {
-			const data = event?.params?.data;
-
-			if (data.collectionTypeData?.__type && data.collectionTypeData.id) {
-				await strapi.entityService?.update(data.collectionTypeData.__type, data.collectionTypeData.id, {
-					data: {
-						id: data.collectionTypeData.id,
-						hasPage: true,
-						lifecycleState: {
-							exit: true
-						}
-					}
-				});
-			}
-		},
-		async afterCreate(event) {
-			const data = event?.params?.data;
-			if (data.collectionTypeData?.__type && data.collectionTypeData.id) {
-				await strapi.entityService?.update(data.collectionTypeData.__type, data.collectionTypeData.id, {
-					data: {
-						id: data.collectionTypeData.id,
-						hasPage: true,
-						lifecycleState: {
-							exit: true
+			try {
+				// Result not correctly typed within Strapi
+				const data = event?.['result'];
+				const hasCollectionTypeRelation =
+					data && data?.collectionTypeData?.[0] && data?.collectionTypeData[0].__type && data?.collectionTypeData[0].id;
+
+				if (hasCollectionTypeRelation) {
+					const isPublished = data.publishedAt !== undefined;
+					const pageData = isPublished ? { hasPage: !!data.publishedAt } : {};
+
+					await strapi.entityService?.update(data.collectionTypeData[0].__type, data.collectionTypeData[0].id, {
+						data: {
+							...pageData,
+							id: data.collectionTypeData[0].id,
+							lifecycleState: {
+								exit: true
+							}
 						}
-					}
-				});
+					});
+				}
+			} catch (error) {
+				console.error('Failed to save hasPage data', error);
 			}
 		},
 		async beforeDelete(event) {

package/server/controllers/index.ts

@@ -2,12 +2,10 @@ import page from './page';
 import pageType from './page-type';
 import collectionTypes from './collection-types';
 import template from './template';
-import platform from './platform';
 
 export default {
 	page,
 	'page-type': pageType,
 	'collection-types': collectionTypes,
-	template,
-	platform
+	template
 };

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

@@ -16,16 +16,13 @@ const getPageInfoFromUID = (strapi: Strapi) => {
 			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, pageFilters: PageFiltersInput): ${collectionType.type}EntityResponseCollection
-        }
+			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}`;
@@ -67,6 +64,7 @@ const getPageInfoFromUID = (strapi: Strapi) => {
 									hasPage: { $eq: true },
 									page: { ...transformedpageArgs.filters }
 								},
+								sort: transformedArgs.sort,
 								start: start,
 								limit: limit
 							});

package/server/routes/index.ts

@@ -52,27 +52,6 @@ const routes = {
 				handler: 'template.findOneById'
 			}
 		]
-	},
-	platform: {
-		type: 'admin',
-		prefix: undefined,
-		routes: [
-			{
-				method: 'GET',
-				path: '/platform',
-				handler: 'platform.findAll'
-			},
-			{
-				method: 'GET',
-				path: '/platform/:uid',
-				handler: 'platform.findOneByUid'
-			},
-			{
-				method: 'GET',
-				path: '/platform/:platform/page-types',
-				handler: 'platform.findPageTypesByPlatform'
-			}
-		]
 	}
 };
 

package/server/schema/page-end.json

@@ -86,11 +86,6 @@
 			"type": "relation",
 			"relation": "oneToOne",
 			"target": "api::page-type.page-type"
-		},
-		"platform": {
-			"type": "relation",
-			"relation": "oneToOne",
-			"target": "api::platform.platform"
 		}
 	}
 }

package/server/services/builder.ts

@@ -4,14 +4,13 @@ import { Common } from '@strapi/strapi';
 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, PLATFORM_UID } from '../../shared/utils/constants';
+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 templateStart from '../schema/template-start.json';
-import platformStart from '../schema/platform-start.json';
 
-const UIDS: Common.UID.ContentType[] = [TEMPLATE_UID, PAGE_TYPE_UID, PLATFORM_UID, PAGE_UID];
+const UIDS: Common.UID.ContentType[] = [TEMPLATE_UID, PAGE_TYPE_UID, PAGE_UID];
 
 export default {
 	async buildContentTypes() {
@@ -88,10 +87,6 @@ export default {
 			[TEMPLATE_UID]: {
 				create: this.getTemplateContentType(),
 				update: this.getTemplateContentType()
-			},
-			[PLATFORM_UID]: {
-				create: this.getPlatformContentType(),
-				update: this.getPlatformContentType()
 			}
 		};
 
@@ -99,30 +94,23 @@ export default {
 	},
 	getPageContentType(create?: boolean) {
 		const page = create ? pageStart : pageEnd;
-		const contentType = this.mergeCollectionTypeWithOld(page, PAGE_UID);
+		const contentType = this.mergeCollectionTypeWithModules(page, PAGE_UID);
 
 		return { uid: PAGE_UID, contentType };
 	},
 	getPageTypeContentType(create?: boolean) {
 		const pageType = create ? pageTypeStart : pageTypeEnd;
-		const contentType = this.mergeCollectionTypeWithOld(pageType, PAGE_TYPE_UID);
+		const contentType = this.mergeCollectionTypeWithModules(pageType, PAGE_TYPE_UID);
 
 		return { uid: PAGE_TYPE_UID, contentType };
 	},
 	getTemplateContentType() {
 		const template = templateStart;
-		const contentType = this.mergeCollectionTypeWithOld(template, TEMPLATE_UID);
+		const contentType = this.mergeCollectionTypeWithModules(template, TEMPLATE_UID);
 
 		return { uid: TEMPLATE_UID, contentType };
 	},
-	getPlatformContentType() {
-		const platform = platformStart;
-
-		const contentType = this.mergeCollectionTypeWithOld(platform, PLATFORM_UID);
-
-		return { uid: PLATFORM_UID, contentType };
-	},
-	mergeCollectionTypeWithOld(collectionType: Record<string, any>, uid: Common.UID.ContentType) {
+	mergeCollectionTypeWithModules(collectionType: Record<string, any>, uid: Common.UID.ContentType) {
 		const { pluginOptions: oldPluginOptions, __schema__: oldSchema } = (strapi.contentType(uid) as any) || {};
 		const modulesFromConfig = oldSchema?.attributes?.modules ? this.getConfigModuleComponents() : undefined;
 

package/server/services/index.ts

@@ -3,13 +3,11 @@ import builder from './builder';
 import pageType from './page-type';
 import collectionTypes from './collection-types';
 import template from './template';
-import platform from './platform';
 
 export default {
 	page,
 	builder,
 	'page-type': pageType,
 	'collection-types': collectionTypes,
-	template,
-	platform
+	template
 };

package/server/services/template.ts

@@ -8,7 +8,6 @@ export default {
 		return foundTemplates;
 	},
 	async findOne(id: number) {
-		const getpopulatedTemplate = getPopulatedEntity(TEMPLATE_UID, id);
-		return getpopulatedTemplate;
+		return await getPopulatedEntity(TEMPLATE_UID, id);
 	}
 };

package/server/utils/strapi.ts

@@ -14,17 +14,13 @@ export const getDeepPopulate = (uid: Common.UID.Component, populate?: any, depth
 	return Object.keys(attributes).reduce((populateAcc, attributeName) => {
 		const attribute = attributes[attributeName];
 
-		if (attribute.type === 'relation') {
-			return populateAcc;
-		}
-
 		if (attribute.type === 'component') {
 			populateAcc[attributeName] = {
 				populate: getDeepPopulate(attribute.component, null, depth + 1)
 			};
 		}
 
-		if (attribute.type === 'media') {
+		if (attribute.type === 'relation' || attribute.type === 'media') {
 			populateAcc[attributeName] = true;
 		}
 

package/shared/utils/constants.ts

@@ -1,6 +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 PLATFORM_UID = 'api::platform.platform';
 export const PAGE_TYPE_PAGE = 'page';
-export const PLATFORM = 'platform';

package/admin/src/api/platform.ts

@@ -1,34 +0,0 @@
-import { useQuery } from 'react-query';
-
-import { useFetchClient } from '@strapi/helper-plugin';
-
-import getRequestUrl from '../utils/getRequestUrl';
-import { PageType } from './page-type';
-
-export type Platform = {
-	id: number;
-	title?: string;
-	pageTypes?: PageType[];
-};
-
-const QUERY_KEY = 'platforms';
-
-const fetchPlatforms = async ({ fetchClient }: any): Promise<Platform[]> => {
-	const { get } = fetchClient;
-	const result = await get(getRequestUrl(`/platform`));
-
-	return result?.data?.map((entity: any) => ({
-		id: entity.id,
-		title: entity.title,
-		pageTypes: entity.pageTypes
-	}));
-};
-
-export const useGetPlatforms = (params: any) => {
-	const fetchClient = useFetchClient();
-	params = {
-		...params,
-		fetchClient
-	};
-	return useQuery<Platform[], Error>(QUERY_KEY, () => fetchPlatforms(params));
-};

package/admin/src/components/EditView/Platform/platform-select.tsx

@@ -1,30 +0,0 @@
-import React from 'react';
-
-import { SingleSelect, SingleSelectOption } from '@strapi/design-system';
-
-import { Platform } from '../../../api/platform';
-import { PLATFORM } from '../../../../../shared/utils/constants';
-
-interface Props {
-	onChange: (platformId: string) => void;
-	selectedPlatform?: Platform | null;
-	platforms?: Platform[];
-}
-
-export const PlatformSelect = ({ onChange, platforms, selectedPlatform }: Props) => {
-	return (
-		<SingleSelect
-			label="Platform"
-			placeholder="Choose a platform"
-			value={selectedPlatform?.id || PLATFORM}
-			onChange={onChange}
-		>
-			<SingleSelectOption value={PLATFORM}>Platform</SingleSelectOption>
-			{platforms?.map((pageType: Platform) => (
-				<SingleSelectOption key={pageType?.id} value={pageType?.id}>
-					{pageType?.title}
-				</SingleSelectOption>
-			))}
-		</SingleSelect>
-	);
-};

package/admin/src/components/PageFilters/PageTypeFilter/index.tsx

@@ -1,39 +0,0 @@
-import React from 'react';
-
-import { SingleSelectOption, SingleSelect } from '@strapi/design-system';
-
-import { PageType } from '../../../api/page-type';
-import { PAGE_TYPE_NO_FILTER } from '../../../constants';
-import { PAGE_TYPE_PAGE } from '../../../../../shared/utils/constants';
-
-interface Props {
-	onChange: (pageTypeUId: string) => void;
-	selectedPageTypeUid?: string;
-	pageTypes?: PageType[];
-}
-
-const PageTypeFilter = ({ onChange, pageTypes, selectedPageTypeUid }: Props) => {
-	return (
-		<SingleSelect
-			placeholder="Select page type"
-			onChange={onChange}
-			size="S"
-			value={selectedPageTypeUid}
-			disabled={(pageTypes?.length || 0) === 0}
-		>
-			<SingleSelectOption key={PAGE_TYPE_NO_FILTER} value={PAGE_TYPE_NO_FILTER}>
-				All Pagetypes
-			</SingleSelectOption>
-			<SingleSelectOption key={PAGE_TYPE_PAGE} value={PAGE_TYPE_PAGE}>
-				Page
-			</SingleSelectOption>
-			{pageTypes?.map((pageType) => (
-				<SingleSelectOption key={pageType.uid} value={pageType.uid}>
-					{pageType.title || pageType.uid}
-				</SingleSelectOption>
-			))}
-		</SingleSelect>
-	);
-};
-
-export default PageTypeFilter;

package/admin/src/components/PageFilters/PlatformFilter/index.tsx

@@ -1,28 +0,0 @@
-import React from 'react';
-
-import { SingleSelectOption, SingleSelect } from '@strapi/design-system';
-import { Platform } from '../../../api/platform';
-import { PLATFORM_NO_FILTER } from '../../../constants';
-
-interface Props {
-	onChange?: (platformId: string) => void;
-	selectedPlatform?: string;
-	platforms?: Platform[];
-}
-
-const PlatformFilter = ({ onChange, platforms, selectedPlatform }: Props) => {
-	return (
-		<SingleSelect placeholder="Select platform" onChange={onChange} size="S" value={selectedPlatform}>
-			<SingleSelectOption key={PLATFORM_NO_FILTER} value={PLATFORM_NO_FILTER}>
-				All Platforms
-			</SingleSelectOption>
-			{platforms?.map((platform: Platform) => (
-				<SingleSelectOption key={platform?.id} value={platform?.title}>
-					{platform?.title}
-				</SingleSelectOption>
-			))}
-		</SingleSelect>
-	);
-};
-
-export default PlatformFilter;

package/admin/src/components/PageFilters/filters.tsx

@@ -1,180 +0,0 @@
-import React, { useMemo } from 'react';
-import set from 'lodash/set';
-
-import { Stack } from '@strapi/design-system';
-import { useQueryParams } from '@strapi/helper-plugin';
-
-import PageTypeFilter from './PageTypeFilter';
-import { PAGE_TYPE_PAGE, PLATFORM } from '../../../../shared/utils/constants';
-import PlatformFilter from './PlatformFilter';
-import { Platform, useGetPlatforms } from '../../api/platform';
-import { PAGE_TYPE, PAGE_TYPE_NO_FILTER, PLATFORM_NO_FILTER } from '../../constants';
-import { PageType } from '../../api/page-type';
-
-interface PageFiltersProps {
-	hidePageType?: boolean;
-}
-
-const PageFilters = ({ hidePageType }: PageFiltersProps) => {
-	const [{ query }, setQuery] = useQueryParams() as any;
-
-	const { data: platforms } = useGetPlatforms({});
-
-	const selectedPlatformTitle = useMemo(() => getPlatformFromQuery(query, platforms), [query, platforms]);
-	const selectedPageTypeUid = useMemo(
-		() => getPageTypeFromQuery(query, getPageTypesFromPlatformTitle(selectedPlatformTitle, platforms)),
-		[query, platforms, selectedPlatformTitle]
-	);
-
-	const handleFilterChange = (
-		filters: Record<string, any>,
-		filterCategory: string,
-		filterCategoryToRemove?: string
-	) => {
-		const currentFilters = query.filters?.$and ? query.filters : { ...query.filters, $and: [] };
-		const filterIndex = currentFilters.$and.findIndex(
-			(x?: Record<string, any>) => Object.keys(x || {})?.[0] === filterCategory
-		);
-
-		if (filterIndex > -1) {
-			set(currentFilters, `$and[${filterIndex}]`, filters); // If the filter in this category already exists, replace it
-		} else {
-			currentFilters.$and.push(filters);
-		}
-
-		const removedFilters = removeFiltersFromQuery({ filters: currentFilters }, filterCategoryToRemove);
-
-		setQuery({
-			page: 1,
-			filters: removedFilters
-		});
-	};
-
-	const removeFilters = (filterCategory: string) => {
-		const filters = removeFiltersFromQuery(query, filterCategory);
-
-		setQuery({
-			page: 1,
-			filters
-		});
-	};
-
-	const handlePlatformSelect = (platformId: string) => {
-		if (platformId === PLATFORM_NO_FILTER) {
-			removeFilters(PLATFORM);
-			return;
-		}
-
-		handleFilterChange(getPlatformQueryFilter(platformId), PLATFORM, PAGE_TYPE);
-	};
-
-	const handlePageTypeSelect = (pageType: string) => {
-		if (pageType === PAGE_TYPE_NO_FILTER) {
-			removeFilters(PAGE_TYPE);
-			return;
-		}
-
-		if (pageType === PAGE_TYPE_PAGE) {
-			handleFilterChange(nullPageTypeQueryFilter, PAGE_TYPE);
-			return;
-		}
-
-		handleFilterChange(getPageTypeQueryFilter(pageType), PAGE_TYPE);
-	};
-
-	return (
-		<Stack horizontal spacing={2}>
-			<PlatformFilter onChange={handlePlatformSelect} platforms={platforms} selectedPlatform={selectedPlatformTitle} />
-			{!hidePageType && (
-				<PageTypeFilter
-					onChange={handlePageTypeSelect}
-					pageTypes={getPageTypesFromPlatformTitle(selectedPlatformTitle, platforms)}
-					selectedPageTypeUid={selectedPageTypeUid}
-				/>
-			)}
-		</Stack>
-	);
-};
-
-export default PageFilters;
-
-const getPageTypesFromPlatformTitle = (selectedPlatformTitle?: string, platforms?: Platform[]) =>
-	platforms?.find((p) => p.title === selectedPlatformTitle)?.pageTypes;
-
-const getPageTypeFromQuery = (query: Record<string, any>, pageTypes?: PageType[]) => {
-	const pageTypeFromQuery = query?.filters?.$and?.find(
-		(x?: Record<string, any>) => Object.keys(x || {})?.[0] === PAGE_TYPE
-	)?.pageType;
-
-	if (pageTypeFromQuery?.uid?.$null === 'true') {
-		return PAGE_TYPE_PAGE;
-	}
-
-	if (pageTypeFromQuery?.uid?.$eq) {
-		const matchingPageType = pageTypes?.find((pageType: any) => pageType?.uid === pageTypeFromQuery.uid.$eq);
-
-		if (matchingPageType) {
-			return matchingPageType.uid;
-		}
-	}
-
-	return PAGE_TYPE_NO_FILTER;
-};
-
-const getPlatformFromQuery = (query: Record<string, any>, platforms?: Platform[]): string | undefined => {
-	const platformFromQuery = query?.filters?.$and?.find(
-		(x?: Record<string, any>) => Object.keys(x || {})?.[0] === PLATFORM
-	)?.platform;
-
-	if (platformFromQuery?.title?.$null === 'true') {
-		return PLATFORM_NO_FILTER;
-	}
-
-	if (platformFromQuery?.title?.$eq) {
-		const matchingPageType = platforms?.find((platforms: Platform) => platforms?.title === platformFromQuery.title.$eq);
-
-		if (matchingPageType) {
-			return matchingPageType.title;
-		}
-	}
-
-	return PLATFORM_NO_FILTER;
-};
-
-const getPlatformQueryFilter = (platform: string) => ({
-	platform: {
-		title: {
-			$eq: platform
-		}
-	}
-});
-
-const getPageTypeQueryFilter = (pageType: string) => ({
-	pageType: {
-		uid: {
-			$eq: pageType
-		}
-	}
-});
-
-const nullPageTypeQueryFilter = {
-	pageType: {
-		uid: {
-			$null: true
-		}
-	}
-};
-
-const removeFiltersFromQuery = (query: Record<string, any>, filterCategory?: string) => {
-	const newAndFilters = query.filters?.$and?.filter(
-		(x?: Record<string, any>) => Object.keys(x || {})?.[0] !== filterCategory
-	);
-
-	const filters = { ...query.filters, $and: newAndFilters };
-
-	if (newAndFilters && newAndFilters.length === 0) {
-		delete filters.$and;
-	}
-
-	return filters;
-};