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

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

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

package/strapi-admin.js

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

package/strapi-server.js

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

package/tsconfig.json

@@ -1,20 +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"
-	]
-}
+{
+	"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

@@ -1,25 +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"
-	]
-}
+{
+	"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"
+	]
+}

package/admin/src/api/platform-page-types.ts

@@ -1,40 +0,0 @@
-import { useQuery } from 'react-query';
-
-import { useFetchClient } from '@strapi/helper-plugin';
-
-import { PageType } from './page-type';
-
-const QUERY_KEY = 'pageTypesForPlatform';
-
-const fetchPageTypesForPlatform = async ({ fetchClient, id }: Record<string, any>): Promise<PageType[]> => {
-	if (!id) return [];
-
-	const { get } = fetchClient;
-	const pageTypesByPlatformResult = await get(
-		`/content-manager/relations/api::platform.platform/${id}/pageTypes?page=1&pageSize=100`
-	);
-	const pageTypesResult = await get(`/content-manager/collection-types/api::page-type.page-type?page=1&pageSize=100`);
-
-	return pageTypesByPlatformResult?.data?.results?.map((entity: Record<string, any>) => {
-		const fullPageType = pageTypesResult?.data?.results?.find(
-			(pageType: Record<string, any>) => pageType.id === entity.id
-		);
-
-		return {
-			id: entity.id,
-			uid: fullPageType.uid,
-			title: fullPageType.title,
-			templateId: fullPageType?.template?.id
-		};
-	});
-};
-
-export const useGetPageTypesForPlatform = (params: Record<string, any>) => {
-	const fetchClient = useFetchClient();
-	params = {
-		...params,
-		fetchClient
-	};
-
-	return useQuery<PageType[], Error>([QUERY_KEY, params?.id], () => fetchPageTypesForPlatform(params));
-};

package/admin/src/api/platform.ts

@@ -1,34 +0,0 @@
-import { useQuery } from 'react-query';
-
-import { useFetchClient } from '@strapi/helper-plugin';
-
-import { PageType } from './page-type';
-
-export type Platform = {
-	id: number;
-	title?: string;
-	pageTypes?: PageType[];
-};
-
-const QUERY_KEY = 'platforms';
-
-const fetchPlatforms = async ({ fetchClient }: Record<string, any>): Promise<Platform[]> => {
-	const { get } = fetchClient;
-	const result = await get('/content-manager/collection-types/api::platform.platform?page=1&pageSize=100');
-
-	return result?.data?.results.map((entity: Record<string, any>) => ({
-		id: entity.id,
-		title: entity.title,
-		pageTypes: entity.pageTypes
-	}));
-};
-
-export const useGetPlatforms = (params: Record<string, 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 { 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';
-import { useGetPageTypesForPlatform } from '../../api/platform-page-types';
-
-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 { data: pageTypesForPlatform } = useGetPageTypesForPlatform({
-		id: platforms?.find((p) => p.title === selectedPlatformTitle)?.id
-	});
-
-	const selectedPageTypeUid = useMemo(() => getPageTypeFromQuery(query, []), [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={pageTypesForPlatform}
-					selectedPageTypeUid={selectedPageTypeUid}
-				/>
-			)}
-		</Stack>
-	);
-};
-
-export default PageFilters;
-
-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;
-};

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

@@ -1,30 +0,0 @@
-import * as React from 'react';
-
-import { useLocation } from 'react-router-dom';
-
-import { PAGE_UID } from '../../../../shared/utils/constants';
-
-import PageFilters from './filters';
-import { useHasPageRelation } from '../../api/has-page-relation';
-
-const PageFiltersContainer = () => {
-	const { pathname } = useLocation();
-	const uid = pathname.split('/').find((x) => x.startsWith('api::')) || '';
-	const isPageCollectionType = uid === PAGE_UID;
-
-	const { data: hasPageRelation, isLoading } = useHasPageRelation({
-		uid
-	});
-
-	if (isPageCollectionType) {
-		return <PageFilters />;
-	}
-
-	if (!isPageCollectionType && hasPageRelation && !isLoading) {
-		return <PageFilters hidePageType />;
-	}
-
-	return null;
-};
-
-export default PageFiltersContainer;

package/server/controllers/platform.ts

@@ -1,21 +0,0 @@
-import { Strapi } from '@strapi/strapi';
-
-export default {
-	async findAll() {
-		return await (strapi as Strapi).service('plugin::page-builder.platform').findAll();
-	},
-
-	async findOneByUid(ctx: any) {
-		const uid = ctx?.params?.uid;
-
-		if (!uid) {
-			return ctx.badRequest('uid is missing.');
-		}
-
-		return await strapi.service('plugin::page-builder.platform').findOneByUid(uid);
-	},
-	async findPageTypesByPlatform(ctx: any) {
-		const platform = ctx?.params?.platform;
-		return await (strapi as Strapi).services['plugin::page-builder.platform'].findPageTypesByPlatform(platform);
-	}
-};