node-resource-utils 0.0.0-stage → 1.1.7

package/resources/scripts/lib/schema-graph.mjs

@@ -0,0 +1,410 @@
+/**
+ * schema / ontology 关系分析（供 check-config 与 suggest-relations 共用）。
+ *
+ * 为什么要有它：
+ *   知识图谱的关系全靠人（或 AI）在 ontology.ts 里手写，
+ *   而人只会写"自己想得到"的关系 —— 典型漏配是
+ *   "考试"和"人员"都在视图里，但谁都忘了它们通过成绩单相连。
+ *   这里把 Prisma schema 里的外键和桥接表扒出来，和 ontology 对账，
+ *   让"漏关系"从"靠自觉"变成"能被机器发现"。
+ */
+
+/**
+ * 去掉 // 与 /* *\/ 注释。
+ * 不剥的话，文件顶部的 `interface GraphView { entities: string[] }`
+ * 和文档里的示例会被误当成真实配置（第一次跑就踩了：本体数 0）。
+ */
+function stripComments(src) {
+  return src
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .split('\n')
+    .map((line) => line.replace(/\/\/.*$/, ''))
+    .join('\n');
+}
+
+/** 这些字段是审计/元数据，不算业务载荷 */
+const META_FIELDS = new Set([
+  'id',
+  'createdAt',
+  'updatedAt',
+  'deletedAt',
+  'sort',
+  'status',
+  'remark',
+  'hidden',
+]);
+
+/**
+ * 解析 prisma/schema.prisma。
+ * 只关心三样：模型名、标量字段、带 `fields: [...]` 的 @relation（真实外键）。
+ */
+export function parseSchema(src) {
+  const models = [];
+  const lines = src.split('\n');
+  let cur = null;
+
+  for (const raw of lines) {
+    const line = raw.replace(/\/\/.*$/, '').trim();
+    if (!line) continue;
+
+    const m = line.match(/^model\s+(\w+)\s*\{/);
+    if (m) {
+      cur = { name: m[1], fields: [] };
+      continue;
+    }
+    if (!cur) continue;
+    if (line.startsWith('}')) {
+      models.push(cur);
+      cur = null;
+      continue;
+    }
+
+    // 字段行：name Type[?|[]] @attrs...
+    const f = line.match(/^(\w+)\s+([A-Za-z_][\w]*)(\[\])?(\?)?\s*(.*)$/);
+    if (!f) continue;
+    const [, name, type, isList, isOptional, attrs] = f;
+
+    const rel = attrs.match(/@relation\(([^)]*)\)/);
+    if (!rel) {
+      cur.fields.push({ name, type, isList: !!isList, optional: !!isOptional, isFk: false });
+      continue;
+    }
+    const fieldsMatch = rel[1].match(/fields:\s*\[([^\]]+)\]/);
+    if (!fieldsMatch) {
+      // 反向虚拟字段（如 users User[]），不是外键
+      cur.fields.push({ name, type, isList: !!isList, optional: !!isOptional, isFk: false });
+      continue;
+    }
+    cur.fields.push({
+      name,
+      type,
+      isList: !!isList,
+      optional: !!isOptional,
+      isFk: true,
+      fkField: fieldsMatch[1].trim().split(/\s*,\s*/)[0],
+      refModel: type,
+    });
+  }
+
+  const fks = [];
+  for (const model of models) {
+    for (const f of model.fields) {
+      if (f.isFk) fks.push({ model: model.name, field: f.fkField, refModel: f.refModel });
+    }
+  }
+
+  /**
+   * 桥接表：一个模型带 ≥2 个指向**不同模型**的外键。
+   * 不要求"纯中间表"——成绩单带 score 字段也算，
+   * 因为它照样能表达"考试 ↔ 人员"的关系（这恰恰是最常被漏的一种）。
+   */
+  const bridges = [];
+  for (const model of models) {
+    const own = fks.filter((f) => f.model === model.name && f.refModel !== model.name);
+    const seen = new Set();
+    const uniq = [];
+    for (const f of own) {
+      const key = f.refModel + '|' + f.field;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      uniq.push(f);
+    }
+    if (uniq.length < 2) continue;
+    // 注意：Prisma 的 @relation 写在**虚拟关系字段**上（user User @relation(fields:[userId])），
+    // userId 本身是普通标量 —— 计算载荷时要把这些外键列名排掉，
+    // 否则 UserRole 会被误判成"带载荷的业务表"。
+    const fkNames = new Set(own.map((f) => f.field));
+    const payload = model.fields
+      .filter((f) => !f.isFk && !META_FIELDS.has(f.name) && !f.isList && !fkNames.has(f.name))
+      .map((f) => f.name);
+    bridges.push({
+      model: model.name,
+      fks: uniq,
+      // 有载荷字段 = 业务表（成绩/明细），空 = 纯中间表（UserRole）
+      pure: payload.length === 0,
+      payload,
+    });
+  }
+
+  return { models, fks, bridges };
+}
+
+/** 从源码里截出 `xxx: [ ... ]` 的数组内容（按括号配对，够用且不怕多行） */
+function sliceArray(src, key) {
+  const i = src.indexOf(key);
+  if (i < 0) return null;
+  const open = src.indexOf('[', i);
+  if (open < 0) return null;
+  let depth = 0;
+  for (let j = open; j < src.length; j += 1) {
+    const ch = src[j];
+    if (ch === '[') depth += 1;
+    else if (ch === ']') {
+      depth -= 1;
+      if (depth === 0) return src.slice(open + 1, j);
+    }
+  }
+  return null;
+}
+
+/** 把数组内容按顶层 `{...}` 切成对象字符串 */
+function splitObjects(block) {
+  const out = [];
+  let depth = 0;
+  let start = -1;
+  for (let i = 0; i < block.length; i += 1) {
+    const ch = block[i];
+    if (ch === '{') {
+      depth += 1;
+      if (depth === 1) start = i;
+    } else if (ch === '}') {
+      depth -= 1;
+      if (depth === 0 && start >= 0) {
+        out.push(block.slice(start, i + 1));
+        start = -1;
+      }
+    }
+  }
+  return out;
+}
+
+function str(block, key) {
+  const m = block.match(new RegExp(`${key}\\s*:\\s*'([^']*)'`));
+  return m ? m[1] : null;
+}
+
+function bool(block, key) {
+  return new RegExp(`${key}\\s*:\\s*true`).test(block);
+}
+
+/**
+ * 解析 ontology.ts 的 entities / relations / views。
+ * 只提取关系分析需要的字段，不试图做完整的 TS 解析。
+ */
+export function parseOntology(rawSrc) {
+  const src = stripComments(rawSrc);
+  const start = src.indexOf('export const ONTOLOGY');
+  const body = start >= 0 ? src.slice(start) : src;
+
+  const entities = splitObjects(sliceArray(body, 'entities:') ?? '').map((o) => ({
+    id: str(o, 'id'),
+    label: str(o, 'label'),
+    model: str(o, 'model'),
+  }));
+
+  const relations = splitObjects(sliceArray(body, 'relations:') ?? '').map((o) => {
+    const viaBlock = o.match(/via\s*:\s*\{([\s\S]*?)\}/);
+    const via = viaBlock ? viaBlock[1] : '';
+    return {
+      id: str(o, 'id'),
+      label: str(o, 'label'),
+      from: str(o, 'from'),
+      to: str(o, 'to'),
+      field: str(via, 'field'),
+      reverse: bool(via, 'reverse'),
+      model: str(via, 'model'),
+      fromField: str(via, 'fromField'),
+      toField: str(via, 'toField'),
+    };
+  });
+
+  const views = splitObjects(sliceArray(body, 'views:') ?? '').map((o) => {
+    const list = (key) => {
+      const m = o.match(new RegExp(`${key}\\s*:\\s*\\[([^\\]]*)\\]`));
+      return m ? m[1].split(',').map((x) => x.trim().replace(/^'|'$/g, '')).filter(Boolean) : [];
+    };
+    return {
+      id: str(o, 'id'),
+      label: str(o, 'label'),
+      entities: list('entities'),
+      relations: list('relations'),
+      root: str(o, 'root'),
+    };
+  });
+
+  return { entities, relations, views };
+}
+
+/** 模型名 ↔ 本体 id */
+function makeModelMap(entities) {
+  const byModel = new Map();
+  const byEntity = new Map();
+  for (const e of entities) {
+    if (!e.model) continue;
+    byModel.set(e.model, e);
+    byEntity.set(e.id, e);
+  }
+  return { byModel, byEntity };
+}
+
+/**
+ * schema 里的"连接"：直接外键，或经桥接表。
+ * 只保留两端都是已声明本体的连接 —— 没建本体就没法画，报了也没用。
+ */
+export function schemaLinks(schema, entities, relations) {
+  const { byModel } = makeModelMap(entities);
+  const links = [];
+  const declared = (aModel, bModel, via) =>
+    relations.some((r) => {
+      const ra = byModel.get(aModel);
+      const rb = byModel.get(bModel);
+      if (!ra || !rb) return false;
+      const pairOk =
+        (r.from === ra.id && r.to === rb.id) || (r.from === rb.id && r.to === ra.id);
+      if (!pairOk) return false;
+      if (via.kind === 'fk') {
+        return r.field === via.field || (r.model === via.model && via.model);
+      }
+      return r.model === via.model;
+    });
+
+  for (const fk of schema.fks) {
+    if (fk.model === fk.refModel) continue; // 自关联（部门树/菜单树）不强制
+    const a = byModel.get(fk.model);
+    const b = byModel.get(fk.refModel);
+    if (!a || !b) continue;
+    const via = { kind: 'fk', field: fk.field };
+    links.push({
+      kind: 'fk',
+      aModel: fk.model,
+      bModel: fk.refModel,
+      aEntity: a.id,
+      bEntity: b.id,
+      field: fk.field,
+      declared: declared(fk.model, fk.refModel, via),
+    });
+  }
+
+  for (const br of schema.bridges) {
+    for (let i = 0; i < br.fks.length; i += 1) {
+      for (let j = 0; j < br.fks.length; j += 1) {
+        if (i === j) continue;
+        const left = br.fks[i];
+        const right = br.fks[j];
+        if (left.refModel === right.refModel) continue;
+        const a = byModel.get(left.refModel);
+        const b = byModel.get(right.refModel);
+        if (!a || !b) continue;
+        const via = { kind: 'bridge', model: br.model };
+        links.push({
+          kind: 'bridge',
+          aModel: left.refModel,
+          bModel: right.refModel,
+          aEntity: a.id,
+          bEntity: b.id,
+          bridgeModel: br.model,
+          fromField: left.field,
+          toField: right.field,
+          pure: br.pure,
+          payload: br.payload,
+          declared: declared(left.refModel, right.refModel, via),
+        });
+      }
+    }
+  }
+
+  // 去重（A→B 与 B→A 视作同一条连接；桥接表只留一条）
+  const seen = new Set();
+  const out = [];
+  for (const l of links) {
+    const pair = [l.aEntity, l.bEntity].sort().join('|');
+    const key = `${l.kind}|${pair}|${l.kind === 'fk' ? '' : l.bridgeModel}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(l);
+  }
+  return out;
+}
+
+/** 视图内的关系图：entity → 相邻 entity 集合（只算视图内声明且列出的关系） */
+export function viewAdjacency(view, relations, entities) {
+  const { byEntity } = makeModelMap(entities);
+  const adj = new Map();
+  for (const id of view.entities) adj.set(id, new Set());
+  for (const rid of view.relations) {
+    const r = relations.find((x) => x.id === rid);
+    if (!r) continue;
+    if (!byEntity.has(r.from) || !byEntity.has(r.to)) continue;
+    if (!adj.has(r.from)) adj.set(r.from, new Set());
+    if (!adj.has(r.to)) adj.set(r.to, new Set());
+    adj.get(r.from).add(r.to);
+    adj.get(r.to).add(r.from);
+  }
+  return adj;
+}
+
+/** 两跳内可达（含直达） */
+export function reachableWithin(adj, from, to, hops = 2) {
+  if (from === to) return 0;
+  let frontier = [from];
+  const seen = new Set([from]);
+  for (let d = 1; d <= hops; d += 1) {
+    const next = [];
+    for (const cur of frontier) {
+      for (const nb of adj.get(cur) ?? []) {
+        if (nb === to) return d;
+        if (!seen.has(nb)) {
+          seen.add(nb);
+          next.push(nb);
+        }
+      }
+    }
+    frontier = next;
+  }
+  return -1;
+}
+
+/**
+ * 总分析：
+ *   missing        —— schema 有连接、ontology 里没声明（全局）
+ *   viewIssues     —— 视图里两端都在、schema 有连接，但图上既没有直连也没有两跳（**硬错误**）
+ *   indirectNote   —— 能两跳到达，但没有直连（提示，不报错）
+ */
+export function analyze(schemaSrc, ontologySrc) {
+  const schema = parseSchema(schemaSrc);
+  const { entities, relations, views } = parseOntology(ontologySrc);
+  const links = schemaLinks(schema, entities, relations);
+  const { byEntity } = makeModelMap(entities);
+
+  const missing = links.filter((l) => !l.declared);
+
+  const viewIssues = [];
+  const indirectNote = [];
+  for (const view of views) {
+    const adj = viewAdjacency(view, relations, entities);
+    const inView = new Set(view.entities);
+    for (const link of links) {
+      if (!inView.has(link.aEntity) || !inView.has(link.bEntity)) continue;
+      const direct = (adj.get(link.aEntity) ?? new Set()).has(link.bEntity);
+      if (direct) continue;
+      const d = reachableWithin(adj, link.aEntity, link.bEntity, 2);
+      const a = byEntity.get(link.aEntity);
+      const b = byEntity.get(link.bEntity);
+      const desc = {
+        view: view.id,
+        a: a?.label ?? link.aEntity,
+        b: b?.label ?? link.bEntity,
+        aId: link.aEntity,
+        bId: link.bEntity,
+        link,
+        hops: d,
+      };
+      if (d > 0) indirectNote.push(desc);
+      else viewIssues.push(desc);
+    }
+  }
+
+  return { schema, entities, relations, views, links, missing, viewIssues, indirectNote };
+}
+
+/** 生成可直接粘贴的 relations 片段 */
+export function suggestSnippet(link, entities) {
+  const { byEntity } = makeModelMap(entities);
+  const a = byEntity.get(link.aEntity);
+  const b = byEntity.get(link.bEntity);
+  if (!a || !b) return '';
+  if (link.kind === 'fk') {
+    return `{ id: '${a.id}_${b.id}', label: '关联${b.label}', from: '${a.id}', to: '${b.id}', via: { field: '${link.field}' } },`;
+  }
+  return `{ id: '${a.id}_${b.id}', label: '关联${b.label}', from: '${a.id}', to: '${b.id}', via: { model: '${link.bridgeModel}', fromField: '${link.fromField}', toField: '${link.toField}' } },`;
+}

package/resources/scripts/patch-next-trace.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+/**
+ * 给 Next 打 trace 并发建流补丁（幂等，可反复跑）
+ *
+ *   node scripts\patch-next-trace.mjs              # 打补丁
+ *   node scripts\patch-next-trace.mjs --check      # 只检查，不写（退出码 1 = 补丁缺失）
+ *   node scripts\patch-next-trace.mjs --file <路径>  # 指定文件（自测用）
+ *
+ * 为什么需要它：`npm ci` / 重装 node_modules 会覆盖 node_modules/next/dist/trace/report/to-json.js，
+ * 补丁就丢了。这个脚本把补丁变成可重复执行的动作 —— 装完依赖跑一次即可。
+ *
+ * 补的是什么（详见 README 第八节）：
+ *   Next 的 trace 上报在 `if (!writeStream)` 与 `writeStream = new RotatingWriteStream(...)`
+ *   之间夹了一个 `await mkdir(...)`。同一个 tick 内两次 flush（trace 批次满 101 条就会触发）
+ *   会双双通过判空、各建一个写流；两个流同时"创建"同一个还不存在的 .next/trace，
+ *   Windows 上第二次 open 返回 EPERM，而没有 error 监听器 → uncaughtException → build 崩。
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const defaultFile = path.resolve(here, "../node_modules/next/dist/trace/report/to-json.js");
+
+const args = process.argv.slice(2);
+const checkOnly = args.includes("--check");
+const fileArgIndex = args.indexOf("--file");
+const target = fileArgIndex >= 0 ? path.resolve(args[fileArgIndex + 1]) : defaultFile;
+
+const MARK = "[patch-next-trace]";
+
+/** 上游原样（15.5.26）——必须逐字匹配，改了说明 Next 版本变了，要重新看代码 */
+const UPSTREAM_INIT = `            if (!writeStream) {
+                await _fs.default.promises.mkdir(distDir, {
+                    recursive: true
+                });
+                const file = _path.default.join(distDir, 'trace');
+                writeStream = new RotatingWriteStream(file, // Development is limited to 50MB, production is unlimited
+                phase === _constants.PHASE_DEVELOPMENT_SERVER ? 52428800 : Infinity);
+            }`;
+
+const PATCHED_INIT = `            if (!writeStream) {
+                // ${MARK} 判空与赋值之间不能有 await：同一 tick 两次 flush 会各建一个写流，
+                // 两个流并发创建同一个不存在的 .next/trace → Windows 第二次 open 得到 EPERM。
+                _fs.default.mkdirSync(distDir, {
+                    recursive: true
+                });
+                const file = _path.default.join(distDir, 'trace');
+                writeStream = new RotatingWriteStream(file, // Development is limited to 50MB, production is unlimited
+                phase === _constants.PHASE_DEVELOPMENT_SERVER ? 52428800 : Infinity);
+            }`;
+
+const UPSTREAM_STREAM = `        this.writeStream = _fs.default.createWriteStream(this.file, writeStreamOptions);`;
+const PATCHED_STREAM = `        this.writeStream = _fs.default.createWriteStream(this.file, writeStreamOptions);
+        // ${MARK} trace 是可丢的诊断数据，绝不让它的 error 变成 uncaughtException 打死构建
+        this.writeStream.on('error', ()=>{});`;
+
+if (!fs.existsSync(target)) {
+  console.error(`✗ 找不到文件：${target}\n  先在 biz-full 里装好依赖（node_modules/next 必须存在）`);
+  process.exit(1);
+}
+
+const src = fs.readFileSync(target, "utf8");
+
+if (src.includes(MARK)) {
+  console.log(`✓ 补丁已在位：${path.relative(process.cwd(), target)}`);
+  process.exit(0);
+}
+
+if (checkOnly) {
+  console.error(`✗ 补丁缺失：${path.relative(process.cwd(), target)}`);
+  process.exit(1);
+}
+
+if (!src.includes(UPSTREAM_INIT)) {
+  console.error("✗ 没匹配到上游的建流代码 —— Next 版本可能变了，别硬套。\n  请打开该文件确认 writeStream 的初始化写法，再更新本脚本的 UPSTREAM_INIT。");
+  process.exit(1);
+}
+if (!src.includes(UPSTREAM_STREAM)) {
+  console.error("✗ 没匹配到 createWriteStream 那一行 —— Next 版本可能变了。");
+  process.exit(1);
+}
+
+const out = src.replace(UPSTREAM_INIT, PATCHED_INIT).replace(UPSTREAM_STREAM, PATCHED_STREAM);
+fs.writeFileSync(target, out);
+console.log(`✓ 打补丁完成：${path.relative(process.cwd(), target)}`);

package/resources/scripts/suggest-relations.mjs

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+/**
+ * 关系挖掘器 —— 把 schema 里"物理存在但 ontology 没写"的关系找出来。
+ *
+ * 用法：
+ *   npm run relations          列出候选关系、漏配项、桥接表，并给出可粘贴的 TS 片段
+ *   npm run relations -- --strict   只要有"视图内该连未连"就退出码 1（CI 用）
+ *
+ * 为什么需要它：
+ *   图谱关系是手写的，人只会写"想得到的"。最典型的漏配是
+ *   考试与人员：两者都在视图里，靠成绩单（examId + personId）相连，
+ *   但写 ontology 时只想着"考试属于部门"，就把它漏了。
+ *   这个脚本把每条外键、每张桥接表都摊开对账，漏没漏一目了然。
+ */
+import { readFileSync } from 'node:fs';
+import { analyze, suggestSnippet } from './lib/schema-graph.mjs';
+
+const SCHEMA = 'prisma/schema.prisma';
+const ONTOLOGY = 'src/lib/ontology.ts';
+const strict = process.argv.includes('--strict');
+
+function read(path) {
+  try {
+    return readFileSync(path, 'utf8');
+  } catch {
+    console.error(`\n[relations] 找不到 ${path}，请在 biz-full 目录下运行\n`);
+    process.exit(1);
+  }
+}
+
+const result = analyze(read(SCHEMA), read(ONTOLOGY));
+const { entities, relations, views, links, missing, viewIssues, indirectNote, schema } = result;
+
+const declared = links.filter((l) => l.declared);
+const byEntity = new Map(entities.map((e) => [e.id, e]));
+
+console.log('\n══════════ 关系挖掘报告 ══════════\n');
+console.log(`本体 ${entities.length} 个 · 已声明关系 ${relations.length} 条 · 视图 ${views.length} 个`);
+console.log(`schema 外键 ${schema.fks.length} 条 · 桥接表 ${schema.bridges.length} 张\n`);
+
+if (schema.bridges.length) {
+  console.log('── 桥接表（最容易漏的关系来源）──');
+  for (const br of schema.bridges) {
+    const refs = br.fks.map((f) => `${f.refModel}.${f.field}`).join(' + ');
+    const extra = br.pure ? '纯中间表' : `带载荷：${br.payload.join(', ')}`;
+    console.log(`  ${br.model}  →  ${refs}   （${extra}）`);
+    if (br.fks.length >= 2) {
+      const a = byEntity.get(br.fks[0].refModel) ?? { label: br.fks[0].refModel };
+      const b = byEntity.get(br.fks[1].refModel) ?? { label: br.fks[1].refModel };
+      console.log(`     可表达：${a.label} ↔ ${b.label}（用 via.model: '${br.model}'）`);
+    }
+  }
+  console.log('');
+}
+
+if (declared.length) {
+  console.log('── 已声明 ──');
+  for (const l of declared) {
+    const a = byEntity.get(l.aEntity)?.label ?? l.aEntity;
+    const b = byEntity.get(l.bEntity)?.label ?? l.bEntity;
+    console.log(`  ✓ ${a} ↔ ${b}${l.kind === 'bridge' ? `（经 ${l.bridgeModel}）` : `（${l.field}）`}`);
+  }
+  console.log('');
+}
+
+if (missing.length) {
+  console.log('── 未声明（可直接粘贴到 ontology.ts 的 relations）──');
+  for (const l of missing) {
+    const a = byEntity.get(l.aEntity)?.label ?? l.aEntity;
+    const b = byEntity.get(l.bEntity)?.label ?? l.bEntity;
+    const how = l.kind === 'bridge'
+      ? `经桥接表 ${l.bridgeModel}（${l.fromField} / ${l.toField}${l.pure ? '，纯中间表' : `，含 ${l.payload.join('/')}`}）`
+      : `外键 ${l.aModel}.${l.field}`;
+    console.log(`  ✗ ${a} ↔ ${b}    ${how}`);
+    const snippet = suggestSnippet(l, entities);
+    if (snippet) console.log(`      ${snippet}`);
+  }
+  console.log('');
+}
+
+if (indirectNote.length) {
+  console.log('── 只能间接到达（两跳内可连通，不报错）──');
+  for (const n of indirectNote) {
+    console.log(`  · 视图「${n.view}」：${n.a} ↔ ${n.b} 隔着 1 个节点，${n.hops} 跳可达`);
+    console.log(`      如果评委要想看它们的关系，建议补一条 via.model 直连`);
+  }
+  console.log('');
+}
+
+if (viewIssues.length) {
+  console.log('── ✗ 视图内该连未连（check:config 会报错）──');
+  for (const n of viewIssues) {
+    console.log(`  ✗ 视图「${n.view}」：${n.a} 和 ${n.b} 都在图里，schema 也有连接，但图上没有任何路径`);
+    console.log(`      ${suggestSnippet(n.link, entities)}`);
+  }
+  console.log('');
+}
+
+if (!links.length) {
+  console.log('（schema 里没有落到"已声明本体"上的连接 —— 先建本体，再谈关系）\n');
+}
+
+const ok = viewIssues.length === 0;
+console.log(ok ? '✓ 视图内的关系没有明显漏配\n' : `✗ 有 ${viewIssues.length} 处关系漏配\n`);
+process.exit(strict && !ok ? 1 : 0);