@liuhange/dsh-gov-data-inspector 3.1.8 → 3.2.1

package/lib/configPack.js

@@ -0,0 +1,38 @@
+const REQUIRED_FIELDS = [
+    'configPackId',
+    'region',
+    'configPackVersion',
+    'policyBasis',
+    'requiredFields',
+    'formatRules',
+    'localStandardTerms',
+    'logicErrorRules',
+    'scoringWeights',
+    'itemTypeMatching',
+    'severityMapping',
+    'gbtMapping',
+    'dataSourceCredentials',
+    'dataSourcePriority',
+];
+export function normalizeConfigPack(raw) {
+    const requiredFields = (raw.requiredFields ?? raw.guideRequiredElements);
+    const scoringWeights = (raw.scoringWeights ?? raw.scoreWeights);
+    const gbtMapping = (raw.gbtMapping ?? raw.gbt47949Mapping);
+    const partial = { ...raw };
+    if (requiredFields !== undefined)
+        partial.requiredFields = requiredFields;
+    if (scoringWeights !== undefined)
+        partial.scoringWeights = scoringWeights;
+    if (gbtMapping !== undefined)
+        partial.gbtMapping = gbtMapping;
+    delete partial.guideRequiredElements;
+    delete partial.scoreWeights;
+    delete partial.gbt47949Mapping;
+    for (const field of REQUIRED_FIELDS) {
+        if (partial[field] === undefined || partial[field] === null) {
+            throw new Error(`GOV_CONFIG_PACK_INVALID: 必填字段 "${field}" 缺失`);
+        }
+    }
+    return partial;
+}
+//# sourceMappingURL=configPack.js.map

package/lib/configPackLoader.js

@@ -0,0 +1,126 @@
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { normalizeConfigPack } from './configPack.js';
+import { ConfigPackSchemaValidator } from './configPackSchemaValidator.js';
+import defaultConfigPack from './default-config-pack.json' with { type: 'json' };
+function tryLoadFromFilePath(warnings) {
+    const envPath = process.env.GOV_CONFIG_PACK_PATH;
+    if (!envPath)
+        return null;
+    try {
+        const raw = readFileSync(envPath, 'utf-8');
+        try {
+            const parsed = JSON.parse(raw);
+            const normalized = normalizeConfigPack(parsed);
+            const validation = ConfigPackSchemaValidator.validate(normalized);
+            if (!validation.valid) {
+                warnings.push({
+                    type: 'CONFIG_PACK_WARNING',
+                    code: 'GOV_CONFIG_PACK_SCHEMA_INVALID',
+                    message: `文件配置包 Schema 校验失败: ${validation.errors.map((e) => e.path).join(', ')}`,
+                });
+                return null;
+            }
+            return normalized;
+        }
+        catch (e) {
+            warnings.push({
+                type: 'CONFIG_PACK_WARNING',
+                code: 'GOV_CONFIG_PACK_PARSE_ERROR',
+                message: `文件配置包 JSON 解析失败: ${e.message}`,
+            });
+            return null;
+        }
+    }
+    catch (e) {
+        warnings.push({
+            type: 'CONFIG_PACK_WARNING',
+            code: 'GOV_CONFIG_PACK_NOT_FOUND',
+            message: `文件配置包加载失败: ${e.message}`,
+        });
+        return null;
+    }
+}
+function tryLoadFromNpmPackage(warnings) {
+    const packageName = process.env.GOV_CONFIG_PACK_PACKAGE;
+    if (!packageName)
+        return null;
+    try {
+        const require = createRequire(import.meta.url);
+        const raw = require(packageName);
+        try {
+            const normalized = normalizeConfigPack(raw);
+            const validation = ConfigPackSchemaValidator.validate(normalized);
+            if (!validation.valid) {
+                warnings.push({
+                    type: 'CONFIG_PACK_WARNING',
+                    code: 'GOV_CONFIG_PACK_SCHEMA_INVALID',
+                    message: `npm 包配置包 Schema 校验失败: ${validation.errors.map((e) => e.path).join(', ')}`,
+                });
+                return null;
+            }
+            return normalized;
+        }
+        catch (e) {
+            warnings.push({
+                type: 'CONFIG_PACK_WARNING',
+                code: 'GOV_CONFIG_PACK_PARSE_ERROR',
+                message: `npm 包配置包解析失败: ${e.message}`,
+            });
+            return null;
+        }
+    }
+    catch (e) {
+        warnings.push({
+            type: 'CONFIG_PACK_WARNING',
+            code: 'GOV_CONFIG_PACK_NOT_FOUND',
+            message: `npm 包配置包加载失败: ${e.message}`,
+        });
+        return null;
+    }
+}
+function tryLoadDefault(warnings) {
+    try {
+        const normalized = normalizeConfigPack(defaultConfigPack);
+        const validation = ConfigPackSchemaValidator.validate(normalized);
+        if (!validation.valid) {
+            warnings.push({
+                type: 'CONFIG_PACK_WARNING',
+                code: 'GOV_CONFIG_PACK_FALLBACK',
+                message: `缺省配置包 Schema 校验失败: ${validation.errors.map((e) => e.path).join(', ')}`,
+            });
+        }
+        return normalized;
+    }
+    catch (e) {
+        warnings.push({
+            type: 'CONFIG_PACK_WARNING',
+            code: 'GOV_CONFIG_PACK_FALLBACK',
+            message: `缺省配置包加载失败: ${e.message}`,
+        });
+        return defaultConfigPack;
+    }
+}
+export const ConfigPackLoader = {
+    load() {
+        const warnings = [];
+        const fromFile = tryLoadFromFilePath(warnings);
+        if (fromFile) {
+            return { configPack: fromFile, loadSource: 'file', warnings };
+        }
+        const fromNpm = tryLoadFromNpmPackage(warnings);
+        if (fromNpm) {
+            return { configPack: fromNpm, loadSource: 'npm', warnings };
+        }
+        if (warnings.length > 0) {
+            warnings.push({
+                type: 'CONFIG_PACK_WARNING',
+                code: 'GOV_CONFIG_PACK_FALLBACK',
+                message: '配置包加载回退至缺省配置包',
+            });
+        }
+        const fromDefault = tryLoadDefault(warnings);
+        return { configPack: fromDefault, loadSource: 'default', warnings };
+    },
+};
+//# sourceMappingURL=configPackLoader.js.map

package/lib/configPackSchemaValidator.js

@@ -0,0 +1,196 @@
+const REQUIRED_TOP_FIELDS = [
+    'configPackId',
+    'region',
+    'configPackVersion',
+    'policyBasis',
+    'requiredFields',
+    'formatRules',
+    'localStandardTerms',
+    'logicErrorRules',
+    'scoringWeights',
+    'itemTypeMatching',
+    'severityMapping',
+    'gbtMapping',
+    'dataSourceCredentials',
+    'dataSourcePriority',
+];
+function isObject(val) {
+    return typeof val === 'object' && val !== null && !Array.isArray(val);
+}
+function isString(val) {
+    return typeof val === 'string';
+}
+function isNumber(val) {
+    return typeof val === 'number';
+}
+function isArray(val) {
+    return Array.isArray(val);
+}
+function checkRegexSafety(pattern) {
+    if (/\([^)]*\+\)[+*]/.test(pattern))
+        return false;
+    if (/\([^)]*\*\)[+*]/.test(pattern))
+        return false;
+    if (/\(\?:[^)]*\)[+*]{2,}/.test(pattern))
+        return false;
+    if (/\[[^\]]*\*\]\[[^\]]*\*\]/.test(pattern))
+        return false;
+    if (/\[[^\]]*\+\]\[[^\]]*\+\]/.test(pattern))
+        return false;
+    try {
+        new RegExp(pattern);
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
+export const ConfigPackSchemaValidator = {
+    validate(pack) {
+        const errors = [];
+        if (!isObject(pack)) {
+            return { valid: false, errors: [{ path: '', message: '配置包应为对象' }] };
+        }
+        for (const field of REQUIRED_TOP_FIELDS) {
+            if (pack[field] === undefined || pack[field] === null) {
+                errors.push({ path: field, message: `必填字段 "${field}" 缺失` });
+            }
+        }
+        if (isString(pack.configPackId)) {
+            if (!/^([a-z]{2}-[a-z]+-\d{4})|default$/.test(pack.configPackId)) {
+                errors.push({ path: 'configPackId', message: 'configPackId 应匹配 ^[a-z]{2}-[a-z]+-\\d{4}$ 或为 default' });
+            }
+        }
+        if (isString(pack.region) && pack.region.length < 2) {
+            errors.push({ path: 'region', message: 'region 长度应不少于 2' });
+        }
+        if (isString(pack.configPackVersion)) {
+            if (!/^\d+\.\d+\.\d+$/.test(pack.configPackVersion)) {
+                errors.push({ path: 'configPackVersion', message: 'configPackVersion 应匹配 ^\\d+\\.\\d+\\.\\d+$' });
+            }
+        }
+        if (isArray(pack.policyBasis)) {
+            if (pack.policyBasis.length < 1) {
+                errors.push({ path: 'policyBasis', message: 'policyBasis 应至少含 1 个条目' });
+            }
+            for (let i = 0; i < pack.policyBasis.length; i++) {
+                const doc = pack.policyBasis[i];
+                if (!isObject(doc)) {
+                    errors.push({ path: `policyBasis[${i}]`, message: '应为对象' });
+                    continue;
+                }
+                for (const f of ['name', 'docNumber', 'coreRequirement']) {
+                    if (!isString(doc[f]) || doc[f].length < 1) {
+                        errors.push({ path: `policyBasis[${i}].${f}`, message: `应为非空字符串` });
+                    }
+                }
+            }
+        }
+        if (isArray(pack.requiredFields) && pack.requiredFields.length < 1) {
+            errors.push({ path: 'requiredFields', message: 'requiredFields 应至少含 1 个条目' });
+        }
+        if (isArray(pack.formatRules)) {
+            for (let i = 0; i < pack.formatRules.length; i++) {
+                const rule = pack.formatRules[i];
+                if (!isObject(rule)) {
+                    errors.push({ path: `formatRules[${i}]`, message: '应为对象' });
+                    continue;
+                }
+                if (!isString(rule.field)) {
+                    errors.push({ path: `formatRules[${i}].field`, message: '应为字符串' });
+                }
+                if (!isString(rule.suggestionTemplate)) {
+                    errors.push({ path: `formatRules[${i}].suggestionTemplate`, message: '应为字符串' });
+                }
+                if (isString(rule.pattern)) {
+                    if (!checkRegexSafety(rule.pattern)) {
+                        errors.push({ path: `formatRules[${i}].pattern`, message: `正则 "${rule.pattern}" 不安全（可能引发 ReDoS）` });
+                    }
+                }
+            }
+        }
+        if (isObject(pack.localStandardTerms)) {
+            if (!isArray(pack.localStandardTerms.materials)) {
+                errors.push({ path: 'localStandardTerms.materials', message: '应为数组' });
+            }
+            if (!isArray(pack.localStandardTerms.conditions)) {
+                errors.push({ path: 'localStandardTerms.conditions', message: '应为数组' });
+            }
+        }
+        if (isArray(pack.logicErrorRules)) {
+            for (let i = 0; i < pack.logicErrorRules.length; i++) {
+                const rule = pack.logicErrorRules[i];
+                if (!isObject(rule)) {
+                    errors.push({ path: `logicErrorRules[${i}]`, message: '应为对象' });
+                    continue;
+                }
+                if (!isString(rule.ruleId)) {
+                    errors.push({ path: `logicErrorRules[${i}].ruleId`, message: '应为字符串' });
+                }
+                if (!isString(rule.standardClause)) {
+                    errors.push({ path: `logicErrorRules[${i}].standardClause`, message: '应为字符串' });
+                }
+                if (!isArray(rule.triggerFields)) {
+                    errors.push({ path: `logicErrorRules[${i}].triggerFields`, message: '应为数组' });
+                }
+                if (!isArray(rule.triggerKeywords)) {
+                    errors.push({ path: `logicErrorRules[${i}].triggerKeywords`, message: '应为数组' });
+                }
+            }
+        }
+        if (isObject(pack.scoringWeights)) {
+            const sw = pack.scoringWeights;
+            const completeness = isNumber(sw.completeness) ? sw.completeness : NaN;
+            const accuracy = isNumber(sw.accuracy) ? sw.accuracy : NaN;
+            const traceability = isNumber(sw.traceability) ? sw.traceability : NaN;
+            if (isNaN(completeness) || isNaN(accuracy) || isNaN(traceability)) {
+                errors.push({ path: 'scoringWeights', message: 'completeness/accuracy/traceability 应为数字' });
+            }
+            else {
+                const sum = completeness + accuracy + traceability;
+                if (Math.abs(sum - 1) > 0.001) {
+                    errors.push({ path: 'scoringWeights', message: `三权重之和应为 1，实际为 ${sum}` });
+                }
+            }
+        }
+        if (isObject(pack.itemTypeMatching)) {
+            if (Object.keys(pack.itemTypeMatching).length < 1) {
+                errors.push({ path: 'itemTypeMatching', message: '应至少含 1 个条目' });
+            }
+        }
+        if (isObject(pack.severityMapping)) {
+            const validValues = ['critical', 'major', 'minor'];
+            for (const [key, val] of Object.entries(pack.severityMapping)) {
+                if (!validValues.includes(val)) {
+                    errors.push({ path: `severityMapping.${key}`, message: `应为 critical/major/minor，实际为 ${val}` });
+                }
+            }
+        }
+        if (isObject(pack.gbtMapping) && Object.keys(pack.gbtMapping).length < 1) {
+            errors.push({ path: 'gbtMapping', message: '应至少含 1 个条目' });
+        }
+        if (isObject(pack.dataSourceCredentials)) {
+            const ds = pack.dataSourceCredentials;
+            for (const src of ['national', 'provincial', 'standard']) {
+                if (!isObject(ds[src])) {
+                    errors.push({ path: `dataSourceCredentials.${src}`, message: '应为对象' });
+                }
+            }
+        }
+        if (isArray(pack.dataSourcePriority)) {
+            if (pack.dataSourcePriority.length < 1) {
+                errors.push({ path: 'dataSourcePriority', message: '应至少含 1 个条目' });
+            }
+            for (let i = 0; i < pack.dataSourcePriority.length; i++) {
+                if (!['national', 'provincial'].includes(pack.dataSourcePriority[i])) {
+                    errors.push({ path: `dataSourcePriority[${i}]`, message: '应为 national 或 provincial' });
+                }
+            }
+        }
+        return { valid: errors.length === 0, errors };
+    },
+    checkRegexSafety(pattern) {
+        return checkRegexSafety(pattern);
+    },
+};
+//# sourceMappingURL=configPackSchemaValidator.js.map