@webbio/strapi-plugin-page-builder 0.18.0-platform → 1.0.0

package/admin/src/api/search-filtered-entity.ts

@@ -111,7 +111,7 @@ export const getSearchFilteredEntities = async ({
 				title: result?.[mainFieldName],
 				publicationState: getPublicationState(),
 				publishedAt: result?.publishedAt,
-				href: `/content-manager/collectionType/${uid}/${result.id}`,
+				href: `/content-manager/collection-types/${uid}/${result.id}`,
 				subTitle: typeof subTitle === 'string' || typeof subTitle === 'number' ? String(subTitle) : ''
 			};
 		});

package/admin/src/components/EditView/CollectionTypeSettings/CreatePageButton/index.tsx

@@ -28,7 +28,7 @@ export const CreatePageButton = ({ selectedPlatform, onCreatedPage }: ICreatePag
 	const { locales } = useSelector((state: any) => state.i18n_locales);
 
 	const { post, get, put } = useFetchClient();
-	const url = `/content-manager/collectionType/${PAGE_UID}/create`;
+	const url = `/content-manager/collection-types/${PAGE_UID}/create`;
 
 	const handleCreatePage = async (e: React.MouseEvent<HTMLAnchorElement>) => {
 		e.preventDefault();

package/admin/src/components/EditView/CollectionTypeSettings/index.tsx

@@ -10,6 +10,7 @@ import { PAGE_TYPE_PAGE, PAGE_UID } from '../../../../../shared/utils/constants'
 import { usePlatformFormData } from '../../../utils/hooks/usePlatformFormData';
 import S from '../Details/styles';
 import { usePageTypeExists } from '../../../api/page-type-exists';
+import { delay } from '../../../utils/delay';
 
 interface CollectionTypeSettingsProps {
 	onlyPlatform?: boolean;
@@ -38,15 +39,26 @@ export const CollectionTypeSettings = ({ onlyPlatform }: CollectionTypeSettingsP
 		}
 	}, [modifiedData.page?.[0]]);
 
-	useEffect(() => {
-		if (isCreatingEntry) {
-			onChange({
+	// Reset page link if creating entry
+	// Reason for the delay is explained in usePlatformFormData.ts
+	const resetPageLinkIfCreatingEntry = async () => {
+		if (!isCreatingEntry || (isCreatingEntry && !initialData.page)) return;
+
+		await delay(100);
+
+		onChange(
+			{
 				target: {
 					name: 'page',
 					value: null
 				}
-			});
-		}
+			},
+			false
+		);
+	};
+
+	useEffect(() => {
+		resetPageLinkIfCreatingEntry();
 	}, []);
 
 	return (
@@ -57,8 +69,8 @@ export const CollectionTypeSettings = ({ onlyPlatform }: CollectionTypeSettingsP
 						{!pageTypeExists && !linkedPage && !isLoadingPageTypeExists && (
 							<S.InfoType variant="pi" textColor="neutral800">
 								Er bestaat nog geen{' '}
-								<Link to="/content-manager/collectionType/api::page-type.page-type">pagina type</Link> voor dit content
-								type.
+								<Link to="/content-manager/collection-types/api::page-type.page-type">pagina type</Link> voor dit
+								content type.
 							</S.InfoType>
 						)}
 						{showCreatePageButton && selectedPlatform && (pageTypeExists || linkedPage) && (

package/admin/src/components/PlatformFilteredSelectField/hooks/useRelationLoad.tsx

@@ -18,7 +18,7 @@ const useRelationLoad = ({ name, attribute }: IRelationLoadProps) => {
 	const { modifiedData, initialData, slug, layout, allLayoutData, isCreatingEntry, relationLoad } =
 		useCMEditViewDataManager() as any;
 	const { params } =
-		useRouteMatch<{ origin?: string }>('/content-manager/collectionType/:collectionType/create/clone/:origin') ?? {};
+		useRouteMatch<{ origin?: string }>('/content-manager/collection-types/:collectionType/create/clone/:origin') ?? {};
 	const { origin } = params ?? {};
 	const isCloningEntry = Boolean(origin);
 	const entityId = origin || modifiedData.id;

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

@@ -55,16 +55,6 @@ const PlatformFilteredSelectField = (props: IPlatformFilteredSelectFieldProps) =
 	);
 };
 
-PlatformFilteredSelectField.defaultProps = {
-	description: undefined,
-	disabled: false,
-	error: undefined,
-	labelAction: undefined,
-	placeholder: undefined,
-	value: '',
-	required: false
-};
-
 export default PlatformFilteredSelectField;
 
 const getLocalizedActionLabel = (actionLabel?: JSX.Element, layout?: Record<string, any>): JSX.Element | undefined => {

package/admin/src/components/StrapiCore/admin/admin/src/content-manager/components/Relations/utils/getRelationLink.ts

@@ -1,5 +1,5 @@
 import { Entity } from '@strapi/types';
 
 export function getRelationLink(targetModel: string, id?: Entity.ID) {
-	return `/content-manager/collectionType/${targetModel}/${id ?? ''}`;
+	return `/content-manager/collection-types/${targetModel}/${id ?? ''}`;
 }

package/admin/src/utils/delay.ts

@@ -0,0 +1 @@
+export const delay = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));

package/admin/src/utils/hooks/usePlatformFormData.ts

@@ -4,6 +4,7 @@ import { Platform } from '../../api/platform';
 import { useDefaultPlatformFromLocalStorage } from './useDefaultPlatformFromLocalStorage';
 import { useGetPlatformRelation } from '../../api/platform-relation';
 import { PLATFORM_UID } from '../../../../shared/utils/constants';
+import { delay } from '../delay';
 
 const usePlatformFormData = (form?: Record<string, any>, onPlatformChange?: (platform: Platform) => void) => {
 	const { onChange, initialData, modifiedData, layout, isCreatingEntry } = form || {};
@@ -77,7 +78,3 @@ const usePlatformFormData = (form?: Record<string, any>, onPlatformChange?: (pla
 };
 
 export { usePlatformFormData };
-
-function delay(ms: number) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@webbio/strapi-plugin-page-builder",
-    "version": "0.18.0-platform",
+    "version": "1.0.0",
     "description": "This is the description of the plugin.",
     "scripts": {
         "develop": "tsc -p tsconfig.server.json -w",
@@ -24,11 +24,11 @@
         "@mantine/hooks": "^7.2.2",
         "@sindresorhus/slugify": "^2.2.1",
         "@strapi/design-system": "^1.19.0",
-        "@strapi/helper-plugin": "^4.25.8",
+        "@strapi/helper-plugin": "^4.25.22",
         "@strapi/icons": "^1.19.0",
         "@strapi/provider-email-amazon-ses": "^4.16.2",
-        "@strapi/typescript-utils": "^4.25.8",
-        "@strapi/utils": "^4.25.8",
+        "@strapi/typescript-utils": "^4.25.22",
+        "@strapi/utils": "^4.25.22",
         "add": "^2.0.6",
         "aws-sdk": "^2.1528.0",
         "fuse.js": "^7.0.0",
@@ -48,7 +48,7 @@
         "typescript": "5.1.6"
     },
     "peerDependencies": {
-        "@strapi/strapi": "^4.25.8",
+        "@strapi/strapi": "^4.25.22",
         "@webbio/strapi-plugin-slug": "^3.3.2",
         "react": "^17.0.0 || ^18.0.0",
         "react-dom": "^17.0.0 || ^18.0.0",

package/dist/server/graphql/page-by-slug.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const filter_underscore_arguments_1 = require("../utils/filter-underscore-arguments");
+const constants_1 = require("../../shared/utils/constants");
+const getPageBySlug = (strapi) => {
+    const typeDefs = () => {
+        return `
+				extend type Page {
+					collectionType: GenericMorph
+				}
+
+        type Query {
+          getPageBySlug(path: String, _locale: String, _publicationState: PublicationState): PageEntity
+        }
+
+      `;
+    };
+    const resolvers = (strapi) => {
+        const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
+        return {
+            Query: {
+                getPageBySlug: {
+                    resolve: async (_parent, args, ctx) => {
+                        var _a;
+                        const filteredArgs = {
+                            ...(0, filter_underscore_arguments_1.filterUnderscoreArguments)(args)
+                        };
+                        const { toEntityResponse } = strapi.plugin('graphql').service('format').returnTypes;
+                        const getPage = async () => {
+                            var _a, _b, _c;
+                            const transformedArgs = transformArgs(filteredArgs, {
+                                contentType: strapi.contentTypes[constants_1.PAGE_UID],
+                                usePagination: false
+                            });
+                            const results = await ((_a = strapi.entityService) === null || _a === void 0 ? void 0 : _a.findMany(constants_1.PAGE_UID, {
+                                filters: transformedArgs,
+                                locale: args._locale,
+                                publicationState: args._publicationState,
+                                populate: '*'
+                            }));
+                            const entityResponse = toEntityResponse((results === null || results === void 0 ? void 0 : results[0]) || {}, {
+                                args: transformedArgs,
+                                resourceUID: constants_1.PAGE_UID
+                            });
+                            if (!(entityResponse === null || entityResponse === void 0 ? void 0 : entityResponse.value) || Object.keys(entityResponse.value).length === 0) {
+                                throw new Error(ctx.koaContext.response.message);
+                            }
+                            const collectionTypeDataFilter = (_c = (_b = entityResponse === null || entityResponse === void 0 ? void 0 : entityResponse.value) === null || _b === void 0 ? void 0 : _b.collectionTypeData) === null || _c === void 0 ? void 0 : _c.filter(Boolean);
+                            const collectionType = collectionTypeDataFilter.length === 1 ? collectionTypeDataFilter === null || collectionTypeDataFilter === void 0 ? void 0 : collectionTypeDataFilter[0] : null;
+                            const addedAttributes = {
+                                collectionType: collectionType
+                            };
+                            const result = {
+                                ...entityResponse.value,
+                                ...addedAttributes
+                            };
+                            return result;
+                        };
+                        const results = await getPage();
+                        if (((_a = Object.values(results)) === null || _a === void 0 ? void 0 : _a.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
+    };
+};
+exports.default = getPageBySlug;

package/dist/server/utils/graphql.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerGraphQLResolvers = void 0;
+const constants_1 = require("../../shared/utils/constants");
+const findPageByPath = (strapi) => {
+    const typeDefs = `
+  type Query {
+    findPageByPath(path: String, locale: I18NLocaleCode): PageEntityResponse 
+  }
+  `;
+    const resolvers = (strapi) => {
+        const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
+        const { toEntityResponse, toEntityResponseCollection } = strapi.plugin('graphql').service('format').returnTypes;
+        return {
+            Query: {
+                findPageByPath: {
+                    resolve: async (parent, args, ctx) => {
+                        const contentType = strapi.getModel(constants_1.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 === null || queryResult === void 0 ? void 0 : 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) => {
+    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) => {
+        const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
+        return {
+            Query: {
+                findPagePaths: {
+                    resolve: async (parent, args, ctx) => {
+                        const contentType = strapi.getModel(constants_1.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 === null || page === void 0 ? void 0 : page.path);
+                        return result;
+                    }
+                }
+            }
+        };
+    };
+    const resolversConfig = {
+        'Query.findPagePaths': {
+            auth: false
+        }
+    };
+    return {
+        typeDefs,
+        resolvers: resolvers(strapi),
+        resolversConfig
+    };
+};
+const registerGraphQLResolvers = (strapi) => {
+    const extensionService = strapi.plugin('graphql').service('extension');
+    extensionService.use(findPageByPath(strapi));
+    extensionService.use(findPagePaths(strapi));
+};
+exports.registerGraphQLResolvers = registerGraphQLResolvers;

package/dist/server/utils/paginationValidation.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pagination = void 0;
+class Pagination {
+    static checkPagination(page, pageSize) {
+        const startPage = page === 1 ? 0 : page - 1;
+        const start = startPage * pageSize;
+        const limit = (startPage + 1) * pageSize;
+        return { start, limit };
+    }
+    static async getPaginationInfo(transformedpageArgs, transformArgs, start, pageSize, entityResponse, uid) {
+        var _a;
+        const total = await ((_a = strapi === null || strapi === void 0 ? void 0 : strapi.entityService) === null || _a === void 0 ? void 0 : _a.count(uid, {
+            filters: {
+                ...transformArgs.filters,
+                hasPage: { $eq: true },
+                page: { ...transformedpageArgs.filters }
+            }
+        }));
+        const pageCount = Math.ceil(total / pageSize);
+        const page = Math.floor(start / pageSize) + 1;
+        entityResponse.metaInfo = {
+            total,
+            pageCount,
+            page,
+            pageSize
+        };
+        return entityResponse;
+    }
+}
+exports.Pagination = Pagination;