@aflueza/log-analysis 0.0.0-stage → 0.2.1-rc.2

package/lib/database/parser-rules-database.js

@@ -0,0 +1,199 @@
+import { mkdirSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { randomUUID } from 'node:crypto';
+const SCHEMA_VERSION = 2;
+export class ParserRulesDatabaseError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+export class ParserRulesDatabase {
+    db;
+    writeQueue = Promise.resolve();
+    constructor(path) {
+        const absolute = resolve(path);
+        mkdirSync(dirname(absolute), { recursive: true });
+        this.db = new DatabaseSync(absolute);
+        try {
+            this.db.exec('PRAGMA foreign_keys=ON; PRAGMA busy_timeout=5000;');
+            this.migrate();
+        }
+        catch (e) {
+            this.db.close();
+            throw e;
+        }
+    }
+    close() {
+        this.db.close();
+    }
+    list() {
+        return this.db.prepare('SELECT * FROM parser_rules ORDER BY name COLLATE NOCASE').all().map(mapRow);
+    }
+    get(id) {
+        const row = this.db.prepare('SELECT * FROM parser_rules WHERE id=?').get(id);
+        if (!row)
+            throw new ParserRulesDatabaseError('not-found', '解析规则不存在');
+        return mapRow(row);
+    }
+    findByName(name) {
+        const row = this.db
+            .prepare('SELECT * FROM parser_rules WHERE name=? COLLATE NOCASE')
+            .get(name.trim());
+        return row ? mapRow(row) : undefined;
+    }
+    async create(name, rule, sampleRaw = '') {
+        return this.enqueue(() => {
+            const clean = normalizeName(name);
+            const valid = validateRule(rule);
+            const sample = normalizeSample(sampleRaw);
+            if (this.findByName(clean))
+                throw new ParserRulesDatabaseError('duplicate-name', '解析规则名称已存在');
+            const now = Date.now();
+            const id = randomUUID();
+            this.db
+                .prepare('INSERT INTO parser_rules(id,name,format,record_start,fields,continuation,sample_raw,created_at,updated_at,revision) VALUES(?,?,?,?,?,?,?,?,?,1)')
+                .run(id, clean, valid.format, valid.recordStart, JSON.stringify(valid.fields), valid.continuation, sample, now, now);
+            return this.get(id);
+        });
+    }
+    async update(id, name, rule, sampleRaw = '') {
+        return this.enqueue(() => {
+            const current = this.get(id);
+            const clean = normalizeName(name);
+            const valid = validateRule(rule);
+            const sample = normalizeSample(sampleRaw);
+            const conflict = this.findByName(clean);
+            if (conflict && conflict.id !== id)
+                throw new ParserRulesDatabaseError('duplicate-name', '解析规则名称已存在');
+            const now = Date.now();
+            this.db
+                .prepare('UPDATE parser_rules SET name=?,format=?,record_start=?,fields=?,continuation=?,sample_raw=?,updated_at=?,revision=? WHERE id=?')
+                .run(clean, valid.format, valid.recordStart, JSON.stringify(valid.fields), valid.continuation, sample, now, current.revision + 1, id);
+            return this.get(id);
+        });
+    }
+    async delete(id) {
+        return this.enqueue(() => {
+            const result = this.db.prepare('DELETE FROM parser_rules WHERE id=?').run(id);
+            if (Number(result.changes) === 0)
+                throw new ParserRulesDatabaseError('not-found', '解析规则不存在');
+        });
+    }
+    enqueue(task) {
+        const run = this.writeQueue.then(task);
+        this.writeQueue = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    migrate() {
+        const version = Number(this.db.prepare('PRAGMA user_version').get().user_version);
+        if (version > SCHEMA_VERSION)
+            throw new Error(`解析规则数据库版本 ${version} 不受支持`);
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            this.db.exec("CREATE TABLE IF NOT EXISTS parser_rules (id TEXT PRIMARY KEY,name TEXT NOT NULL UNIQUE COLLATE NOCASE,format TEXT NOT NULL,record_start TEXT NOT NULL,fields TEXT NOT NULL,continuation TEXT NOT NULL,sample_raw TEXT NOT NULL DEFAULT '',created_at INTEGER NOT NULL,updated_at INTEGER NOT NULL,revision INTEGER NOT NULL DEFAULT 1);");
+            if (version === 1)
+                this.db.exec("ALTER TABLE parser_rules ADD COLUMN sample_raw TEXT NOT NULL DEFAULT '';");
+            this.db.exec(`PRAGMA user_version=${SCHEMA_VERSION};`);
+            this.db.exec('COMMIT');
+        }
+        catch (e) {
+            this.db.exec('ROLLBACK');
+            throw e;
+        }
+    }
+}
+function normalizeName(value) {
+    const name = value.trim();
+    if (!name)
+        throw new ParserRulesDatabaseError('invalid-name', '解析规则名称不能为空');
+    return name;
+}
+function normalizeSample(value) {
+    return String(value ?? '')
+        .replace(/\r\n?/g, '\n')
+        .slice(0, 120_000);
+}
+function validateRule(value) {
+    if (!value ||
+        value.version !== 1 ||
+        typeof value.format !== 'string' ||
+        !value.format.trim() ||
+        typeof value.recordStart !== 'string' ||
+        !value.fields ||
+        value.continuation !== 'until-next-record')
+        throw new ParserRulesDatabaseError('invalid-rule', '解析规则结构无效');
+    const fields = { ...value.fields };
+    validatePattern(value.recordStart, 'recordStart', true, false);
+    for (const [field, spec] of Object.entries(fields)) {
+        if (!spec || typeof spec.pattern !== 'string')
+            throw new ParserRulesDatabaseError('invalid-rule', `解析规则字段无效：${field}`);
+        if (!spec.pattern.trim()) {
+            delete fields[field];
+            continue;
+        }
+        validatePattern(spec.pattern, field, false, true);
+    }
+    return {
+        version: 1,
+        format: value.format.trim().slice(0, 80),
+        recordStart: value.recordStart,
+        fields,
+        continuation: 'until-next-record',
+    };
+}
+function validatePattern(pattern, label, anchored, capture) {
+    const fieldLabel = displayParserField(label);
+    if (!pattern ||
+        pattern.length > 512 ||
+        (anchored && !pattern.startsWith('^')) ||
+        /\(\?<[/=!]/.test(pattern) ||
+        /\\[1-9]|\\k</.test(pattern))
+        throw new ParserRulesDatabaseError('invalid-rule', `解析规则正则无效：${fieldLabel}`);
+    try {
+        const expression = new RegExp(pattern, 'm');
+        if (anchored && expression.test(''))
+            throw new Error();
+        if (capture && !/(^|[^\\])\((?!\?)/.test(pattern))
+            throw new Error();
+    }
+    catch {
+        throw new ParserRulesDatabaseError('invalid-rule', `解析规则正则无效：${fieldLabel}`);
+    }
+}
+function displayParserField(field) {
+    const labels = {
+        recordStart: '记录起始正则',
+        level: '级别',
+        timestamp: '时间',
+        exceptionType: '异常',
+        loggerName: '类名',
+        threadName: '线程',
+        sourceLine: '行号',
+        traceId: 'TraceId',
+        spanId: 'SpanId',
+        service: '服务',
+        mdc: 'MDC',
+        message: '消息',
+    };
+    return labels[field] ?? field;
+}
+function mapRow(row) {
+    return {
+        id: String(row.id),
+        name: String(row.name),
+        rule: {
+            version: 1,
+            format: String(row.format),
+            recordStart: String(row.record_start),
+            fields: JSON.parse(String(row.fields)),
+            continuation: String(row.continuation),
+        },
+        sampleRaw: String(row.sample_raw ?? ''),
+        createdAt: Number(row.created_at),
+        updatedAt: Number(row.updated_at),
+        revision: Number(row.revision),
+    };
+}