feat: update validation message with validation from strapi

Author: TMSchipper

packages/core/server/controllers/search.ts

@@ -1,29 +1,28 @@
 import { Context } from 'koa';
 import { UID } from '@strapi/strapi';
+import { errors } from '@strapi/utils';
 import { isContentTypeEnabled } from '../util/enabledContentTypes';
-import { getMainField } from '../services/get-main-field';
+import { getPluginService } from '../util/getPluginService';
 
 /**
  * Search controller
  */
 export default {
   search: async (ctx: Context & { params: { id: number } }) => {
     const { q } = ctx.query;
-    const { id } = ctx.params;
-    let results = [];
+    const results = [];
 
     const qStr = typeof q === 'string' ? q.trim() : '';
     if (!qStr) {
-      ctx.throw(400, 'Missing or invalid query parameter "?q=" (must be a non-empty strin4g)');
-      return;
+      throw new errors.ValidationError('Missing or invalid query parameter "?q=" (must be a non-empty string)');
     }
 
     await Promise.all(
       Object.entries(strapi.contentTypes).map(async ([uid, config]: [UID.CollectionType, any]) => {
         const hasWT = isContentTypeEnabled(config);
         if (!hasWT) return;
 
-        const mainField = await getMainField(uid);
+        const mainField = await getPluginService('get-main-field').getMainField(uid);
         if (!mainField) return;
 
         const entries = await (strapi as any).documents(uid).findMany({
@@ -54,20 +53,17 @@ export default {
     const { contentType, documentId } = ctx.params;
 
     if (typeof contentType !== 'string' || !(contentType in strapi.contentTypes)) {
-      ctx.throw(400, `Unknown or invalid content type: ${contentType}`);
-      return;
+      throw new errors.ValidationError(`Unknown or invalid content type: ${contentType}`);
     }
 
-    const mainField = await getMainField(contentType as UID.CollectionType);
-
+    const mainField = await getPluginService('get-main-field').getMainField(contentType as UID.CollectionType);
     const entry = await (strapi as any).documents(contentType as UID.CollectionType).findOne({
       documentId,
       fields: ['id', 'documentId', ...(mainField ? [mainField] : [])],
     });
 
     if (!entry) {
-      ctx.throw(404, 'Entry not found');
-      return;
+      throw new errors.ValidationError('Entry not found');
     }
 
     ctx.body = {

packages/core/server/services/get-main-field.ts

@@ -1,11 +1,16 @@
 import { UID } from '@strapi/strapi';
 
-export async function getMainField(uid: UID.CollectionType): Promise<string | null> {
+export const getMainField = async (uid: UID.CollectionType): Promise<string | null> => {
   const coreStoreSettings = await strapi.query('strapi::core-store').findMany({
     where: { key: `plugin_content_manager_configuration_content_types::${uid}` },
   });
   if (!coreStoreSettings?.[0]) return null;
 
   const value = JSON.parse(coreStoreSettings[0].value);
+
   return value?.settings?.mainField ?? null;
-}
+};
+
+export default () => ({
+  getMainField,
+});

packages/core/server/services/index.ts

@@ -1,9 +1,11 @@
-import urlAliasController from './url-alias';
-import urlPatternController from './url-pattern';
-import bulkGenerateController from './bulk-generate';
+import urlAliasService from './url-alias';
+import urlPatternService from './url-pattern';
+import bulkGenerateService from './bulk-generate';
+import getMainFieldService from './get-main-field';
 
 export default {
-  'url-alias': urlAliasController,
-  'url-pattern': urlPatternController,
-  'bulk-generate': bulkGenerateController,
+  'url-alias': urlAliasService,
+  'url-pattern': urlPatternService,
+  'bulk-generate': bulkGenerateService,
+  'get-main-field': getMainFieldService,
 };