nodejs-store 1.0.0 → 2.0.0

package/src/index.js

@@ -24,6 +24,7 @@
 const crud = require('./crud');
 const datasource = require('./datasource');
 const executors = require('./executors');
+const feedback = require('./feedback');
 const introspect = require('./introspect');
 const permission = require('./permission');
 const schema = require('./schema');
@@ -51,6 +52,7 @@ class Store {
   /**
    * GQL 查询。`routeOverride`（可选）：`{ source?, namespace? }` 多租户路由，
    * 覆盖命令定位（权限/计算列仍按结构 schema 判定）。下同。
+   * 注意：`routeOverride` 为**受信服务端参数**，禁止透传用户输入（否则可被用于跨源路由，CWE-639）。
    */
   async query(gql, params, routeOverride) {
     return crud.query(gql, params, routeOverride);
@@ -106,11 +108,6 @@ class Store {
     return crud.upsert(schemaName, condition, data, options, routeOverride);
   }
 
-  // ── 原生聚合 ──
-  async aggregate(schemaName, pl, routeOverride) {
-    return crud.aggregate(schemaName, pl, routeOverride);
-  }
-
   // ── 结构同步（SQL 数据源：introspect → schemaFromRows → mergeSchema → register） ──
   async syncSchema(opts) {
     return syncSchema(opts);
@@ -122,6 +119,30 @@ class Store {
     return schema.core.buildPipeline(gql, params ?? {}, permission.getContext() ?? null);
   }
 
+  // ── 宿主接入守卫（Registry 级，对齐 py-store c44001e） ──
+  /**
+   * 开关「上下文强制」（默认关闭 = fail-open）。开启后：所有查询/写入在 ctx 缺失时
+   * 抛 `ERR_NO_CONTEXT`（fail-secure）；内部调用须显式传 `{ internal: true }` 上下文。
+   */
+  setRequireContext(needCtx = true) {
+    return schema.setRequireContext(needCtx);
+  }
+
+  /** 「上下文强制」开关当前值（对齐 py-store store.require_context） */
+  requireContext() {
+    return schema.requireContext();
+  }
+
+  /** 设置数据源连接映射（多后端路由；对齐 py-store store.set_connections） */
+  setConnections(connections) {
+    return datasource.setConnections(connections);
+  }
+
+  /** 注册反馈事件回调（兜底/降级/拦截的统一出口）；传 null 恢复默认 stderr */
+  setFeedbackSink(fn) {
+    return feedback.setSink(fn);
+  }
+
   // ── 权限控制（AsyncLocalStorage 上下文） ──
   setContext(ctx) {
     return permission.setContext(ctx);
@@ -156,13 +177,10 @@ async function _createIndexesIfNeeded() {
   for (const name of names) {
     const s = schema.get(name);
     // 索引创建是初始化的辅助动作（非命令路由）：schema 绑定的 source 暂未在
-    // 当前连接映射中时跳过，不阻塞 init（命令路由的 fail fast 不在此处）
-    let db;
-    try {
-      db = datasource.dbOfSchema(name); // Mongo 按 (datasource, namespace) 解析；SQL 源返回 null
-    } catch (e) {
-      continue;
-    }
+    // 当前连接映射中时软跳过，不阻塞 init；其余配置错误（namespace 形态不匹配等）
+    // 按 fail-fast 由 dbOfSchema 上抛，不静默吞掉
+    if (!datasource.hasConnection(datasource.sourceOfSchema(name))) continue;
+    const db = datasource.dbOfSchema(name); // Mongo 按 (datasource, namespace) 解析；SQL 源返回 null
     if (!db) continue; // SQL 后端不建索引
 
     const coll = db.collection(s.collection);
@@ -171,7 +189,10 @@ async function _createIndexesIfNeeded() {
     try {
       existingIndexes = await coll.listIndexes().toArray();
     } catch (e) {
-      existingIndexes = [];
+      // 只吞服务器错误（集合尚未存在 → NamespaceNotFound 属 MongoServerError）；
+      // 连接/程序错误按 fail-fast 上抛，不再静默吞掉（对齐 py 侧 PyMongoError 收窄）
+      if (e && e.name === 'MongoServerError') existingIndexes = [];
+      else throw e;
     }
 
     for (const idx of s.indexes || []) {
@@ -193,7 +214,15 @@ async function _createIndexesIfNeeded() {
 
         await coll.createIndex(Object.entries(keys), finalOptions);
       } catch (e) {
-        console.error(`[MongoStore] 创建索引失败 ${s.collection}: ${e && e.message ? e.message : e}`);
+        // 索引创建失败不阻塞 init（辅助动作），但必须走统一反馈通道：
+        // 无 sink 时由 feedback 默认落 stderr（不双份打印），宿主可 setFeedbackSink 接管
+        feedback.emit({
+          type: 'index_create_failed',
+          code: 'indexCreateFailed',
+          layer: 'host',
+          message: `创建索引失败 ${s.collection}: ${e && e.message ? e.message : e}`,
+          hint: '检查该集合的索引定义与连接权限；索引缺失不影响读写，相关查询将退化为全表扫描',
+        });
       }
     }
   }
@@ -224,13 +253,14 @@ module.exports = {
   init,
   store,
   Store,
-  aggregate: crud.aggregate,
   PermissionError: permission.PermissionError,
+  PushdownUnsupportedError: datasource.PushdownUnsupportedError,
   datasource,
   schema,
   permission,
   crud,
   executors,
+  feedback,
   introspect,
   syncSchema,
 };

package/src/introspect/_shared.js

@@ -0,0 +1,28 @@
+'use strict';
+
+/**
+ * introspect 共享工具（mysql / postgres 复用，避免复制粘贴式重复）
+ *
+ * 两后端 `_INDEXES` 查询产出的行形态不同（MySQL `nonUnique` 取反、PG `unique` 直取），
+ * 由调用方以 `uniqueOf(row)` 参数化该差异；归并逻辑本身逐行一致，抽为单份实现。
+ */
+
+/**
+ * 把 `{table,name,column,...}` 索引行按 `(table, name)` 归并出
+ * `{table, name, columns, unique}` 数组（`unique` 取 `uniqueOf(row)` 的 0/1）
+ */
+function groupIndexes(rows, uniqueOf) {
+  const byKey = new Map();
+  for (const r of rows) {
+    const key = `${r.table}::${r.name}`;
+    let entry = byKey.get(key);
+    if (!entry) {
+      entry = { table: r.table, name: r.name, columns: [], unique: uniqueOf(r) };
+      byKey.set(key, entry);
+    }
+    entry.columns.push(r.column);
+  }
+  return [...byKey.values()];
+}
+
+module.exports = { groupIndexes };

package/src/introspect/mysql.js

@@ -7,6 +7,8 @@
  * 交 core `schemaFromRows` 做纯映射。建议使用只读账号；库名取当前连接的 `DATABASE()`。
  */
 
+const { groupIndexes } = require('./_shared');
+
 const _TABLES = `
   SELECT table_name AS name
   FROM information_schema.tables
@@ -42,20 +44,8 @@ const _INDEXES = `
   WHERE table_schema = DATABASE()
   ORDER BY table_name, index_name, seq_in_index`;
 
-/** 把 `{table,name,nonUnique,column}` 行按索引名归并出 columns 数组 */
-function _groupIndexes(rows) {
-  const byKey = new Map();
-  for (const r of rows) {
-    const key = `${r.table}::${r.name}`;
-    let entry = byKey.get(key);
-    if (!entry) {
-      entry = { table: r.table, name: r.name, columns: [], unique: Number(r.nonUnique) ? 0 : 1 };
-      byKey.set(key, entry);
-    }
-    entry.columns.push(r.column);
-  }
-  return [...byKey.values()];
-}
+// MySQL 行携带 nonUnique（1=非唯一）→ 取反为 unique 标志；归并逻辑共享见 _shared.js
+const _uniqueOf = (r) => (Number(r.nonUnique) ? 0 : 1);
 
 async function introspect(driver, { database = null } = {}) {
   if (!driver || typeof driver.execute !== 'function') {
@@ -91,7 +81,7 @@ async function introspect(driver, { database = null } = {}) {
       pk: c.columnKey === 'PRI' ? 1 : 0,
     })),
     fks,
-    indexes: _groupIndexes(indexRows),
+    indexes: groupIndexes(indexRows, _uniqueOf),
   };
 }
 

package/src/introspect/postgres.js

@@ -7,6 +7,8 @@
  * 产出规范化行 JSON，交 core `schemaFromRows` 做纯映射。建议使用只读账号。
  */
 
+const { groupIndexes } = require('./_shared');
+
 const _TABLES = `
   SELECT table_name AS name
   FROM information_schema.tables
@@ -63,20 +65,8 @@ const _INDEXES = `
   WHERE ns.nspname = $1 AND NOT ix.indisprimary
   ORDER BY t.relname, i.relname`;
 
-/** 把 `{table,name,unique,column}` 行按索引名归并出 columns 数组 */
-function _groupIndexes(rows) {
-  const byKey = new Map();
-  for (const r of rows) {
-    const key = `${r.table}::${r.name}`;
-    let entry = byKey.get(key);
-    if (!entry) {
-      entry = { table: r.table, name: r.name, columns: [], unique: Number(r.unique) };
-      byKey.set(key, entry);
-    }
-    entry.columns.push(r.column);
-  }
-  return [...byKey.values()];
-}
+// PG 行已带 unique（0/1）→ 直取；归并逻辑共享见 _shared.js
+const _uniqueOf = (r) => Number(r.unique);
 
 async function introspect(driver, opts = {}) {
   if (!driver || typeof driver.query !== 'function') {
@@ -106,7 +96,7 @@ async function introspect(driver, opts = {}) {
       pk: Number(c.pk) || 0,
     })),
     fks: fks.rows,
-    indexes: _groupIndexes(indexRows.rows),
+    indexes: groupIndexes(indexRows.rows, _uniqueOf),
   };
 }
 

package/src/permission.js

@@ -11,6 +11,8 @@
 
 const { AsyncLocalStorage } = require('node:async_hooks');
 
+const { core } = require('./schema');
+
 const _als = new AsyncLocalStorage();
 
 /** 设置当前请求的上下文，每次请求开始时调用一次 */
@@ -41,6 +43,47 @@ async function runAsInternal(fn) {
   return _als.run(next, () => fn());
 }
 
+// ─── core 权限方法包装（对齐 py_store.permission 的同名薄包装） ──────
+
+/** 接受 schema 对象或 schema 名称 */
+function _model(schema) {
+  return typeof schema === 'string' ? schema : schema.name;
+}
+
+function canReadSchema(schema, ctx) {
+  return core.canRead(_model(schema), ctx ?? null);
+}
+
+function canWriteSchema(schema, ctx) {
+  return core.canWrite(_model(schema), ctx ?? null);
+}
+
+function shouldInjectOwnerCondition(schema, ctx) {
+  return core.shouldInjectOwner(_model(schema), ctx ?? null);
+}
+
+function mergeOwnerCondition(schema, ctx, condition) {
+  const out = core.mergeOwnerCondition(_model(schema), ctx ?? null, condition ?? null);
+  // core 在「不注入」时返回 null（无法区分原条件为 null）→ 原样返回入参条件
+  return out === null || out === undefined ? condition : out;
+}
+
+function getReadableFields(schema, ctx) {
+  return core.readableFields(_model(schema), ctx ?? null);
+}
+
+function getReadableRelations(schema, ctx) {
+  return core.readableRelations(_model(schema), ctx ?? null);
+}
+
+function getWritableFields(schema, ctx) {
+  return core.writableFields(_model(schema), ctx ?? null);
+}
+
+function filterWritableData(schema, ctx, data) {
+  return core.filterWritableData(_model(schema), ctx ?? null, data);
+}
+
 // ─── 自定义错误 ──────────────────────────────────────────────
 
 class PermissionError extends Error {
@@ -56,5 +99,13 @@ module.exports = {
   getContext,
   scopedRoles,
   runAsInternal,
+  canReadSchema,
+  canWriteSchema,
+  shouldInjectOwnerCondition,
+  mergeOwnerCondition,
+  getReadableFields,
+  getReadableRelations,
+  getWritableFields,
+  filterWritableData,
   PermissionError,
 };

package/src/schema.js

@@ -52,6 +52,8 @@ function register(defn) {
     namespace: defn.namespace || null,
     idPrefix: defn.idPrefix || '',
     timestamps: defn.timestamps !== false,
+    // 时间戳单位（'ms'/'s'/null=不维护）；值合法性由 core.register 校验
+    timestampUnit: defn.timestamps === 's' ? 's' : (defn.timestamps === false ? null : 'ms'),
     fields: defn.fields || {},
     relations: defn.relations || {},
     computes,
@@ -98,9 +100,24 @@ function list() {
   return core.list();
 }
 
+/**
+ * 开关「上下文强制」（默认关闭 = fail-open，与 JS 原版语义一致）。
+ *
+ * 开启后：所有 plan 入口遇 ctx 缺失抛 `ERR_NO_CONTEXT` 错误（fail-secure）；
+ * 内部调用（索引创建、归档回填、后台任务等）须显式传 `{ internal: true }` 上下文。
+ */
+function setRequireContext(needCtx = true) {
+  core.setRequireContext(Boolean(needCtx));
+}
+
+/** 「上下文强制」开关当前值（对齐 py_store.schema.require_context） */
+function requireContext() {
+  return core.requireContext();
+}
+
 /** 取 asyncFn 计算列实现（fnRef 缺省 = 计算列 key 名） */
 function getAsyncFn(fnRef) {
   return _asyncFns[fnRef];
 }
 
-module.exports = { core, register, get, has, list, getAsyncFn };
+module.exports = { core, register, get, has, list, setRequireContext, requireContext, getAsyncFn };