feat: fix linting issues and add interfaces

Author: TMSchipper

packages/core/server/controllers/search.ts

@@ -4,49 +4,64 @@ import { errors } from '@strapi/utils';
 import { isContentTypeEnabled } from '../util/enabledContentTypes';
 import { getPluginService } from '../util/getPluginService';
 
+interface ContentTypeConfig {
+  [key: string]: any; // We only pass this to isContentTypeEnabled, so any is fine here
+}
+
+interface DocumentEntry {
+  id: number;
+  documentId: string;
+  [key: string]: unknown; // Dynamic fields like title, etc.
+}
+
+interface SearchResult extends DocumentEntry {
+  contentType: string;
+}
+
 /**
  * Search controller
  */
 export default {
   search: async (ctx: Context & { params: { id: number } }) => {
     const { q } = ctx.query;
-    const results = [];
+    const results: SearchResult[] = [];
 
     const qStr = typeof q === 'string' ? q.trim() : '';
     if (!qStr) {
       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 getPluginService('get-main-field').getMainField(uid);
-        if (!mainField) return;
-
-        const entries = await (strapi as any).documents(uid).findMany({
-          filters: {
-            [mainField]: { $containsi: qStr },
-          },
-          fields: [mainField, 'documentId'],
-          populate: {
-            url_alias: { fields: ['id'] },
-          },
-        });
-
-        if (!entries || entries.length === 0) return;
-
-        const entriesWithContentType = entries.map((entry: any) => ({
-          ...entry,
-          contentType: uid,
-        }));
-
-        results.push(...entriesWithContentType);
-      }),
+      Object.entries(strapi.contentTypes).map(
+        async ([uid, config]: [UID.CollectionType, ContentTypeConfig]) => {
+          const hasWT = isContentTypeEnabled(config);
+          if (!hasWT) return;
+
+          const mainField = await getPluginService('get-main-field').getMainField(uid);
+          if (!mainField) return;
+
+          const entries: DocumentEntry[] = await strapi.documents(uid).findMany({
+            filters: {
+              [mainField]: { $containsi: qStr },
+            },
+            fields: [mainField, 'documentId'],
+            populate: {
+              url_alias: { fields: ['id'] },
+            },
+          });
+
+          if (!entries || entries.length === 0) return;
+
+          const entriesWithContentType: SearchResult[] = entries.map((entry: DocumentEntry) => ({
+            ...entry,
+            contentType: uid,
+          }));
+
+          results.push(...entriesWithContentType);
+        },
+      ),
     );
 
-    // @ts-ignore
     ctx.body = results;
   },
   reverseSearch: async (ctx: Context & { params: { contentType: string; documentId: string } }) => {
@@ -56,14 +71,17 @@ export default {
       throw new errors.ValidationError(`Unknown or invalid content type: ${contentType}`);
     }
 
-    const mainField = await getPluginService('get-main-field').getMainField(contentType as UID.CollectionType);
-    const entry = await (strapi as any).documents(contentType as UID.CollectionType).findOne({
+    const mainField = await getPluginService('get-main-field').getMainField(
+      contentType as UID.CollectionType,
+    );
+    // eslint-disable-next-line max-len
+    const entry: DocumentEntry | null = await strapi.documents(contentType as UID.CollectionType).findOne({
       documentId,
       fields: ['id', 'documentId', ...(mainField ? [mainField] : [])],
     });
 
     if (!entry) {
-      throw new errors.ValidationError('Entry not found');
+      throw new errors.NotFoundError('Entry not found');
     }
 
     ctx.body = {

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

@@ -1,12 +1,19 @@
 import { UID } from '@strapi/strapi';
 
+interface ContentManagerConfig {
+  settings?: {
+    mainField?: string;
+  };
+}
+
 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}` },
-  });
+  }) as Array<{ value: string }>;
+
   if (!coreStoreSettings?.[0]) return null;
 
-  const value = JSON.parse(coreStoreSettings[0].value);
+  const value = JSON.parse(coreStoreSettings[0].value) as ContentManagerConfig;
 
   return value?.settings?.mainField ?? null;
 };