@liuhange/dsh-gov-data-inspector 3.1.7 → 3.2.0

package/lib/config-pack-schema.json

@@ -0,0 +1,186 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://liuhange.dev/gov-data-inspector/config-pack-schema.json",
+    "title": "Government Data Inspector Config Pack",
+    "type": "object",
+    "required": [
+        "configPackId",
+        "region",
+        "configPackVersion",
+        "policyBasis",
+        "requiredFields",
+        "formatRules",
+        "localStandardTerms",
+        "logicErrorRules",
+        "scoringWeights",
+        "itemTypeMatching",
+        "severityMapping",
+        "gbtMapping",
+        "dataSourceCredentials",
+        "dataSourcePriority"
+    ],
+    "properties": {
+        "configPackId": {
+            "type": "string",
+            "pattern": "^[a-z]{2}-[a-z]+-\\d{4}$|^default$"
+        },
+        "region": {
+            "type": "string",
+            "minLength": 2
+        },
+        "configPackVersion": {
+            "type": "string",
+            "pattern": "^\\d+\\.\\d+\\.\\d+$"
+        },
+        "policyBasis": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+                "type": "object",
+                "required": ["name", "docNumber", "coreRequirement"],
+                "properties": {
+                    "name": { "type": "string", "minLength": 1 },
+                    "docNumber": { "type": "string", "minLength": 1 },
+                    "coreRequirement": { "type": "string", "minLength": 1 }
+                }
+            }
+        },
+        "requiredFields": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "type": "string" }
+        },
+        "formatRules": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "required": ["field", "suggestionTemplate"],
+                "properties": {
+                    "field": { "type": "string" },
+                    "pattern": { "type": "string" },
+                    "requiredKeywords": {
+                        "type": "array",
+                        "items": { "type": "string" }
+                    },
+                    "suggestionTemplate": { "type": "string" }
+                }
+            }
+        },
+        "localStandardTerms": {
+            "type": "object",
+            "required": ["materials", "conditions"],
+            "properties": {
+                "materials": {
+                    "type": "array",
+                    "items": { "type": "string" }
+                },
+                "conditions": {
+                    "type": "array",
+                    "items": { "type": "string" }
+                }
+            }
+        },
+        "logicErrorRules": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "required": ["ruleId", "standardClause", "triggerFields", "triggerKeywords"],
+                "properties": {
+                    "ruleId": { "type": "string" },
+                    "standardClause": { "type": "string" },
+                    "triggerFields": {
+                        "type": "array",
+                        "items": { "type": "string" }
+                    },
+                    "condition": { "type": "string" },
+                    "threshold": { "type": ["number", "null"] },
+                    "suggestionTemplate": { "type": "string" },
+                    "triggerKeywords": {
+                        "type": "array",
+                        "items": { "type": "string" }
+                    }
+                }
+            }
+        },
+        "scoringWeights": {
+            "type": "object",
+            "required": ["completeness", "accuracy", "traceability"],
+            "properties": {
+                "completeness": { "type": "number", "minimum": 0, "maximum": 1 },
+                "accuracy": { "type": "number", "minimum": 0, "maximum": 1 },
+                "traceability": { "type": "number", "minimum": 0, "maximum": 1 }
+            }
+        },
+        "itemTypeMatching": {
+            "type": "object",
+            "minProperties": 1,
+            "additionalProperties": {
+                "type": "object",
+                "required": ["keywords", "codePrefix"],
+                "properties": {
+                    "keywords": {
+                        "type": "array",
+                        "items": { "type": "string" }
+                    },
+                    "codePrefix": { "type": "string" }
+                }
+            }
+        },
+        "severityMapping": {
+            "type": "object",
+            "properties": {
+                "missing": { "type": "string", "enum": ["critical", "major", "minor"] },
+                "semantic": { "type": "string", "enum": ["critical", "major", "minor"] },
+                "logical": { "type": "string", "enum": ["critical", "major", "minor"] }
+            }
+        },
+        "gbtMapping": {
+            "type": "object",
+            "minProperties": 1,
+            "additionalProperties": { "type": "string" }
+        },
+        "dataSourceCredentials": {
+            "type": "object",
+            "required": ["national", "provincial", "standard"],
+            "properties": {
+                "national": {
+                    "type": "object",
+                    "required": ["apiKey", "endpoint"],
+                    "properties": {
+                        "apiKey": { "type": "string" },
+                        "endpoint": { "type": "string" }
+                    }
+                },
+                "provincial": {
+                    "type": "object",
+                    "required": ["apiKey", "endpoint"],
+                    "properties": {
+                        "apiKey": { "type": "string" },
+                        "endpoint": { "type": "string" }
+                    }
+                },
+                "standard": {
+                    "type": "object",
+                    "required": ["docPath", "endpoint"],
+                    "properties": {
+                        "docPath": { "type": "string" },
+                        "endpoint": { "type": "string" }
+                    }
+                }
+            }
+        },
+        "dataSourcePriority": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "type": "string", "enum": ["national", "provincial"] }
+        },
+        "convenienceWeights": {
+            "type": "object",
+            "additionalProperties": { "type": "number" }
+        },
+        "materialConciseThreshold": { "type": "number" },
+        "missingFieldStandardClause": { "type": "string" },
+        "degradedSimilarityThreshold": { "type": "number", "minimum": 0, "maximum": 1 },
+        "inputLengthThreshold": { "type": "number" }
+    }
+}

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