fix: Tests

Author: flyingrobots

src/domain/schemas/GitTrailerSchema.js

@@ -25,40 +25,48 @@ const buildKeyRegex = (keyPattern) => {
   }
 };
 
+const normalizeKeyPattern = (keyPattern) => {
+  if (keyPattern instanceof RegExp) {
+    return keyPattern.source;
+  }
+  return keyPattern;
+};
+
 /**
  * Creates a Git trailer schema bundle with customizable validation rules.
  * @param {Object} options - Configuration options
- * @param {string} options.keyPattern - Regex pattern string for key validation (will be anchored)
+ * @param {string|RegExp} options.keyPattern - Regex pattern string or RegExp for key validation (will be anchored)
  * @param {number} options.keyMaxLength - Maximum length for trailer keys
  * @returns {{ schema: z.ZodObject, keyPattern: string, keyRegex: RegExp }}
  */
 export function createGitTrailerSchemaBundle({ keyPattern = DEFAULT_KEY_PATTERN, keyMaxLength = 100 } = {}) {
-  if (typeof keyPattern !== 'string' || keyPattern.length === 0) {
-    throw new TypeError('keyPattern must be a non-empty string');
+  const normalizedKeyPattern = normalizeKeyPattern(keyPattern);
+  if (typeof normalizedKeyPattern !== 'string' || normalizedKeyPattern.length === 0) {
+    throw new TypeError('keyPattern must be a non-empty string or RegExp');
   }
   if (!Number.isInteger(keyMaxLength) || keyMaxLength <= 0) {
     throw new TypeError('keyMaxLength must be a positive integer');
   }
 
-  const cacheKey = `${keyPattern}::${keyMaxLength}`;
+  const cacheKey = `${normalizedKeyPattern}::${keyMaxLength}`;
   if (bundleCache.has(cacheKey)) {
     return bundleCache.get(cacheKey);
   }
 
-  const keyRegex = buildKeyRegex(keyPattern);
+  const keyRegex = buildKeyRegex(normalizedKeyPattern);
   const bundle = {
     schema: z.object({
       key: z
         .string()
         .min(1)
         .max(keyMaxLength, 'Trailer key must not exceed character limit')
-        .regex(keyRegex, `Trailer key must match the required pattern ${keyPattern}`),
+        .regex(keyRegex, `Trailer key must match the required pattern ${normalizedKeyPattern}`),
       value: z
         .string()
         .min(1)
         .regex(/^[^\r\n]+$/, 'Trailer values cannot contain line breaks'),
     }),
-    keyPattern,
+    keyPattern: normalizedKeyPattern,
     keyRegex,
   };
 

src/domain/services/TrailerCodecService.js

@@ -142,9 +142,14 @@ export default class TrailerCodecService {
   _buildTrailers(lines) {
     return lines.reduce((acc, line) => {
       const match = this.parser.lineRegex.exec(line);
-      if (match) {
-        acc.push(this.trailerFactory(match[1], match[2], this.schemaBundle.schema));
+      if (!match) {
+        return acc;
       }
+
+      const key = match.groups?.key ?? match[1];
+      const value = match.groups?.value ?? match[2];
+
+      acc.push(this.trailerFactory(key, value, this.schemaBundle.schema));
       return acc;
     }, []);
   }

src/domain/services/TrailerParser.js

@@ -19,7 +19,7 @@ export default class TrailerParser {
     /**
      * @type {RegExp}
      */
-    this.lineRegex = new RegExp(`^(${keyPattern}):\\s*(.*)$`);
+    this.lineRegex = new RegExp(`^(?<key>${keyPattern}):\\s*(?<value>[\\s\\S]*)$`);
   }
 
   /**

src/domain/value-objects/GitTrailer.js

@@ -17,11 +17,13 @@ export default class GitTrailer {
    */
   constructor(key, value, schema = GitTrailerSchema) {
     const actualSchema = this._validateSchema(schema);
-    const normalizedKey = String(key ?? '').toLowerCase();
-    const normalizedValue = String(value ?? '').trim();
+    const rawKey = String(key ?? '');
+    const normalizedKey = rawKey.toLowerCase();
+    const rawValue = String(value ?? '');
+    const normalizedValue = rawValue.trim();
 
     try {
-      actualSchema.parse({ key: normalizedKey, value: normalizedValue });
+      actualSchema.parse({ key: rawKey, value: normalizedValue });
       this.key = normalizedKey;
       this.value = normalizedValue;
     } catch (error) {