mm_api 1.1.4 → 1.1.7

package/README.md

@@ -1,3 +1,33 @@
 ## API框架
 用于实现web api和mvc模式路由请求
-负责配置路由路径、访问权限、校验机制
+负责配置路由路径、访问权限、校验机制
+
+### 接口数据源（dao.json 的 db 字段）
+
+接口用哪个库由接口自己声明，不依赖路由层注入。在 `dao.json` 里写 `db`：
+
+```json
+{
+  "name": "ai_agent",
+  "db": "org",
+  "schema": "ai.sql",
+  "table": "ai_agent",
+  ...
+}
+```
+
+- `db` 为数据域名，执行时经 `daoAdmin(域)` 取数据源；省略时默认 `os`（主库）。
+- `db: "org"` 表示按机构分库：机构ID取自 query 参数 `org_id`，取 `daoAdmin('org', { org_id })`，
+  即每个机构一个独立库（`org_{org_id}.db`）。
+  - 页面路由 `/ai/{org_id}/` 渲染时不带 query，自动回落到路径中的机构段；两者都没带时使用默认机构 `1`。
+  - `org_id` 是数据源标识而非表字段，需在 dao.json 的 `filter` 中声明：
+    `"filter": { "org_id": "" }`（值为空表示只抽取不赋值），DAO 生成 where 前会将其抽走（详见 mm_dao 文档）。
+- `schema` 为表结构脚本：首次访问某个机构库时自动执行一次（幂等），之后跳过。
+  路径从 dao.json 所在目录向上逐级查找。
+- 登录态、字典等系统表固定走主库，不受该字段影响。
+
+调用示例：
+
+```
+GET /api/ai/agent?org_id=2&method=get&size=10
+```

package/lib/api.js

@@ -3,6 +3,7 @@ const path = require("path");
 const Item = require('mm_machine').Mod;
 const { string, date, object, file } = require("mm_helper");
 const { getRet } = require('mm_ret');
+const { sqlAdmin } = require('mm_sql');
 const Oauth = require("./oauth.js"); // 是MM自带的身份验证机制，基于Oauth2.0，可以不使用
 
 /**
@@ -23,7 +24,12 @@ const Param = loadOptional("mm_param/lib/param.js"); // 是MM自带的参数机
 // 回退到 mm_sql 的 Sql（仅支持 run(sql, param, timeout) 原始SQL执行）
 const mm_dao = loadOptional("mm_dao");
 const Dao = mm_dao ? mm_dao.Dao : null;
+// 数据域入口：dao.json 声明 db 后，用对应域的数据源执行（未声明时仍为主库 os）
+const daoAdmin = mm_dao ? mm_dao.daoAdmin : null;
 const Sql = loadOptional("mm_sql/lib/sql.js"); // 是MM自带的sql机制，可以不使用
+// 登录态存储：token 解析优先走 mm_state_store（用户状态）+ mm_dict（token→user_id 映射）
+const mm_state_store = loadOptional("mm_state_store");
+const mm_dict = loadOptional("mm_dict");
 
 /** param 实例缓存（模块级，替代原全局 param 模块列表） */
 const PARAM_CACHE = new Map();
@@ -189,6 +195,8 @@ Api.prototype._preset = function () {
   this.param = null;
   // sql模板配置 + 函数
   this.sql = null;
+  // 数据域：接口默认使用主库（os），dao.json 的 db 字段可覆盖为其他域（如 org）
+  this.db_scope = this.config.db || "os";
 
   var cg = this.config;
   this._loadParam(cg.param_path);
@@ -328,6 +336,10 @@ Api.prototype._loadSql = function (file_path) {
   cfg.name = this.config.name || cfg.name;
   cfg.config_file = p;
   cfg.dir = path.dirname(p);
+  // 数据域：dao.json 用 db 字段声明本接口的数据源（如 "org"），未声明时为主库 os
+  this.db_scope = cfg.db || this.db_scope || "os";
+  // 表结构脚本：org 域按机构分库时，首次访问该机构库自动建表
+  this.schema = this._resolveSchema(cfg.schema);
   if (Dao) {
     this.sql = new Dao(cfg, this);
   } else {
@@ -498,6 +510,146 @@ Api.prototype._getState = async function (db, token) {
   }
 };
 
+/**
+ * 解析本次请求的机构ID
+ * 机构是调用方指定的数据源标识，以 query 参数 org_id 为准；
+ * 页面路由 /ai/{org_id}/ 渲染时不带 query，回落到路径中的机构段；
+ * 两者都没有时使用默认机构 1。
+ * @param {object} ctx HTTP上下文
+ * @returns {number} 机构ID
+ * @private
+ */
+function _orgId(ctx) {
+  var q = (ctx && (ctx.query || (ctx.request && ctx.request.query))) || {};
+  var v = q.org_id;
+  if (v !== undefined && v !== null && v !== "") {
+    var n = parseInt(v, 10);
+    if (!isNaN(n) && n > 0) {
+      return n;
+    }
+  }
+  var p = (ctx && (ctx.path || (ctx.request && ctx.request.path))) || "";
+  var m = /\/ai\/(\d+)(?=\/|$)/.exec(p);
+  return m ? parseInt(m[1], 10) : 1;
+}
+
+/**
+ * 按数据域名取数据管理器
+ * 数据源由接口自己声明（dao.json 的 db 字段），不依赖调用方下传：
+ * os 为主库；org 域按机构分库（daoAdmin('org', { org_id })）；
+ * 其余域名交由 mm_dao 的 daoAdmin 解析，域未配置时其内部回落主库。
+ * @param {string} scope 数据域名
+ * @param {number} [org_id] 机构ID（scope 为 org 时使用）
+ * @returns {object} 数据管理器
+ * @private
+ */
+function _scopedDb(scope, org_id) {
+  if (daoAdmin) {
+    try {
+      if (scope === "org") {
+        return daoAdmin("org", { org_id: org_id }).db();
+      }
+      if (scope && scope !== "os") {
+        return daoAdmin(scope).db();
+      }
+    } catch (err) {
+      // 域不可用时退回主库，避免因配置缺失导致接口整体不可用
+    }
+  }
+  return sqlAdmin("os").db();
+}
+
+/** 已建表的机构库标记，避免重复执行表结构脚本 */
+const SCHEMA_READY = new Set();
+
+/**
+ * 解析表结构脚本路径：从接口目录向上逐级查找（最多 8 级），命中即返回
+ * @param {string} name 脚本文件名
+ * @returns {string|null} 绝对路径，未找到返回 null
+ * @private
+ */
+Api.prototype._resolveSchema = function (name) {
+  if (!name) {
+    return null;
+  }
+  var dir = this.getDir();
+  for (var i = 0; i < 8 && dir; i++) {
+    var p = file.fullname(name, dir);
+    if (fs.existsSync(p)) {
+      return p;
+    }
+    var up = path.dirname(dir);
+    if (up === dir) {
+      break;
+    }
+    dir = up;
+  }
+  return null;
+};
+
+/**
+ * 首次访问某个机构库时创建表结构（幂等：同一库只执行一次）
+ * @param {object} manager 该机构的数据域管理器（提供 load 执行表结构脚本）
+ * @param {object} db 数据管理器
+ * @returns {Promise<void>} 无返回值
+ * @private
+ */
+Api.prototype._ensureSchema = async function (manager, db) {
+  if (!this.schema || !manager) {
+    return;
+  }
+  var key = (db.database ? db.database() : "") + "|" + this.schema;
+  if (SCHEMA_READY.has(key)) {
+    return;
+  }
+  SCHEMA_READY.add(key);
+  try {
+    await manager.load(this.schema);
+  } catch (err) {
+    SCHEMA_READY.delete(key);
+    throw err;
+  }
+};
+
+/**
+ * 获取本接口的数据管理器（数据源由 dao.json 的 db 字段声明，默认 os）
+ * org 域按机构ID分库（org_id 取自 query，页面路径兜底），并在首次访问时建表
+ * @param {object} ctx HTTP上下文
+ * @returns {Promise<object>} 数据管理器
+ * @private
+ */
+Api.prototype._getDb = async function (ctx) {
+  var scope = this.db_scope || "os";
+  if (scope === "org") {
+    var org_id = _orgId(ctx);
+    var name = "org_" + org_id;
+    if (!this._db_manager || this._db_manager_scope !== name) {
+      this._org_manager = daoAdmin ? daoAdmin("org", { org_id: org_id }) : null;
+      this._db_manager = this._org_manager ? this._org_manager.db() : sqlAdmin("os").db();
+      this._db_manager_scope = name;
+    }
+    await this._ensureSchema(this._org_manager, this._db_manager);
+    return this._db_manager;
+  }
+  if (!this._db_manager || this._db_manager_scope !== scope) {
+    this._db_manager = _scopedDb(scope);
+    this._db_manager_scope = scope;
+  }
+  return this._db_manager;
+};
+
+/**
+ * 获取主库数据管理器（登录态、字典等系统表固定走主库）
+ * @returns {object} 数据管理器
+ * @private
+ */
+Api.prototype._getMainDb = function () {
+  if (!this._main_db_manager) {
+    this._main_db_manager = sqlAdmin("os").db();
+  }
+  return this._main_db_manager;
+};
+
 /**
  * 获取登录态（原名 getState，因与 mm_corejs 生命周期 getState 冲突而更名）
  * @param {object} ctx 请求上下文
@@ -528,15 +680,37 @@ Api.prototype._getUserFromSession = function (ctx) {
   return null;
 };
 
+/**
+ * 从上下文中提取 auth token（协议头优先，Cookie 兜底）
+ * @param {object} ctx 请求上下文
+ * @returns {string} token，无则返回空串
+ * @private
+ */
+Api.prototype._getToken = function (ctx) {
+  var headers = (ctx && (ctx.headers || (ctx.request && ctx.request.headers))) || {};
+  var token = headers[this.config.token_key] || "";
+  if (!token && ctx) {
+    var cookies = ctx.cookies || (ctx.request && ctx.request.cookies);
+    if (cookies) {
+      token =
+        typeof cookies.get === "function"
+          ? cookies.get(this.config.token_key) || ""
+          : cookies[this.config.token_key] || "";
+    }
+  }
+  return String(token || "");
+};
+
 /**
  * 从 token 中获取用户信息
+ * 解析顺序：缓存 → 用户状态存储（mm_dict 映射 / 解码 → mm_state_store）→ 数据库
  * @param {object} ctx 请求上下文
  * @param {object} db 数据管理器
  * @returns {object|null} 用户信息
  * @private
  */
 Api.prototype._getUserFromToken = async function (params, ctx, options) {
-  var token = ctx.headers[this.config.token_key];
+  var token = this._getToken(ctx);
   if (!token) {
     return null;
   }
@@ -544,10 +718,76 @@ Api.prototype._getUserFromToken = async function (params, ctx, options) {
   if (cache) {
     var u = await cache.get(this.config.session_key + "_" + token);
     if (u) {
-      return await this._processUserFromCache(u, ctx, options, token);
+      return await this._processUserFromCache(u, ctx, token);
     }
   }
-  return await this._getUserFromDb(token, ctx, options);
+  var o = await this._getUserFromState(token, ctx);
+  if (o) {
+    return o;
+  }
+  // 数据库兜底：自行获取数据管理器查询
+  return await this._getUserFromDb(token, ctx);
+};
+
+/**
+ * 从用户状态存储获取用户信息
+ * token → user_id：mm_dict 映射，或 base64(JSON) 直接解码；
+ * user_id → 用户：mm_state_store 的 stateAdmin('user') 中 user_{id} 状态的 user 字段
+ * @param {string} token token
+ * @param {object} ctx 请求上下文
+ * @param {object} options 数据管理器
+ * @returns {object|null} 用户信息，未识别或状态中无用户资料返回 null
+ * @private
+ */
+Api.prototype._getUserFromState = async function (token, ctx, options) {
+  if (!mm_state_store || !mm_dict) {
+    return null;
+  }
+  try {
+    // 1. token → user_id：字典映射，或 base64(JSON) 解码
+    var user_id = null;
+    try {
+      user_id = mm_dict.dictAdmin("token").get(token);
+    } catch (err) {
+      user_id = null;
+    }
+    if (!user_id) {
+      try {
+        var json = Buffer.from(token, "base64").toString("utf8");
+        if (/^\s*\{[\s\S]*\}\s*$/.test(json)) {
+          var obj = JSON.parse(json);
+          if (obj && obj.user_id !== undefined && obj.user_id !== null && obj.user_id !== "") {
+            user_id = String(obj.user_id);
+          }
+        }
+      } catch (err) {
+        user_id = null;
+      }
+    }
+    if (!user_id) {
+      return null;
+    }
+    // 2. user_id → 用户状态
+    var state = null;
+    try {
+      state = await mm_state_store.stateAdmin("user").get("user_" + user_id);
+    } catch (err) {
+      state = null;
+    }
+    if (!state || !state.user) {
+      return null;
+    }
+    var o = { ...state.user };
+    o.token = token;
+    o.user_id = String(user_id);
+    if (ctx && ctx.session) {
+      ctx.session.uuid = ctx.session.uuid || token;
+      ctx.session.user = o;
+    }
+    return o;
+  } catch (err) {
+    return null;
+  }
 };
 
 /**
@@ -559,7 +799,7 @@ Api.prototype._getUserFromToken = async function (params, ctx, options) {
  * @returns {object|null} 用户信息
  * @private
  */
-Api.prototype._processUserFromCache = async function (u, ctx, options, token) {
+Api.prototype._processUserFromCache = async function (u, ctx, token) {
   var o;
   if (typeof u === "string") {
     o = { ...string.toJson(u) };
@@ -570,7 +810,7 @@ Api.prototype._processUserFromCache = async function (u, ctx, options, token) {
     return null;
   }
   if (!o.user_id) {
-    return await this._getUserFromDb(token, ctx, options);
+    return await this._getUserFromDb(token, ctx);
   }
   o.token = token;
   return o;
@@ -584,8 +824,8 @@ Api.prototype._processUserFromCache = async function (u, ctx, options, token) {
  * @returns {object|null} 用户信息
  * @private
  */
-Api.prototype._getUserFromDb = async function (token, ctx, options) {
-  var obj = await this._getState(options, token);
+Api.prototype._getUserFromDb = async function (token, ctx) {
+  var obj = await this._getState(this._getMainDb(), token);
   if (obj) {
     var o = { ...obj.user };
     ctx.session.user = obj.user;
@@ -633,13 +873,15 @@ Api.prototype.before = async function (params, ctx, options) {
 Api.prototype.main = async function (params, ctx, options) {
   if (this.sql) {
     var req = ctx.request;
-    // 获取文件
-    if (req.files) {
+    // 获取文件（仅在上传时处理，files 为空对象时不应往 body 写空字段）
+    if (req.files && req.files.file) {
       var fobj = this.saveFile(req.files);
       req.body.file = fobj.file;
       req.body.url = fobj.url;
     }
-    var ret = await this.sql.run(req.query, req.body, options);
+    // 数据源由接口自行解析（dao.json 的 db 字段），
+    // 组织过滤由 DAO 按 dao.json 的 filter 声明统一抽取，此处不改动请求参数
+    var ret = await this.sql.run(req.query, req.body, await this._getDb(ctx));
     return ret;
   } else {
     return getRet().error(10000, "接口函数未定义");

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mm_api",
-    "version": "1.1.4",
+    "version": "1.1.7",
     "description": "API框架，用于实现web api和mvc模式路由请求，负责配置路由路径、访问权限、校验机制；基于 mm_corejs，内置管理器池，无全局/原型扩展依赖",
     "main": "index.js",
     "keywords": [
@@ -24,11 +24,13 @@
     "dependencies": {
         "mm_corejs": "^1.1.4",
         "mm_dao": "^1.8.2",
+        "mm_dict": "^1.0.3",
         "mm_helper": "^1.0.0",
         "mm_machine": "^3.5.4",
         "mm_param": "^1.1.0",
         "mm_ret": "^1.4.8",
-        "mm_sql": "^1.8.0"
+        "mm_sql": "^1.8.0",
+        "mm_state_store": "^1.0.3"
     },
     "scripts": {
         "test": "node test.js && node --test tests/*.test.js"

package/tests/fixtures/dao_org.json

@@ -0,0 +1,11 @@
+{
+  "name": "ai_agent",
+  "db": "org",
+  "schema": "ai.sql",
+  "table": "ai_agent",
+  "key": "agent_id",
+  "filter": { "org_id": "" },
+  "query": {
+    "name": "`name` like '%{0}%'"
+  }
+}

package/tests/fixtures/dao_org_plain.json

@@ -0,0 +1,9 @@
+{
+  "name": "ai_agent_plain",
+  "db": "org",
+  "table": "ai_agent",
+  "key": "agent_id",
+  "query": {
+    "name": "`name` like '%{0}%'"
+  }
+}

package/tests/org.test.js

@@ -0,0 +1,121 @@
+'use strict';
+
+/**
+ * 机构数据源测试
+ * @description 覆盖 org 域的机构ID来源（query 优先、路径兜底），以及
+ *              控制参数在进入 where 之前被剔除（DAO 层统一处理）
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const os = require('node:os');
+const path = require('node:path');
+const Api = require('../lib/api.js');
+const { daoAdmin } = require('mm_dao');
+
+// 登记 org 域的分库模板（每个机构一个独立的 SQLite 库）
+daoAdmin('org', {
+  sql: {
+    way: 'sqlite',
+    sqlite: { dir: path.join(os.tmpdir(), 'mm_api_org_test/'), database: 'org_{org_id}' }
+  }
+});
+
+/**
+ * 构造接口实例
+ * @param {string} dao_file dao 配置文件名
+ * @returns {Api} 接口实例
+ */
+function makeApi(dao_file) {
+  const api = new Api({
+    name: 'org_probe_' + Math.random().toString(36).slice(2),
+    dir: __dirname,
+    db: 'org'
+  });
+  api._loadSql('fixtures/' + dao_file);
+  return api;
+}
+
+/**
+ * 拦截 DAO 执行，记录实际使用的库与查询参数
+ * @param {Api} api 接口实例
+ * @returns {object} 记录对象
+ */
+function spy(api) {
+  const seen = { db: '', query: null };
+  api.sql.run = async (query, body, db) => {
+    seen.db = String(db.database());
+    seen.query = { ...query };
+    return { error: 0 };
+  };
+  return seen;
+}
+
+test('org_id 取自 query 参数', async () => {
+  const api = makeApi('dao_org.json');
+  const seen = spy(api);
+  await api.main({}, { request: { query: { org_id: '2', method: 'get' }, body: {} }, path: '/api/ai/agent' }, {});
+  assert.equal(seen.db, 'org_2', '应落到机构 2 的库');
+});
+
+test('页面路由不带 query 时回落路径中的机构段', async () => {
+  const api = makeApi('dao_org.json');
+  const seen = spy(api);
+  await api.main({}, { request: { query: { method: 'get' }, body: {} }, path: '/ai/3/' }, {});
+  assert.equal(seen.db, 'org_3', '应落到机构 3 的库');
+});
+
+test('query 与路径同时存在时以 query 为准', async () => {
+  const api = makeApi('dao_org.json');
+  const seen = spy(api);
+  await api.main({}, { request: { query: { org_id: '5', method: 'get' }, body: {} }, path: '/ai/9/' }, {});
+  assert.equal(seen.db, 'org_5', 'query 优先于路径');
+});
+
+test('都未指定时使用默认机构 1', async () => {
+  const api = makeApi('dao_org.json');
+  const seen = spy(api);
+  await api.main({}, { request: { query: { method: 'get' }, body: {} }, path: '/api/ai/agent' }, {});
+  assert.equal(seen.db, 'org_1', '默认落到机构 1');
+});
+
+test('dao.json 声明 filter 后 org_id 不进入 where', () => {
+  const api = makeApi('dao_org.json');
+  const db = daoAdmin('org', { org_id: 2 }).db().new('ai_agent', 'agent_id');
+  const where = api.sql.toWhere(db, { method: 'get', org_id: '2' });
+  assert.equal(where, '', 'org_id 应被抽取，where 为空');
+});
+
+test('未声明 filter 时 org_id 会被当成查询条件', () => {
+  const api = makeApi('dao_org_plain.json');
+  const db = daoAdmin('org', { org_id: 2 }).db().new('ai_agent', 'agent_id');
+  const where = api.sql.toWhere(db, { method: 'get', org_id: '2' });
+  assert.equal(where, "`org_id` = '2'", '未声明时按普通字段处理');
+});
+
+test('控制参数不进入 where（含假值）', () => {
+  const api = makeApi('dao_org.json');
+  const db = daoAdmin('org', { org_id: 2 }).db().new('ai_agent', 'agent_id');
+  const where = api.sql.toWhere(db, {
+    method: 'get',
+    page: '0',
+    size: '',
+    orderby: 'agent_id desc',
+    db: 'org',
+    groupby: 'llm',
+    org_id: '2'
+  });
+  assert.equal(where, '', '分页、排序、数据域等控制参数都应被剔除');
+});
+
+test('业务查询条件正常保留', () => {
+  const api = makeApi('dao_org.json');
+  const db = daoAdmin('org', { org_id: 2 }).db().new('ai_agent', 'agent_id');
+  const where = api.sql.toWhere(db, { method: 'get', org_id: '2', name: '张三' });
+  assert.equal(where, "`name` like '%张三%'", '业务字段应按 query 模板生成条件');
+});
+
+test('非 org 域不受 org_id 影响', () => {
+  const api = new Api({ name: 'os_probe_' + Math.random().toString(36).slice(2), dir: __dirname });
+  assert.equal(api.db_scope, 'os', '未声明 db 时为主库');
+});