@wener/common 2.0.5 → 2.0.6

package/lib/drain3/LogCluster.js

@@ -1,38 +1,38 @@
 /**
  * Represents a cluster of similar log messages with a common template.
  */ export class LogCluster {
-    clusterId;
-    logTemplateTokens;
-    size;
-    constructor(clusterId, logTemplateTokens, size = 1){
-        this.clusterId = clusterId;
-        this.logTemplateTokens = logTemplateTokens;
-        this.size = size;
-    }
-    /**
+	clusterId;
+	logTemplateTokens;
+	size;
+	constructor(clusterId, logTemplateTokens, size = 1) {
+		this.clusterId = clusterId;
+		this.logTemplateTokens = logTemplateTokens;
+		this.size = size;
+	}
+	/**
 	 * Returns the template as a space-separated string.
 	 */ getTemplate() {
-        return this.logTemplateTokens.join(' ');
-    }
-    /**
+		return this.logTemplateTokens.join(' ');
+	}
+	/**
 	 * Returns a string representation of the cluster.
 	 */ toString() {
-        return `ID=${this.clusterId.toString().padEnd(5)} : size=${this.size.toString().padEnd(10)}: ${this.getTemplate()}`;
-    }
-    /**
+		return `ID=${this.clusterId.toString().padEnd(5)} : size=${this.size.toString().padEnd(10)}: ${this.getTemplate()}`;
+	}
+	/**
 	 * Creates a LogCluster from JSON data.
 	 */ static fromJSON(data) {
-        return new LogCluster(data.clusterId, data.logTemplateTokens, data.size);
-    }
-    /**
+		return new LogCluster(data.clusterId, data.logTemplateTokens, data.size);
+	}
+	/**
 	 * Converts the cluster to JSON for serialization.
 	 */ toJSON() {
-        return {
-            clusterId: this.clusterId,
-            logTemplateTokens: this.logTemplateTokens,
-            size: this.size
-        };
-    }
+		return {
+			clusterId: this.clusterId,
+			logTemplateTokens: this.logTemplateTokens,
+			size: this.size,
+		};
+	}
 }
 
-//# sourceMappingURL=LogCluster.js.map
+//# sourceMappingURL=LogCluster.js.map

package/lib/drain3/Node.js

@@ -1,39 +1,39 @@
 /**
  * Represents a node in the prefix tree used by Drain algorithm.
  */ export class Node {
-    /**
+	/**
 	 * Map of token keys to child nodes.
 	 */ keyToChildNode = new Map();
-    /**
+	/**
 	 * List of cluster IDs associated with this node.
 	 */ clusterIds = [];
-    /**
+	/**
 	 * Creates a new empty node.
 	 */ static newNode() {
-        return new Node();
-    }
-    /**
+		return new Node();
+	}
+	/**
 	 * Converts the node to JSON for serialization.
 	 */ toJSON() {
-        const keyToChildNode = {};
-        for (const [key, node] of this.keyToChildNode){
-            keyToChildNode[key] = node.toJSON();
-        }
-        return {
-            keyToChildNode,
-            clusterIds: this.clusterIds
-        };
-    }
-    /**
+		const keyToChildNode = {};
+		for (const [key, node] of this.keyToChildNode) {
+			keyToChildNode[key] = node.toJSON();
+		}
+		return {
+			keyToChildNode,
+			clusterIds: this.clusterIds,
+		};
+	}
+	/**
 	 * Creates a Node from JSON data.
 	 */ static fromJSON(data) {
-        const node = new Node();
-        node.clusterIds = data.clusterIds;
-        for (const [key, childData] of Object.entries(data.keyToChildNode)){
-            node.keyToChildNode.set(key, Node.fromJSON(childData));
-        }
-        return node;
-    }
+		const node = new Node();
+		node.clusterIds = data.clusterIds;
+		for (const [key, childData] of Object.entries(data.keyToChildNode)) {
+			node.keyToChildNode.set(key, Node.fromJSON(childData));
+		}
+		return node;
+	}
 }
 
-//# sourceMappingURL=Node.js.map
+//# sourceMappingURL=Node.js.map

package/lib/drain3/TemplateMiner.js

@@ -1,204 +1,205 @@
-import { Drain } from "./Drain.js";
+import { Drain } from './Drain.js';
 /**
  * High-level API for log template mining with persistence support.
  *
  * TemplateMiner wraps the Drain algorithm and provides convenience methods
  * for extracting parameters and managing persistence.
  */ export class TemplateMiner {
-    drain;
-    persistence;
-    constructor(drain, persistence) {
-        this.drain = drain;
-        this.persistence = persistence;
-    }
-    /**
-     * Adds a log message and returns the update type, cluster, template, and cluster count.
-     *
-     * @param content The log message content
-     * @returns Object containing updateType, cluster, templateMined, and clusterCount
-     */ async addLogMessage(content) {
-        const { cluster, updateType } = this.drain.addLogMessage(content);
-        const templateMined = cluster.getTemplate();
-        const clusterCount = this.drain.getClusters().length;
-        if (updateType !== "none") {
-            await this.saveState();
-        }
-        return {
-            updateType,
-            cluster,
-            templateMined,
-            clusterCount
-        };
-    }
-    /**
-     * Matches a log message against an already existing cluster.
-     *
-     * @param content Log message to match
-     * @param strategy Search strategy
-     * @returns Matched cluster or null
-     */ match(content, strategy = "never") {
-        return this.drain.match(content, strategy);
-    }
-    /**
-     * Extracts parameters from a log message according to a provided template.
-     *
-     * @param logTemplate Template generated by AddLogMessage
-     * @param logMessage The log message to extract parameters from
-     * @returns Array of extracted parameters, or null if template doesn't match
-     */ extractParameters(logTemplate, logMessage) {
-        // Apply delimiters
-        let processedMessage = logMessage;
-        for (const delimiter of this.drain.extraDelimiters) {
-            // Escape delimiter for regex if it contains special characters
-            const escapedDelimiter = delimiter.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-            processedMessage = processedMessage.replace(new RegExp(escapedDelimiter, "g"), " ");
-        }
-        const { templateRegex, paramGroupNameToMaskName } = this.getTemplateParameterExtractionRegex(logTemplate);
-        // Create regex from template
-        const regex = new RegExp(templateRegex);
-        // Match the log message against the template
-        const match = processedMessage.match(regex);
-        // Template doesn't match
-        if (match === null) {
-            return null;
-        }
-        // Extract named captures
-        const extractedParameters = [];
-        // Get all named groups from the match
-        if (match.groups) {
-            for (const [groupName, value] of Object.entries(match.groups)) {
-                if (value !== undefined) {
-                    const maskName = paramGroupNameToMaskName.get(groupName);
-                    if (maskName !== undefined) {
-                        extractedParameters.push({
-                            value,
-                            maskName
-                        });
-                    }
-                }
-            }
-        }
-        // Also check by index if groups are not available (fallback)
-        // The regex exec method provides better named group support
-        const execResult = regex.exec(processedMessage);
-        if (execResult !== null && execResult.groups === undefined) {
-            // Fallback: extract by order (less reliable but works)
-            const indices = Array.from({
-                length: execResult.length - 1
-            }, (_, i) => i + 1);
-            let paramIndex = 0;
-            for (const index of indices) {
-                const value = execResult[index];
-                if (value !== undefined) {
-                    // Find corresponding mask name by order
-                    // This is a fallback - ideally we should use named groups
-                    const maskName = paramGroupNameToMaskName.get(`p_${paramIndex}`);
-                    if (maskName !== undefined) {
-                        extractedParameters.push({
-                            value,
-                            maskName
-                        });
-                    }
-                    paramIndex++;
-                }
-            }
-        }
-        return extractedParameters.length > 0 ? extractedParameters : null;
-    }
-    /**
-     * Gets the template parameter extraction regex and mapping.
-     *
-     * @param logTemplate The log template
-     * @returns Tuple of [templateRegex, paramGroupNameToMaskName]
-     */ getTemplateParameterExtractionRegex(logTemplate) {
-        const paramGroupNameToMaskName = new Map();
-        let paramNameCounter = 0;
-        const getNextParamName = () => {
-            const paramGroupName = `p_${paramNameCounter}`;
-            paramNameCounter++;
-            return paramGroupName;
-        };
-        // Create a named group with the respective patterns for the given mask-name
-        const createCaptureRegex = (maskName) => {
-            const allowedPatterns = [];
-            if (maskName === "*") {
-                allowedPatterns.push(".+?");
-            }
-            // Give each capture group a unique name to avoid conflict
-            const paramGroupName = getNextParamName();
-            paramGroupNameToMaskName.set(paramGroupName, maskName);
-            const joinedPatterns = allowedPatterns.join("|");
-            const captureRegex = `(?<${paramGroupName}>${joinedPatterns})`;
-            return captureRegex;
-        };
-        // For every mask in the template, replace it with a named group
-        const maskNames = new Set();
-        // The drain catch-all mask
-        maskNames.add("*");
-        // Escape the template for regex
-        let templateRegex = this.escapeRegex(logTemplate);
-        // Replace each mask name with a proper regex that captures it
-        for (const maskName of maskNames) {
-            const searchStr = `<${this.escapeRegex(maskName)}>`;
-            // Replace one-by-one to get a new param group name for each replacement
-            while (true) {
-                const repStr = createCaptureRegex(maskName);
-                const templateRegexNew = templateRegex.replace(searchStr, repStr);
-                // Break when all replaces for this mask are done
-                if (templateRegexNew === templateRegex) {
-                    break;
-                }
-                templateRegex = templateRegexNew;
-            }
-        }
-        // Match also messages with multiple spaces or other whitespace chars between tokens
-        templateRegex = templateRegex.replace(/\\ /g, "\\s+");
-        templateRegex = `^${templateRegex}$`;
-        return {
-            templateRegex,
-            paramGroupNameToMaskName
-        };
-    }
-    /**
-     * Escapes special regex characters in a string.
-     */ escapeRegex(str) {
-        return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    }
-    /**
-     * Loads the Drain state from persistence.
-     *
-     * @throws Error if loading fails
-     */ async loadState() {
-        const state = await this.persistence.load();
-        if (state === null || typeof state === "string" && state.length === 0) {
-            throw new Error("saved state not found");
-        }
-        try {
-            const stateStr = typeof state === "string" ? state : new TextDecoder().decode(state);
-            const data = JSON.parse(stateStr);
-            this.drain = Drain.fromJSON(data);
-        }
-        catch (error) {
-            throw new Error(`failed to unmarshal state: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Saves the Drain state to persistence.
-     *
-     * @throws Error if saving fails
-     */ async saveState() {
-        try {
-            const state = JSON.stringify(this.drain.toJSON());
-            await this.persistence.save(state);
-        }
-        catch (error) {
-            throw new Error(`failed to save state: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Gets the underlying Drain instance.
-     */ getDrain() {
-        return this.drain;
-    }
+	drain;
+	persistence;
+	constructor(drain, persistence) {
+		this.drain = drain;
+		this.persistence = persistence;
+	}
+	/**
+	 * Adds a log message and returns the update type, cluster, template, and cluster count.
+	 *
+	 * @param content The log message content
+	 * @returns Object containing updateType, cluster, templateMined, and clusterCount
+	 */ async addLogMessage(content) {
+		const { cluster, updateType } = this.drain.addLogMessage(content);
+		const templateMined = cluster.getTemplate();
+		const clusterCount = this.drain.getClusters().length;
+		if (updateType !== 'none') {
+			await this.saveState();
+		}
+		return {
+			updateType,
+			cluster,
+			templateMined,
+			clusterCount,
+		};
+	}
+	/**
+	 * Matches a log message against an already existing cluster.
+	 *
+	 * @param content Log message to match
+	 * @param strategy Search strategy
+	 * @returns Matched cluster or null
+	 */ match(content, strategy = 'never') {
+		return this.drain.match(content, strategy);
+	}
+	/**
+	 * Extracts parameters from a log message according to a provided template.
+	 *
+	 * @param logTemplate Template generated by AddLogMessage
+	 * @param logMessage The log message to extract parameters from
+	 * @returns Array of extracted parameters, or null if template doesn't match
+	 */ extractParameters(logTemplate, logMessage) {
+		// Apply delimiters
+		let processedMessage = logMessage;
+		for (const delimiter of this.drain.extraDelimiters) {
+			// Escape delimiter for regex if it contains special characters
+			const escapedDelimiter = delimiter.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+			processedMessage = processedMessage.replace(new RegExp(escapedDelimiter, 'g'), ' ');
+		}
+		const { templateRegex, paramGroupNameToMaskName } = this.getTemplateParameterExtractionRegex(logTemplate);
+		// Create regex from template
+		const regex = new RegExp(templateRegex);
+		// Match the log message against the template
+		const match = processedMessage.match(regex);
+		// Template doesn't match
+		if (match === null) {
+			return null;
+		}
+		// Extract named captures
+		const extractedParameters = [];
+		// Get all named groups from the match
+		if (match.groups) {
+			for (const [groupName, value] of Object.entries(match.groups)) {
+				if (value !== undefined) {
+					const maskName = paramGroupNameToMaskName.get(groupName);
+					if (maskName !== undefined) {
+						extractedParameters.push({
+							value,
+							maskName,
+						});
+					}
+				}
+			}
+		}
+		// Also check by index if groups are not available (fallback)
+		// The regex exec method provides better named group support
+		const execResult = regex.exec(processedMessage);
+		if (execResult !== null && execResult.groups === undefined) {
+			// Fallback: extract by order (less reliable but works)
+			const indices = Array.from(
+				{
+					length: execResult.length - 1,
+				},
+				(_, i) => i + 1,
+			);
+			let paramIndex = 0;
+			for (const index of indices) {
+				const value = execResult[index];
+				if (value !== undefined) {
+					// Find corresponding mask name by order
+					// This is a fallback - ideally we should use named groups
+					const maskName = paramGroupNameToMaskName.get(`p_${paramIndex}`);
+					if (maskName !== undefined) {
+						extractedParameters.push({
+							value,
+							maskName,
+						});
+					}
+					paramIndex++;
+				}
+			}
+		}
+		return extractedParameters.length > 0 ? extractedParameters : null;
+	}
+	/**
+	 * Gets the template parameter extraction regex and mapping.
+	 *
+	 * @param logTemplate The log template
+	 * @returns Tuple of [templateRegex, paramGroupNameToMaskName]
+	 */ getTemplateParameterExtractionRegex(logTemplate) {
+		const paramGroupNameToMaskName = new Map();
+		let paramNameCounter = 0;
+		const getNextParamName = () => {
+			const paramGroupName = `p_${paramNameCounter}`;
+			paramNameCounter++;
+			return paramGroupName;
+		};
+		// Create a named group with the respective patterns for the given mask-name
+		const createCaptureRegex = (maskName) => {
+			const allowedPatterns = [];
+			if (maskName === '*') {
+				allowedPatterns.push('.+?');
+			}
+			// Give each capture group a unique name to avoid conflict
+			const paramGroupName = getNextParamName();
+			paramGroupNameToMaskName.set(paramGroupName, maskName);
+			const joinedPatterns = allowedPatterns.join('|');
+			const captureRegex = `(?<${paramGroupName}>${joinedPatterns})`;
+			return captureRegex;
+		};
+		// For every mask in the template, replace it with a named group
+		const maskNames = new Set();
+		// The drain catch-all mask
+		maskNames.add('*');
+		// Escape the template for regex
+		let templateRegex = this.escapeRegex(logTemplate);
+		// Replace each mask name with a proper regex that captures it
+		for (const maskName of maskNames) {
+			const searchStr = `<${this.escapeRegex(maskName)}>`;
+			// Replace one-by-one to get a new param group name for each replacement
+			while (true) {
+				const repStr = createCaptureRegex(maskName);
+				const templateRegexNew = templateRegex.replace(searchStr, repStr);
+				// Break when all replaces for this mask are done
+				if (templateRegexNew === templateRegex) {
+					break;
+				}
+				templateRegex = templateRegexNew;
+			}
+		}
+		// Match also messages with multiple spaces or other whitespace chars between tokens
+		templateRegex = templateRegex.replace(/\\ /g, '\\s+');
+		templateRegex = `^${templateRegex}$`;
+		return {
+			templateRegex,
+			paramGroupNameToMaskName,
+		};
+	}
+	/**
+	 * Escapes special regex characters in a string.
+	 */ escapeRegex(str) {
+		return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+	}
+	/**
+	 * Loads the Drain state from persistence.
+	 *
+	 * @throws Error if loading fails
+	 */ async loadState() {
+		const state = await this.persistence.load();
+		if (state === null || (typeof state === 'string' && state.length === 0)) {
+			throw new Error('saved state not found');
+		}
+		try {
+			const stateStr = typeof state === 'string' ? state : new TextDecoder().decode(state);
+			const data = JSON.parse(stateStr);
+			this.drain = Drain.fromJSON(data);
+		} catch (error) {
+			throw new Error(`failed to unmarshal state: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	/**
+	 * Saves the Drain state to persistence.
+	 *
+	 * @throws Error if saving fails
+	 */ async saveState() {
+		try {
+			const state = JSON.stringify(this.drain.toJSON());
+			await this.persistence.save(state);
+		} catch (error) {
+			throw new Error(`failed to save state: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	/**
+	 * Gets the underlying Drain instance.
+	 */ getDrain() {
+		return this.drain;
+	}
 }
 //# sourceMappingURL=TemplateMiner.js.map

package/lib/drain3/index.js

@@ -23,9 +23,9 @@
  * const miner = new TemplateMiner(drain, new MemoryPersistence());
  * await miner.addLogMessage('[INFO] User 123 logged in');
  * ```
- */ export { Drain } from "./Drain.js";
-export { LogCluster } from "./LogCluster.js";
-export { Node } from "./Node.js";
-export { TemplateMiner } from "./TemplateMiner.js";
-export { MemoryPersistence } from "./persistence/MemoryPersistence.js";
+ */ export { Drain } from './Drain.js';
+export { LogCluster } from './LogCluster.js';
+export { Node } from './Node.js';
+export { MemoryPersistence } from './persistence/MemoryPersistence.js';
+export { TemplateMiner } from './TemplateMiner.js';
 //# sourceMappingURL=index.js.map

package/lib/drain3/persistence/FilePersistence.js

@@ -1,24 +1,24 @@
-import { readFile, writeFile } from "node:fs/promises";
+import { readFile, writeFile } from 'node:fs/promises';
 /**
  * File-based persistence handler that saves and loads state from the filesystem.
  */ export class FilePersistence {
-    filePath;
-    constructor(filePath){
-        this.filePath = filePath;
-    }
-    async save(state) {
-        await writeFile(this.filePath, state, 'utf8');
-    }
-    async load() {
-        try {
-            return await readFile(this.filePath, 'utf8');
-        } catch (error) {
-            if (error?.code === 'ENOENT') {
-                return null;
-            }
-            throw error;
-        }
-    }
+	filePath;
+	constructor(filePath) {
+		this.filePath = filePath;
+	}
+	async save(state) {
+		await writeFile(this.filePath, state, 'utf8');
+	}
+	async load() {
+		try {
+			return await readFile(this.filePath, 'utf8');
+		} catch (error) {
+			if (error?.code === 'ENOENT') {
+				return null;
+			}
+			throw error;
+		}
+	}
 }
 
-//# sourceMappingURL=FilePersistence.js.map
+//# sourceMappingURL=FilePersistence.js.map

package/lib/drain3/persistence/MemoryPersistence.js

@@ -2,17 +2,17 @@
  * In-memory persistence handler that stores state in memory.
  * Useful for testing or when persistence is not needed.
  */ export class MemoryPersistence {
-    state = null;
-    /**
+	state = null;
+	/**
 	 * Saves the state to memory.
 	 */ async save(state) {
-        this.state = state;
-    }
-    /**
+		this.state = state;
+	}
+	/**
 	 * Loads the state from memory.
 	 */ async load() {
-        return this.state;
-    }
+		return this.state;
+	}
 }
 
-//# sourceMappingURL=MemoryPersistence.js.map
+//# sourceMappingURL=MemoryPersistence.js.map

package/lib/drain3/persistence/PersistenceHandler.js

@@ -1,5 +1,5 @@
 /**
  * Interface for persistence handlers that can save and load Drain state.
- */ export { };
+ */ export {};
 
-//# sourceMappingURL=PersistenceHandler.js.map
+//# sourceMappingURL=PersistenceHandler.js.map

package/lib/drain3/types.js

@@ -2,6 +2,6 @@
  * Cluster update type indicating what happened when a log message was processed.
  */ /**
  * Extracted parameter from a log message based on a template.
- */ export { };
+ */ export {};
 
-//# sourceMappingURL=types.js.map
+//# sourceMappingURL=types.js.map