nodejs-store 1.0.0 → 2.0.0

package/src/datasource.js

@@ -18,13 +18,48 @@
  * `{ default: db }`，保证既有单库调用零变更。
  */
 
+const { AsyncLocalStorage } = require('node:async_hooks');
 const { core: _core, get: _getSchema } = require('./schema');
+const { emit: _emitFeedback } = require('./feedback');
 const executors = require('./executors');
 
 const DEFAULT_SOURCE = 'default';
 
 let _connections = Object.create(null);
 
+/** 事务作用域的连接覆盖：source → 事务描述符（见 runInTransaction） */
+const _txStore = new AsyncLocalStorage();
+
+/**
+ * SQL 下推遇到无法安全翻译的组合（core 标记 unsupported）
+ *
+ * 显式报错而非静默执行「缺少该段」的 SQL（会返回错误结果）；
+ * 自动反馈：触发原因见 message，修复指引见 feedback()。
+ */
+class PushdownUnsupportedError extends Error {
+  constructor(source, kind, codes, warnings) {
+    super(`SQL 下推不支持（${kind}）: ${codes.join(', ')}；${warnings.join(' / ')}`);
+    this.name = 'PushdownUnsupportedError';
+    this.source = source;
+    this.kind = kind;
+    this.codes = codes;
+    this.warnings = warnings;
+  }
+
+  /** 转统一反馈事件（与 feedback.emit 的事件形状一致） */
+  feedback() {
+    return {
+      type: 'sql_pushdown_unsupported',
+      code: 'pushdownUnsupported',
+      layer: 'dialect',
+      message: this.message,
+      hint: '改写查询避开该组合，或改用 Mongo 源执行该段取数',
+      source: this.source,
+      kind: this.kind,
+    };
+  }
+}
+
 /** Mongo 形态判别：db 实例（collection 为函数）或 MongoClient（db 为函数且无 collection） */
 function _isMongoHandle(x) {
   return (
@@ -58,6 +93,64 @@ function getConnection(source) {
   return conn;
 }
 
+/** 指定数据源是否已在当前连接映射中配置（辅助动作「软跳过」判定用，如 init 建索引） */
+function hasConnection(source) {
+  return _connections[source] !== undefined;
+}
+
+/** 连接是否为 SQL 执行器描述符（`{ kind, exec }`；Mongo 为驱动实例） */
+function isSqlConnection(connection) {
+  return (
+    !!connection &&
+    typeof connection.kind === 'string' &&
+    typeof connection.exec === 'function'
+  );
+}
+
+/** 数据源名是否绑定 SQL 源 */
+function isSql(source) {
+  return isSqlConnection(getConnection(source));
+}
+
+/**
+ * 当前生效连接：事务作用域内返回覆盖描述符，否则返回全局映射的连接
+ * （`exec.js#_execOn` 经此取连接，使事务内所有命令落到专用连接）
+ */
+function connectionFor(source) {
+  const store = _txStore.getStore();
+  if (store && store.has(source)) return store.get(source);
+  return getConnection(source);
+}
+
+/**
+ * 事务作用域：在单个 SQL 源上以「同连接 + 同事务」执行 fn 内的全部命令
+ *
+ *   - fn 内经 `_exec` 路由到该 source 的命令全部落到事务连接（commit/rollback 一体）；
+ *   - Mongo 源 / 执行器未实现 withTransaction / 多源混合时按原样执行
+ *     （跨源无法原子 —— 信任边界见 README「事务边界」），绝不静默假装已事务化；
+ *   - 事务体抛错统一 rollback 后原样上抛。
+ */
+async function runInTransaction(source, fn) {
+  const conn = getConnection(source);
+  if (!isSqlConnection(conn) || typeof conn.withTransaction !== 'function') {
+    return fn();
+  }
+  const parent = _txStore.getStore();
+  const store = new Map(parent || []);
+  if (store.has(source)) {
+    // 同源嵌套事务：外层已持有该源的事务连接，内层并入外层（不做保存点）
+    return fn();
+  }
+  const txDescriptor = { kind: conn.kind, exec: null };
+  store.set(source, txDescriptor);
+  return _txStore.run(store, () =>
+    conn.withTransaction(async (execOnTx) => {
+      txDescriptor.exec = execOnTx;
+      return fn();
+    }),
+  );
+}
+
 /**
  * Mongo 源：按命令的 `namespace` 解析目标 db（两种形态，绝不猜）
  *
@@ -117,18 +210,25 @@ function route(cmd) {
  * 使上层（crud/*）对 Mongo / SQL 两条路径无感。
  */
 async function execSql(source, connection, cmd) {
-  if (typeof connection.exec !== 'function') {
-    throw new Error(
-      `SQL 数据源 ${source}(${connection.kind}) 的执行器未接入（见执行文档 Phase 4）`,
-    );
-  }
   const plan = _core.dialectTranslate(connection.kind, cmd);
   // Host 兜底：core 标记了无法安全下推的组合（如 $lookup 子 $limit 每父 top-N）时，
   // 绝不执行「缺少该段」的 SQL（会静默返回错误结果），改为显式报错，由调用方降级重查。
+  // 先于执行器检查 —— 命令本身不可安全下推时，报下推不支持而非「执行器未接入」
+  // （对齐 py_store/datasource.py#exec_sql 的检查次序）。
   if (Array.isArray(plan.unsupported) && plan.unsupported.length > 0) {
-    const codes = plan.unsupported.map((u) => (u && u.code) || String(u)).join(', ');
+    const err = new PushdownUnsupportedError(
+      source,
+      connection.kind,
+      plan.unsupported.map((u) => (u && u.code) || String(u)),
+      (plan.warnings || []).map((w) => String(w)),
+    );
+    // 自动反馈：拦截即告警（无 sink 时打 stderr），禁止静默失守
+    _emitFeedback(err.feedback());
+    throw err;
+  }
+  if (typeof connection.exec !== 'function') {
     throw new Error(
-      `SQL 下推不支持（${connection.kind}）: ${codes}；${(plan.warnings || []).join(' / ')}`,
+      `SQL 数据源 ${source}(${connection.kind}) 的执行器未接入（见执行文档 Phase 4）`,
     );
   }
   const out = await connection.exec(plan);
@@ -139,10 +239,16 @@ module.exports = {
   DEFAULT_SOURCE,
   setConnections,
   getConnection,
+  hasConnection,
+  isSqlConnection,
+  isSql,
+  connectionFor,
+  runInTransaction,
   mongoDb,
   sourceOfSchema,
   connectionOfSchema,
   dbOfSchema,
   route,
   execSql,
+  PushdownUnsupportedError,
 };

package/src/executors/_values.js

@@ -0,0 +1,55 @@
+'use strict';
+
+/**
+ * 驱动原始值归一（SQL 执行器共用）
+ *
+ * `pg` / `mysql2` 对**精确数值列**默认返回**字符串**：
+ * - `pg`：`int8`(20) / `numeric`(1700) → string；
+ * - `mysql2`：`DECIMAL` / `NEWDECIMAL`(246) → string。
+ *
+ * 而 Mongo 驱动对这些值返回 `number`。未归一 → 同一查询在 SQL 后端返回 `"8"`、Mongo 返回
+ * `8`（**静默类型失真**，`JSON.stringify` 对拍与用户代码都能看到差异）。
+ *
+ * 归一**只依据驱动给出的列类型元数据**（`pg` 的 `res.fields[].dataTypeID`、`mysql2` 的
+ * `fields[].columnType`），因此**不会**误伤真正的字符串列（如 `_id` / `status`）。
+ *
+ * 与 py-store 的 `py_store/executors/_values.py`（`Decimal` → 数值）同源同责。
+ */
+
+/** pg 的数值类型 OID（int2/int4/int8/float4/float8/numeric） */
+const PG_NUMERIC_OIDS = new Set([20, 21, 23, 700, 701, 1700]);
+
+/** mysql2 的数值 columnType（DECIMAL/TINY/SHORT/LONG/FLOAT/DOUBLE/LONGLONG/INT24/NEWDECIMAL） */
+const MYSQL_NUMERIC_TYPES = new Set([0, 1, 2, 3, 4, 5, 8, 9, 246]);
+
+/** 字符串数值 → number；非有限数值（如超长整数溢出为 Infinity）保持原样，不静默改值 */
+function toNumber(v) {
+  if (typeof v !== 'string' || v === '') return v;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : v;
+}
+
+/**
+ * 行集归一：按列类型元数据把**数值列**的字符串值转 `number`。
+ *
+ * @param {object[]} rows   驱动返回的行
+ * @param {object[]|undefined} fields 列元数据（`dataTypeID` for pg / `columnType` for mysql2）
+ * @param {'postgres'|'mysql'} kind 驱动种类
+ */
+function normalizeRows(rows, fields, kind) {
+  if (!rows || !rows.length || !fields || !fields.length) return rows;
+  const numeric = [];
+  for (let i = 0; i < fields.length; i += 1) {
+    const t = kind === 'postgres' ? fields[i].dataTypeID : fields[i].columnType;
+    const hit = kind === 'postgres' ? PG_NUMERIC_OIDS.has(t) : MYSQL_NUMERIC_TYPES.has(t);
+    if (hit) numeric.push(fields[i].name);
+  }
+  if (!numeric.length) return rows;
+  return rows.map((row) => {
+    const out = { ...row };
+    for (const k of numeric) out[k] = toNumber(out[k]);
+    return out;
+  });
+}
+
+module.exports = { MYSQL_NUMERIC_TYPES, PG_NUMERIC_OIDS, normalizeRows, toNumber };

package/src/executors/index.js

@@ -12,12 +12,17 @@
  * （`crud/query|write|mutation`）透明：上层只看到同一套返回值语义。
  */
 
+const mongo = require('./mongo');
 const mysql = require('./mysql');
 const postgres = require('./postgres');
 const sqlite = require('./sqlite');
 
 const _BACKENDS = { mysql, postgres, sqlite };
 
+// 注意：sqlite 执行器基于 better-sqlite3 同步驱动，调用期间会阻塞事件循环
+// （设计选择，非缺陷）——高并发主链路请用 mysql/postgres/mongo，或为 SQLite
+// 单独起独立进程；详见 ./sqlite.js 模块头「同步阻塞说明」。
+
 /** 创建 SQL 数据源连接描述符 `{ kind, exec }`（driver 为对应驱动实例/连接） */
 function createConnection(kind, driver, options) {
   const mod = _BACKENDS[kind];
@@ -57,4 +62,4 @@ function shapeResult(cmd, out) {
   }
 }
 
-module.exports = { createConnection, shapeResult, mysql, postgres, sqlite };
+module.exports = { createConnection, shapeResult, mongo, mysql, postgres, sqlite };

package/src/executors/mongo.js

@@ -0,0 +1,102 @@
+'use strict';
+
+/**
+ * Mongo 执行器（驱动：mongodb 原生）
+ *
+ * 只做「Command JSON → 原生驱动调用」（铁律 1/3）：全部纯逻辑（GQL 解析、权限、
+ * 命令规划、结果后处理）都在 Rust core。对齐 ``py-store/src/py_store/executors/mongo.py``。
+ *
+ * 唯一原生边界改写：`_explicitNull` —— 把「字段 = null」的**等值条件**编译为
+ * 「字段存在且为 null」（`{$eq: null, $exists: true}`）。理由：Mongo 原生把 `{f: null}`
+ * 同时命中「值为 null」与「字段缺失」两类文档，而本 store 的三态契约（F-07/H-09）
+ * 要求 `null` 只命中显式 null、`$exists:false` 才命中缺失 —— 这与 SQL 侧
+ * `col IS NULL`（显式 null）语义对齐。运算对象（`$ne:null`/`$exists`/`$gt`…）不改写。
+ */
+
+/** 递归改写 filter：`field: null`（标量等值）→ `field: {$eq: null, $exists: true}`。 */
+function _explicitNull(v) {
+  if (Array.isArray(v)) return v.map(_explicitNull);
+  if (v && typeof v === 'object') {
+    const out = {};
+    for (const [k, val] of Object.entries(v)) {
+      if (k.startsWith('$') && (val !== null && typeof val === 'object')) {
+        out[k] = _explicitNull(val);
+      } else if (k.startsWith('$')) {
+        out[k] = val;
+      } else if (val !== null && typeof val === 'object') {
+        out[k] = _explicitNull(val);
+      } else if (val === null) {
+        out[k] = { $eq: null, $exists: true };
+      } else {
+        out[k] = val;
+      }
+    }
+    return out;
+  }
+  return v;
+}
+
+function _normFilter(cmd) {
+  if (cmd.filter && typeof cmd.filter === 'object' && !Array.isArray(cmd.filter)) {
+    cmd.filter = _explicitNull(cmd.filter);
+  }
+}
+
+function _normPipeline(cmd) {
+  if (!Array.isArray(cmd.pipeline)) return;
+  for (const stage of cmd.pipeline) {
+    if (stage && typeof stage === 'object' && stage.$match && typeof stage.$match === 'object') {
+      stage.$match = _explicitNull(stage.$match);
+    }
+  }
+}
+
+/** Command JSON → MongoDB 原生驱动调用 */
+async function execMongo(db, cmd) {
+  const coll = db.collection(cmd.collection);
+  switch (cmd.kind) {
+    case 'find': {
+      _normFilter(cmd);
+      const opts = cmd.projection ? { projection: cmd.projection } : undefined;
+      return coll.find(cmd.filter, opts).toArray();
+    }
+    case 'aggregate':
+      _normPipeline(cmd);
+      return coll.aggregate(cmd.pipeline).toArray();
+    case 'countDocuments':
+      _normFilter(cmd);
+      return coll.countDocuments(cmd.filter);
+    case 'findOne': {
+      _normFilter(cmd);
+      const opts = cmd.projection ? { projection: cmd.projection } : undefined;
+      return coll.findOne(cmd.filter, opts);
+    }
+    case 'insertOne':
+      await coll.insertOne(cmd.doc);
+      return cmd.doc;
+    case 'insertMany':
+      if (cmd.upsertById) {
+        // 归档幂等（core planArchiveDocs）：按 _id 逐条覆盖 —— 「归档成功但删除失败」
+        // 的重试不再因 _id 冲突整批失败。SQL 侧由 dialect 的 ON CONFLICT/REPLACE 承接。
+        for (const doc of cmd.docs) {
+          await coll.replaceOne({ _id: doc._id }, doc, { upsert: true });
+        }
+        return { insertedCount: cmd.docs.length };
+      }
+      await coll.insertMany(cmd.docs);
+      return { insertedCount: cmd.docs.length };
+    case 'findOneAndUpdate':
+      _normFilter(cmd);
+      return coll.findOneAndUpdate(cmd.filter, cmd.update, cmd.options);
+    case 'updateMany':
+      _normFilter(cmd);
+      return coll.updateMany(cmd.filter, cmd.update);
+    case 'deleteMany':
+      _normFilter(cmd);
+      return coll.deleteMany(cmd.filter);
+    default:
+      throw new Error(`未支持的命令: ${cmd.kind}`);
+  }
+}
+
+module.exports = { execMongo };

package/src/executors/mysql.js

@@ -10,6 +10,7 @@
  */
 
 const { core: _core } = require('../schema');
+const { normalizeRows } = require('./_values');
 
 /** mysql2 返回 RowDataPacket 实例，转普通对象后再交 core（绑定层只认纯 JSON） */
 function _plain(row) {
@@ -23,22 +24,49 @@ function create(driver, _options = {}) {
   if (!driver || typeof driver.execute !== 'function') {
     throw new TypeError('mysql 执行器需要 mysql2/promise 的连接或连接池');
   }
+
+  /** 在指定连接上依序执行 plan.stmts（多语句 plan 由 withTransaction 包事务） */
+  async function runStmts(conn, plan) {
+    let docs = null;
+    let rows = null;
+    let affectedRows = 0;
+    for (const stmt of plan.stmts) {
+      const [raw, fields] = await conn.execute(stmt.text, stmt.params || []);
+      if (Array.isArray(raw)) {
+        rows = normalizeRows(raw.map(_plain), fields, 'mysql');
+        if (stmt.rowShape) docs = _core.restoreRows(stmt.rowShape, rows);
+      } else {
+        affectedRows = Number(raw.affectedRows || 0);
+      }
+    }
+    return { docs, rows, affectedRows };
+  }
+
   return {
     kind: 'mysql',
-    async exec(plan) {
-      let docs = null;
-      let rows = null;
-      let affectedRows = 0;
-      for (const stmt of plan.stmts) {
-        const [raw] = await driver.execute(stmt.text, stmt.params || []);
-        if (Array.isArray(raw)) {
-          rows = raw.map(_plain);
-          if (stmt.rowShape) docs = _core.restoreRows(stmt.rowShape, rows);
-        } else {
-          affectedRows = Number(raw.affectedRows || 0);
+    exec: (plan) => runStmts(driver, plan),
+    /**
+     * 事务执行：body(executeOnTx) 的所有 plan 落在同一连接同一事务内，
+     * 成功 commit / 失败 rollback。池自动取专用连接（结束归还）。
+     */
+    async withTransaction(body) {
+      const conn =
+        typeof driver.getConnection === 'function' ? await driver.getConnection() : driver;
+      try {
+        await conn.beginTransaction();
+        const out = await body((plan) => runStmts(conn, plan));
+        await conn.commit();
+        return out;
+      } catch (e) {
+        try {
+          await conn.rollback();
+        } catch (_) {
+          /* rollback 失败不掩盖原始错误 */
         }
+        throw e;
+      } finally {
+        if (conn !== driver && typeof conn.release === 'function') conn.release();
       }
-      return { docs, rows, affectedRows };
     },
   };
 }

package/src/executors/postgres.js

@@ -10,25 +10,65 @@
  */
 
 const { core: _core } = require('../schema');
+const { normalizeRows } = require('./_values');
 
 /** 创建执行器描述符（可直接作为 `init(connections)` 的一个 SQL 数据源连接） */
 function create(driver, _options = {}) {
   if (!driver || typeof driver.query !== 'function') {
     throw new TypeError('postgres 执行器需要 pg 的 Pool/Client 实例');
   }
+
+  /** 在指定连接上依序执行 plan.stmts */
+  async function runStmts(conn, plan) {
+    let docs = null;
+    let rows = null;
+    let affectedRows = 0;
+    for (const stmt of plan.stmts) {
+      const res = await conn.query(stmt.text, stmt.params || []);
+      rows = normalizeRows(res.rows || [], res.fields, 'postgres');
+      affectedRows = Number(res.rowCount || 0);
+      if (stmt.rowShape) docs = _core.restoreRows(stmt.rowShape, rows);
+    }
+    return { docs, rows, affectedRows };
+  }
+
   return {
     kind: 'postgres',
-    async exec(plan) {
-      let docs = null;
-      let rows = null;
-      let affectedRows = 0;
-      for (const stmt of plan.stmts) {
-        const res = await driver.query(stmt.text, stmt.params || []);
-        rows = res.rows || [];
-        affectedRows = Number(res.rowCount || 0);
-        if (stmt.rowShape) docs = _core.restoreRows(stmt.rowShape, rows);
+    exec: (plan) => runStmts(driver, plan),
+    /**
+     * 事务执行：显式 BEGIN/COMMIT/ROLLBACK 包住 body 的全部 plan。
+     * Pool 自动 checkout 专用 client（`release()` 归还）；Client 直连直接用。
+     */
+    async withTransaction(body) {
+      let conn = driver;
+      let release = null;
+      if (typeof driver.connect === 'function') {
+        try {
+          const c = await driver.connect();
+          // Pool.connect() → 专用 Client（带 release）；Client.connect() → 自身
+          if (c && typeof c.query === 'function') {
+            conn = c;
+            if (c !== driver && typeof c.release === 'function') release = () => c.release();
+          }
+        } catch (_) {
+          /* checkout 失败退回 driver 本体，事务语义由 BEGIN/COMMIT 保证 */
+        }
+      }
+      try {
+        await conn.query('BEGIN');
+        const out = await body((plan) => runStmts(conn, plan));
+        await conn.query('COMMIT');
+        return out;
+      } catch (e) {
+        try {
+          await conn.query('ROLLBACK');
+        } catch (_) {
+          /* rollback 失败不掩盖原始错误 */
+        }
+        throw e;
+      } finally {
+        if (release) release();
       }
-      return { docs, rows, affectedRows };
     },
   };
 }

package/src/executors/sqlite.js

@@ -7,6 +7,11 @@
  * 产出，本模块不拼任何 SQL；带 `rowShape` 的语句结果交 core `restoreRows` 还原为
  * 嵌套文档。返回值是中立包络 `{ docs, rows, affectedRows }`，由 `./index.js`
  * 依 command.kind 塑形为 Mongo 驱动等价返回值。
+ *
+ * ⚠️ 同步阻塞说明：better-sqlite3 是**同步驱动**，`prepare/all/run` 在 async 契约内
+ * 仍会**阻塞事件循环**（本模块保持同步调用是有意为之的设计选择：单连接语义最简、
+ * 无跨线程开销）。高并发主链路请改用 MySQL / PostgreSQL / MongoDB 数据源，
+ * 或为 SQLite 单独起独立进程隔离阻塞面——本执行器不适合多请求共享的事件循环热路径。
  */
 
 const { core: _core } = require('../schema');
@@ -25,23 +30,43 @@ function create(db, _options = {}) {
   if (!db || typeof db.prepare !== 'function') {
     throw new TypeError('sqlite 执行器需要 better-sqlite3 Database 实例');
   }
+
+  /** 依序执行 plan.stmts（better-sqlite3 同步单连接；同步调用会阻塞事件循环，见模块头说明） */
+  function runStmts(plan) {
+    let docs = null;
+    let rows = null;
+    let affectedRows = 0;
+    for (const stmt of plan.stmts) {
+      const params = _bind(stmt.params);
+      // 带 RETURNING 的写语句同样返回行 → 必须用 all() 取回；其余写语句用 run() 取影响行数
+      if (!stmt.isWrite || stmt.rowShape) {
+        rows = db.prepare(stmt.text).all(...params);
+        if (stmt.rowShape) docs = _core.restoreRows(stmt.rowShape, rows);
+      } else {
+        affectedRows = Number(db.prepare(stmt.text).run(...params).changes || 0);
+      }
+    }
+    return { docs, rows, affectedRows };
+  }
+
   return {
     kind: 'sqlite',
-    exec(plan) {
-      let docs = null;
-      let rows = null;
-      let affectedRows = 0;
-      for (const stmt of plan.stmts) {
-        const params = _bind(stmt.params);
-        // 带 RETURNING 的写语句同样返回行 → 必须用 all() 取回；其余写语句用 run() 取影响行数
-        if (!stmt.isWrite || stmt.rowShape) {
-          rows = db.prepare(stmt.text).all(...params);
-          if (stmt.rowShape) docs = _core.restoreRows(stmt.rowShape, rows);
-        } else {
-          affectedRows = Number(db.prepare(stmt.text).run(...params).changes || 0);
+    exec: runStmts,
+    /** 事务执行：显式 BEGIN/COMMIT/ROLLBACK（better-sqlite3 默认 autocommit，显式开事务安全） */
+    async withTransaction(body) {
+      db.exec('BEGIN');
+      try {
+        const out = await body(runStmts);
+        db.exec('COMMIT');
+        return out;
+      } catch (e) {
+        try {
+          db.exec('ROLLBACK');
+        } catch (_) {
+          /* rollback 失败不掩盖原始错误 */
         }
+        throw e;
       }
-      return { docs, rows, affectedRows };
     },
   };
 }

package/src/feedback.js

@@ -0,0 +1,39 @@
+'use strict';
+
+/**
+ * 反馈事件通道 —— 兜底/降级/拦截触发的统一出口
+ *
+ * 事件形状（对齐 rust-store 联邦 degraded 契约）::
+ *
+ *   {type, code, layer, message, hint, ...}
+ *     - type  : 事件类别（federation_degraded / sql_pushdown_unsupported ...）
+ *     - code  : 机器可读代码（crossSourceSort / pushdownUnsupported ...）
+ *     - layer : 命中的防护层（federation / dialect ...）
+ *     - message: 人可读描述
+ *     - hint  : 修复指引（供上游排查/加固）
+ *
+ * 默认无 sink 时打 stderr（向后兼容）；宿主可 `setSink(fn)` 接管，
+ * 接入自动反馈闭环（允许被拦截，禁止静默失守）。
+ */
+
+let _sink = null;
+
+/** 注册反馈事件回调 `fn(event)`；传 null/非函数恢复默认 stderr 行为 */
+function setSink(fn) {
+  _sink = typeof fn === 'function' ? fn : null;
+}
+
+/** 产出一条反馈事件：有 sink 回调之；否则打印 stderr（允许拦截，禁止静默） */
+function emit(event) {
+  const e = event || {};
+  if (_sink) {
+    _sink(e);
+    return;
+  }
+  console.error(
+    `[nodejs-store][${e.layer || '?'}/${e.code || '?'}] `
+    + `${e.message || ''}（hint: ${e.hint || '-'}）`,
+  );
+}
+
+module.exports = { setSink, emit };