Added Dublin Core metadata for entries

Author: KartoffelChipss

src/tests/utils/xml/AtomEntryBuilder.dcMetadata.test.ts

@@ -1,17 +1,17 @@
 import { create } from 'xmlbuilder2';
-import { EntryOptions } from '../../versions/v1_2/types';
+import { EntryOptions, simpleDcTextFields } from '../../versions/v1_2/types';
 import { BaseAtomBuilder } from './BaseAtomBuilder';
 
 export class AtomEntryBuilder extends BaseAtomBuilder<EntryOptions> {
     constructor() {
         super('entry');
     }
 
-    protected initializeRoot(): void {
+    protected override initializeRoot(): void {
         this.root = create().ele(this.elementName);
     }
 
-    protected addCoreMetadata(options: EntryOptions): void {
+    protected override addCoreMetadata(options: EntryOptions): void {
         this.root.ele('id').txt(options.id).up();
         this.root.ele('title').txt(options.title).up();
         this.root
@@ -26,10 +26,58 @@ export class AtomEntryBuilder extends BaseAtomBuilder<EntryOptions> {
                 .up();
         }
 
+        this.addDcMetadata(options);
+
         this.addAuthorIfPresent(options.author);
     }
 
-    protected addExtraContent(options: EntryOptions): void {
+    private addDcMetadata(options: EntryOptions): void {
+        const dc = options.dcMetadata || {};
+
+        for (const field of simpleDcTextFields) {
+            const value = dc[field];
+            if (value) {
+                this.root.ele(`dc:${field}`).txt(value).up();
+            }
+        }
+
+        if (dc.identifiers) {
+            for (const id of dc.identifiers) {
+                this.root.ele('dc:identifier').txt(id).up();
+            }
+        }
+
+        if (dc.subjects) {
+            for (const subject of dc.subjects) {
+                this.root.ele('dc:subject').txt(subject).up();
+            }
+        }
+
+        if (dc.references) {
+            for (const ref of dc.references) {
+                this.root.ele('dc:references').txt(ref).up();
+            }
+        }
+
+        if (dc.isReferencedBy) {
+            for (const refBy of dc.isReferencedBy) {
+                this.root.ele('dc:isReferencedBy').txt(refBy).up();
+            }
+        }
+
+        if (dc.contributors) {
+            for (const contributor of dc.contributors) {
+                this.root
+                    .ele('dc:contributor')
+                    .ele('name')
+                    .txt(contributor)
+                    .up()
+                    .up();
+            }
+        }
+    }
+
+    protected override addExtraContent(options: EntryOptions): void {
         if (options.summary) {
             this.root
                 .ele('summary', { type: 'text' })

src/tests/utils/xml/dcMetadata.xmlParsing.test.ts

@@ -12,14 +12,14 @@ export class AtomFeedBuilder extends BaseAtomBuilder<FeedOptions> {
         });
     }
 
-    protected initializeRoot(): void {
+    protected override initializeRoot(): void {
         this.root = create({ version: '1.0', encoding: 'utf-8' }).ele(
             this.elementName,
             this.namespaces
         );
     }
 
-    protected addCoreMetadata(options: FeedOptions): void {
+    protected override addCoreMetadata(options: FeedOptions): void {
         if (options.lang) {
             this.root.att('xml:lang', options.lang);
         }
@@ -38,7 +38,7 @@ export class AtomFeedBuilder extends BaseAtomBuilder<FeedOptions> {
         this.addAuthorIfPresent(authorName);
     }
 
-    protected addExtraContent(options: FeedOptions): void {}
+    protected override addExtraContent(options: FeedOptions): void {}
 
     /**
      * Adds entries to the feed.

src/tests/v1_2/dcMetadata.test.ts

@@ -61,6 +61,27 @@ export class AtomXmlParser {
         return undefined;
     }
 
+    /**
+     * Extarcts multiple text from multiple elements. (e.g. multiple dc:identifier)
+     * @param element - The element(s) to extract text from.
+     * @returns The array of text content or undefined.
+     */
+    extractMultipleText(element: any): string[] | undefined {
+        if (!element) return undefined;
+
+        const elements = Array.isArray(element) ? element : [element];
+        const texts: string[] = [];
+
+        for (const el of elements) {
+            const text = this.extractText(el);
+            if (text) {
+                texts.push(text);
+            }
+        }
+
+        return texts.length > 0 ? texts : undefined;
+    }
+
     /**
      * Extracts attribute value from an element.
      * @param element - The element to extract attribute from.

src/utils/xml/AtomEntryBuilder.ts

@@ -1,4 +1,8 @@
-import { EntryOptions } from '../../versions/v1_2/types';
+import {
+    DCMetadata,
+    EntryOptions,
+    simpleDcTextFields,
+} from '../../versions/v1_2/types';
 import { Entry } from '../../versions/v1_2/entry';
 import { AtomXmlParser } from './AtomXmlParser';
 
@@ -74,6 +78,9 @@ export class EntryXmlParser extends AtomXmlParser {
         const rights = this.extractText(entryElement.rights);
         if (rights) options.rights = rights;
 
+        const dcMetadata = this.parseDcMetadata(entryElement);
+        if (dcMetadata) options.dcMetadata = dcMetadata;
+
         if (entryElement.content) {
             const contentType =
                 this.extractAttribute(entryElement.content, 'type') || 'text';
@@ -110,4 +117,63 @@ export class EntryXmlParser extends AtomXmlParser {
 
         return options;
     }
+
+    private parseDcMetadata(entryElement: any): DCMetadata | undefined {
+        const dc: DCMetadata = {};
+
+        for (const field of simpleDcTextFields) {
+            const value = this.extractText(entryElement[`dc:${field}`]);
+            if (value) {
+                (dc as any)[field] = value;
+            }
+        }
+
+        const identifiers = this.extractMultipleText(
+            entryElement['dc:identifier']
+        );
+        if (identifiers && identifiers.length > 0) {
+            dc.identifiers = identifiers;
+        }
+
+        const subjects = this.extractMultipleText(entryElement['dc:subject']);
+        if (subjects && subjects.length > 0) {
+            dc.subjects = subjects;
+        }
+
+        const references = this.extractMultipleText(
+            entryElement['dc:references']
+        );
+        if (references && references.length > 0) {
+            dc.references = references;
+        }
+
+        const isReferencedBy = this.extractMultipleText(
+            entryElement['dc:isReferencedBy']
+        );
+        if (isReferencedBy && isReferencedBy.length > 0) {
+            dc.isReferencedBy = isReferencedBy;
+        }
+
+        const contributorElements = this.ensureArray(
+            entryElement['dc:contributor']
+        );
+        if (contributorElements && contributorElements.length > 0) {
+            const contributors: string[] = [];
+            for (const contributorEl of contributorElements) {
+                const name = this.extractText(contributorEl.name);
+                if (name) {
+                    contributors.push(name);
+                }
+            }
+            if (contributors.length > 0) {
+                dc.contributors = contributors;
+            }
+        }
+
+        if (Object.keys(dc).length === 0) {
+            return undefined;
+        }
+
+        return dc;
+    }
 }

src/utils/xml/AtomFeedBuilder.ts

@@ -1,5 +1,6 @@
 import {
     AcquisitionRel,
+    DCMetadata,
     EntryOptions,
     FeedKind,
     Link,
@@ -29,9 +30,9 @@ export class Entry {
 
     constructor(param1: EntryOptions | string, param2?: string) {
         if (typeof param1 === 'string' && param2 !== undefined) {
-            this.options = { id: param1, title: param2 };
+            this.options = { id: param1, title: param2, dcMetadata: {} };
         } else if (typeof param1 === 'object') {
-            this.options = { ...param1 };
+            this.options = { ...param1, dcMetadata: param1.dcMetadata || {} };
         } else {
             throw new Error('Invalid constructor arguments');
         }
@@ -249,6 +250,41 @@ export class Entry {
         return this.options.rights;
     }
 
+    /**
+     * Sets the DC metadata of the entry.
+     * @param dcMetadata - The DC metadata object.
+     * @returns The Entry instance (for chaining).
+     */
+    setDcMetadata(dcMetadata: DCMetadata) {
+        this.options.dcMetadata = dcMetadata;
+        return this;
+    }
+
+    /**
+     * Sets a specific field in the DC metadata of the entry.
+     * @param key - The key of the DC metadata field.
+     * @param value - The value to set for the specified field.
+     * @returns The Entry instance (for chaining).
+     */
+    setDcMetadataField<K extends keyof DCMetadata>(
+        key: K,
+        value: DCMetadata[K]
+    ) {
+        if (!this.options.dcMetadata) {
+            this.options.dcMetadata = {};
+        }
+        this.options.dcMetadata[key] = value;
+        return this;
+    }
+
+    /**
+     * Gets the DC metadata of the entry.
+     * @returns The DC metadata.
+     */
+    getDcMetadata(): DCMetadata {
+        return this.options.dcMetadata || {};
+    }
+
     /**
      * Adds extra metadata to the entry.
      * @param key - The key for the extra metadata.