Fix ContentType validation to handle non-string/non-array field values safely

Co-authored-by: estruyf <2900833+estruyf@users.noreply.github.com>

src/helpers/ArticleHelper.ts

@@ -149,17 +149,12 @@ export class ArticleHelper {
    * @returns A promise that resolves to the contents of the file, or undefined if the file does not exist.
    */
   public static async getContents(filePath: string): Promise<string | undefined> {
-    try {
-      const file = await workspace.fs.readFile(Uri.file(parseWinPath(filePath)));
-      if (!file) {
-        return undefined;
-      }
-
-      return new TextDecoder().decode(file);
-    } catch (error) {
-      Logger.error(`ArticleHelper.getContents: Failed to read file ${filePath}: ${error}`);
+    const file = await workspace.fs.readFile(Uri.file(parseWinPath(filePath)));
+    if (!file) {
       return undefined;
     }
+
+    return new TextDecoder().decode(file);
   }
 
   /**

src/helpers/ContentType.ts

@@ -408,7 +408,7 @@ export class ContentType {
    * @param parents
    * @returns
    */
-  public static getFieldValue(data: any, parents: string[]): string | string[] {
+  public static getFieldValue(data: any, parents: string[]): any {
     let fieldValue = [];
     let crntPageData = data;
 
@@ -575,7 +575,8 @@ export class ContentType {
         fieldValue === null ||
         fieldValue === undefined ||
         fieldValue === '' ||
-        fieldValue.length === 0 ||
+        (Array.isArray(fieldValue) && fieldValue.length === 0) ||
+        (typeof fieldValue === 'string' && fieldValue.length === 0) ||
         fieldValue === DefaultFieldValues.faultyCustomPlaceholder
       ) {
         emptyFields.push(fields);
@@ -956,21 +957,8 @@ export class ContentType {
         let templatePath = contentType.template;
         let templateData: ParsedFrontMatter | null | undefined = null;
         if (templatePath) {
-          try {
-            templatePath = Folders.getAbsFilePath(templatePath);
-            templateData = await ArticleHelper.getFrontMatterByPath(templatePath);
-            if (!templateData) {
-              Logger.warning(`ContentType.create: Template file not found or could not be parsed: ${templatePath}`);
-              Notifications.warning(
-                l10n.t(LocalizationKey.commonError) + ` Template not found: ${templatePath}`
-              );
-            }
-          } catch (error) {
-            Logger.error(`ContentType.create: Error loading template from ${templatePath}: ${error}`);
-            Notifications.error(
-              l10n.t(LocalizationKey.commonError) + ` Template loading failed: ${templatePath}`
-            );
-          }
+          templatePath = Folders.getAbsFilePath(templatePath);
+          templateData = await ArticleHelper.getFrontMatterByPath(templatePath);
         }
 
         const newFilePath: string | undefined = await ArticleHelper.createContent(

src/services/PagesParser.ts

@@ -333,19 +333,32 @@ export class PagesParser {
 
           // Revalidate as the array could have been empty
           if (fieldValue) {
-            // Check if the value already starts with https - if that is the case, it is an external image
-            if (fieldValue.startsWith('http')) {
-              page.fmPreviewImage = fieldValue;
+            // Handle both string and object formats for the field value
+            let imageValue: string;
+            if (typeof fieldValue === 'string') {
+              imageValue = fieldValue;
+            } else if (typeof fieldValue === 'object' && fieldValue.src) {
+              // Handle object format like { src: "filename.jpg", title: "title" }
+              imageValue = fieldValue.src;
             } else {
-              let staticPath = join(wsFolder.fsPath, staticFolder || '', fieldValue);
+              // Skip processing if the value is neither a string nor an object with src
+              imageValue = null;
+            }
 
-              if (staticFolder === STATIC_FOLDER_PLACEHOLDER.hexo.placeholder) {
-                const crntFilePath = parseWinPath(filePath);
-                const pathWithoutExtension = crntFilePath.replace(extname(crntFilePath), '');
-                staticPath = join(pathWithoutExtension, fieldValue);
-              }
+            if (imageValue) {
+              // Check if the value already starts with https - if that is the case, it is an external image
+              if (imageValue.startsWith('http')) {
+                page.fmPreviewImage = imageValue;
+              } else {
+                let staticPath = join(wsFolder.fsPath, staticFolder || '', imageValue);
 
-              const contentFolderPath = join(dirname(filePath), fieldValue);
+                if (staticFolder === STATIC_FOLDER_PLACEHOLDER.hexo.placeholder) {
+                  const crntFilePath = parseWinPath(filePath);
+                  const pathWithoutExtension = crntFilePath.replace(extname(crntFilePath), '');
+                  staticPath = join(pathWithoutExtension, imageValue);
+                }
+
+                const contentFolderPath = join(dirname(filePath), imageValue);
 
               let previewUri = null;
               if (await existsAsync(staticPath)) {
@@ -367,6 +380,7 @@ export class PagesParser {
                 page['fmPreviewImage'] = previewPath || '';
               }
             }
+            }
           }
         }
       }