mm_dao 1.8.2 → 1.8.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/lib/manager.js CHANGED
@@ -1,7 +1,7 @@
1
1
  const path = require("path");
2
2
  const Manager = require('mm_machine').Manager;
3
3
  const Dao = require("./dao");
4
- const { getSql } = require("mm_sql");
4
+ const { getSql, sqlAdmin } = require("mm_sql");
5
5
  const { array } = require("mm_helper");
6
6
 
7
7
  /**
@@ -63,8 +63,8 @@ class DaoManager extends Manager {
63
63
  */
64
64
  constructor(config, parent) {
65
65
  super({ ...DaoManager.config, ...config }, parent);
66
- // 兼容 Sql 实例(惰性创建,供 db()/load() 等价入口委托)
67
- this._sql = getSql();
66
+ // 兼容 Sql 实例(惰性创建,按作用域绑定数据源,见 _getSql)
67
+ this._sql = null;
68
68
  }
69
69
  }
70
70
 
@@ -190,37 +190,35 @@ DaoManager.prototype.sort = function () {
190
190
  * @param {string} name 名称
191
191
  * @param {object} query 查询参数
192
192
  * @param {object} body 修改参数
193
- * @param {object} db 数据库管理器 (object) 只支持可用sql语句的数据库
193
+ * @param {object} [db] 数据库管理器,不传时使用本作用域绑定的数据源
194
194
  * @returns {object} 执行结果
195
195
  */
196
196
  DaoManager.prototype.run = async function (name, query, body, db) {
197
197
  var obj = this.get(name);
198
198
  if (obj) {
199
- return await obj.run(query, body, db);
199
+ return await obj.run(query, body, db || this.db());
200
200
  }
201
201
  return null;
202
202
  };
203
203
 
204
204
  /**
205
- * 获取兼容 Sql 实例(惰性创建,复用服务端已建的数据库适配器)
205
+ * 获取本作用域绑定的 Sql 实例
206
+ * 数据源按作用域划分:os / user / org / project / client / app 各自可独立配置数据库;
207
+ * 作用域未单独配置 sql 时复用一个进程级主库,便于同库分域与后续平滑拆库。
206
208
  * @returns {Sql} 兼容 Sql 实例
207
209
  * @private
208
210
  */
209
211
  DaoManager.prototype._getSql = function () {
210
212
  if (!this._sql) {
211
- var SERVER = this.getServer();
212
- var server_config = (SERVER && SERVER.config) || {};
213
- var db_config = server_config.db || {};
214
- var way = this.config.way || db_config.type || "mysql";
215
- var sql_config = {
216
- scope: this.config.name || "sys",
217
- way: way,
218
- };
219
- var way_config = this.config[way] || server_config[way];
220
- if (way_config) {
221
- sql_config[way] = way_config;
213
+ const name = this.config.name || 'os';
214
+ const sql_config = this.config.sql;
215
+ if (sql_config) {
216
+ // 该作用域显式配置了数据源:按名取独立实例
217
+ this._sql = sqlAdmin(name, sql_config);
218
+ } else {
219
+ // 未单独配置:复用主库,避免出现未选库的空连接
220
+ this._sql = getSql();
222
221
  }
223
- this._sql = new Sql(sql_config);
224
222
  }
225
223
  return this._sql;
226
224
  };
package/package.json CHANGED
@@ -1,11 +1,11 @@
1
1
  {
2
2
  "name": "mm_dao",
3
- "version": "1.8.2",
3
+ "version": "1.8.4",
4
4
  "description": "一个通用的SQL帮助类,支持通过切换db_type实现对不同数据库的操作,包括MySQL和SQLite等;另提供 manager.js/drive.js 的SQL模板管理器(融合自 mm_os com/sql,基于 mm_corejs,内置管理器池,无全局/原型扩展依赖)",
5
5
  "main": "index.js",
6
6
  "scripts": {
7
7
  "start": "node tests/test.js",
8
- "test": "node tests/test.js",
8
+ "test": "node tests/test.js && node --test tests/scope.test.js",
9
9
  "lint": "eslint . --config eslint.config.js",
10
10
  "lint:fix": "eslint . --config eslint.config.js --fix",
11
11
  "lint:check": "eslint . --config eslint.config.js --max-warnings 0"
@@ -0,0 +1,244 @@
1
+ 'use strict';
2
+
3
+ /**
4
+ * Dao 主流程健壮性测试
5
+ * @description 覆盖 set / 导出取格式 / 去重 / 导入路径 等方法的真实 SQLite 行为
6
+ */
7
+
8
+ const test = require('node:test');
9
+ const assert = require('node:assert');
10
+ const fs = require('fs');
11
+ const os = require('os');
12
+ const path = require('path');
13
+ const { Dao, daoAdmin } = require('../index');
14
+
15
+ const db_dir = path.join(os.tmpdir(), 'mm_dao_main_test') + path.sep;
16
+
17
+ /**
18
+ * 构造一张空的 demo 表
19
+ * @returns {object} 表模型
20
+ */
21
+ function makeTable() {
22
+ if (!fs.existsSync(db_dir)) {
23
+ fs.mkdirSync(db_dir, { recursive: true });
24
+ }
25
+ daoAdmin('main_test', {
26
+ sql: { way: 'sqlite', sqlite: { dir: db_dir, database: 'main_test' } }
27
+ });
28
+ return daoAdmin('main_test').db().new('demo', 'id');
29
+ }
30
+
31
+ /**
32
+ * 重建表并写入初始数据
33
+ * @param {object} db 表模型
34
+ * @returns {Promise<void>}
35
+ */
36
+ async function reset(db) {
37
+ await db.exec('DROP TABLE IF EXISTS demo');
38
+ await db.exec(
39
+ 'CREATE TABLE demo (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, cnt INTEGER, user_id INTEGER)'
40
+ );
41
+ }
42
+
43
+ test('set: update 模板为空时仍能生成 SET 子句', async () => {
44
+ const db = makeTable();
45
+ await reset(db);
46
+ await db.exec("INSERT INTO demo (name, cnt) VALUES ('a', 1)");
47
+ const dao = new Dao({ name: 'm_set', table: 'demo', key: 'id' });
48
+ const ret = await dao.run({ method: 'set', id: '1' }, { cnt: 9 }, db);
49
+ assert.ok(!ret.error, '不应返回错误');
50
+ const row = await db.getObj({ id: 1 });
51
+ assert.strictEqual(row.cnt, 9);
52
+ });
53
+
54
+ test('set: update 模板按 {0} 替换,支持自增', async () => {
55
+ const db = makeTable();
56
+ await reset(db);
57
+ await db.exec("INSERT INTO demo (name, cnt) VALUES ('a', 5)");
58
+ const dao = new Dao({
59
+ name: 'm_set_tpl',
60
+ table: 'demo',
61
+ key: 'id',
62
+ update: { cnt: '`cnt` = `cnt` + {0}' }
63
+ });
64
+ await dao.run({ method: 'set', id: '1' }, { cnt: 3 }, db);
65
+ const row = await db.getObj({ id: 1 });
66
+ assert.strictEqual(row.cnt, 8);
67
+ });
68
+
69
+ test('getFormat: 派生视图保留 getSql,能按表取映射数据', async () => {
70
+ const db = makeTable();
71
+ await reset(db);
72
+ await db.exec("INSERT INTO demo (name, cnt) VALUES ('a', 1)");
73
+ const dao = new Dao({
74
+ name: 'm_fmt',
75
+ table: 'demo',
76
+ key: 'id',
77
+ format: [{ table: 'demo', id: 'id', key: 'name', name: 'name' }]
78
+ });
79
+ const fmt = await dao.getFormat(db);
80
+ assert.strictEqual(fmt[0].list.length, 1);
81
+ assert.strictEqual(fmt[0].list[0].name, 'a');
82
+ });
83
+
84
+ test('del_repeat: 控制参数不进 where,且只删多余的那条', async () => {
85
+ const db = makeTable();
86
+ await reset(db);
87
+ await db.exec("INSERT INTO demo (name, cnt) VALUES ('a', 1), ('b', 1), ('b', 1)");
88
+ const dao = new Dao({ name: 'm_repeat', table: 'demo', key: 'id' });
89
+ const ret = await dao.run(
90
+ { method: 'del_repeat', table: 'demo', page: '1', size: '10', groupby: 'name', field: 'name' },
91
+ {},
92
+ db
93
+ );
94
+ assert.ok(ret.result.bl);
95
+ const left = await db.getSql('', '', 'id,name');
96
+ assert.deepStrictEqual(left.map((o) => o.name), ['a', 'b']);
97
+ // 过程改动过分页,结束后必须还原
98
+ assert.strictEqual(db.page, 0);
99
+ assert.strictEqual(db.size, 30);
100
+ });
101
+
102
+ test('_processFilePath: URL 路径映射到运行目录下的静态目录', () => {
103
+ const dao = new Dao({ name: 'm_path', table: 'demo', key: 'id' });
104
+ const fpath = dao._processFilePath('/file/a.xlsx');
105
+ assert.ok(fpath.endsWith(path.join('static', 'file', 'a.xlsx')), fpath);
106
+ assert.ok(path.isAbsolute(fpath), fpath);
107
+ // 已在运行目录下的路径原样返回
108
+ assert.strictEqual(dao._processFilePath(fpath), fpath);
109
+ });
110
+
111
+ test('分隔符只在本 dao 拼接期间生效,不污染共享配置', () => {
112
+ const db = makeTable();
113
+ const before = db.config.separator;
114
+ const dao = new Dao({ name: 'm_sep', table: 'demo', separator: ',' });
115
+ const where = dao.toWhere(db, { name: 'a,b' });
116
+ // 按 , 拆分后应生成两个条件(默认 | 分隔符下会是一个等值条件)
117
+ assert.ok(where.includes("'a'") && where.includes("'b'"), where);
118
+ assert.strictEqual(db.config.separator, before);
119
+ });
120
+
121
+ test('del: 追加 query_default,删除范围与查询一致', async () => {
122
+ const db = makeTable();
123
+ await reset(db);
124
+ await db.exec("INSERT INTO demo (id, name, cnt, user_id) VALUES (1, 'a', 1, 1), (2, 'a', 1, 2)");
125
+ const dao = new Dao({
126
+ name: 'm_del_dft',
127
+ table: 'demo',
128
+ key: 'id',
129
+ dict: { user_id: 'uid' },
130
+ query_default: { user_id: '`user_id` = {uid}' },
131
+ });
132
+ // 当前登录用户是 2,只能删到自己的那条
133
+ db.user = { uid: 2 };
134
+ const ret = await dao.run({ method: 'del', name: 'a' }, {}, db);
135
+ assert.ok(ret.result.bl, '删除成功');
136
+ const left = await db.getSql('', '', 'id, user_id');
137
+ assert.deepStrictEqual(left.map((o) => o.user_id), [1]);
138
+ });
139
+
140
+ test('get: query_default 在 SQLite 下同样生效', async () => {
141
+ const db = makeTable();
142
+ await reset(db);
143
+ await db.exec("INSERT INTO demo (id, name, cnt, user_id) VALUES (1, 'a', 1, 1), (2, 'a', 1, 2)");
144
+ const dao = new Dao({
145
+ name: 'm_get_dft',
146
+ table: 'demo',
147
+ key: 'id',
148
+ dict: { user_id: 'uid' },
149
+ query_default: { user_id: '`user_id` = {uid}' },
150
+ });
151
+ db.user = { uid: 2 };
152
+ const ret = await dao.run({ method: 'get' }, {}, db);
153
+ assert.strictEqual(ret.result.list.length, 1);
154
+ assert.strictEqual(ret.result.list[0].user_id, 2);
155
+ });
156
+
157
+ test('del: 条件为空时拒绝删除', async () => {
158
+ const db = makeTable();
159
+ await reset(db);
160
+ await db.exec("INSERT INTO demo (name, cnt) VALUES ('a', 1)");
161
+ const dao = new Dao({ name: 'm_del_empty', table: 'demo', key: 'id' });
162
+ const ret = await dao.run({ method: 'del' }, {}, db);
163
+ assert.ok(ret.error, '应返回错误');
164
+ assert.ok(String(ret.error.message).includes('删除条件不能为空'), ret.error.message);
165
+ const left = await db.getSql('', '', 'id');
166
+ assert.strictEqual(left.length, 1, '数据不能被删掉');
167
+ });
168
+
169
+ test('addOrSet: 只改自己的记录,不碰他人数据', async () => {
170
+ const db = makeTable();
171
+ await reset(db);
172
+ await db.exec("INSERT INTO demo (id, name, cnt, user_id) VALUES (1, 'a', 1, 1), (2, 'a', 1, 2)");
173
+ const dao = new Dao({
174
+ name: 'm_aos_scope',
175
+ table: 'demo',
176
+ key: 'id',
177
+ dict: { user_id: 'uid' },
178
+ query_default: { user_id: '`user_id` = {uid}' },
179
+ });
180
+ // 当前用户是 2,同名记录的更新只能落在自己的那条
181
+ db.user = { uid: 2 };
182
+ const ret = await dao.addOrSet(db, { name: 'a' }, { cnt: 9 });
183
+ assert.ok(!ret.error, JSON.stringify(ret.error));
184
+ const rows = await db.getSql('', 'id', 'id, user_id, cnt');
185
+ assert.deepStrictEqual(
186
+ rows.map((o) => [o.user_id, o.cnt]),
187
+ [
188
+ [1, 1],
189
+ [2, 9],
190
+ ]
191
+ );
192
+ });
193
+
194
+ test('addOrSet: 新增时补齐 body_default,重复调用不会插出重复数据', async () => {
195
+ const db = makeTable();
196
+ await reset(db);
197
+ const dao = new Dao({
198
+ name: 'm_aos_ins',
199
+ table: 'demo',
200
+ key: 'id',
201
+ dict: { user_id: 'uid' },
202
+ query_default: { user_id: '`user_id` = {uid}' },
203
+ body_default: { user_id: '`user_id` = {uid}' },
204
+ });
205
+ db.user = { uid: 2 };
206
+ await dao.addOrSet(db, { name: 'z' }, { cnt: 1 });
207
+ await dao.addOrSet(db, { name: 'z' }, { cnt: 2 });
208
+ const rows = await db.getSql('', '', 'id, name, cnt, user_id');
209
+ assert.strictEqual(rows.length, 1, '同名同用户只能有一条');
210
+ assert.strictEqual(rows[0].user_id, 2, '新增记录必须带上隔离字段');
211
+ assert.strictEqual(rows[0].cnt, 2, '第二次调用应走更新');
212
+ });
213
+
214
+ test('del_repeat: 只在本用户范围内去重,不删他人重复项', async () => {
215
+ const db = makeTable();
216
+ await reset(db);
217
+ await db.exec(
218
+ "INSERT INTO demo (id, name, cnt, user_id) VALUES (1, 'b', 1, 1), (2, 'b', 1, 1), (3, 'b', 1, 2)"
219
+ );
220
+ const dao = new Dao({
221
+ name: 'm_repeat_scope',
222
+ table: 'demo',
223
+ key: 'id',
224
+ dict: { user_id: 'uid' },
225
+ query_default: { user_id: '`user_id` = {uid}' },
226
+ });
227
+ // 用户 2 只有一条 b,不该被去重
228
+ db.user = { uid: 2 };
229
+ await dao.run({ method: 'del_repeat', groupby: 'name', field: 'name' }, {}, db);
230
+ assert.deepStrictEqual((await db.getSql('', 'id', 'id')).map((o) => o.id), [1, 2, 3]);
231
+
232
+ // 用户 1 有两条 b,只删自己多余的那条(未指定排序时按默认顺序取,留下 id 较大的一条)
233
+ db.user = { uid: 1 };
234
+ await dao.run({ method: 'del_repeat', groupby: 'name', field: 'name' }, {}, db);
235
+ const left = await db.getSql('', 'id', 'id, user_id');
236
+ assert.deepStrictEqual(
237
+ left.map((o) => [o.id, o.user_id]),
238
+ [
239
+ [2, 1],
240
+ [3, 2],
241
+ ]
242
+ );
243
+ assert.strictEqual(left.length, 2, '每个用户各留一条');
244
+ });
@@ -0,0 +1,140 @@
1
+ 'use strict';
2
+
3
+ /**
4
+ * 查询参数字段过滤测试
5
+ * @description 验证控制参数在生成 where 之前被抽取,业务非表字段按 filter 声明
6
+ */
7
+
8
+ const test = require('node:test');
9
+ const assert = require('node:assert');
10
+ const fs = require('fs');
11
+ const os = require('os');
12
+ const path = require('path');
13
+ const { Dao, daoAdmin } = require('../index');
14
+
15
+ const db_dir = path.join(os.tmpdir(), 'mm_dao_query_test') + path.sep;
16
+
17
+ /**
18
+ * 创建测试用 SQLite 目录
19
+ * @returns {void}
20
+ */
21
+ function ensureDir() {
22
+ if (!fs.existsSync(db_dir)) {
23
+ fs.mkdirSync(db_dir, { recursive: true });
24
+ }
25
+ }
26
+
27
+ /**
28
+ * 构造表模型
29
+ * @returns {object} 数据管理器
30
+ */
31
+ function makeTable() {
32
+ ensureDir();
33
+ daoAdmin('query_test', {
34
+ sql: { way: 'sqlite', sqlite: { dir: db_dir, database: 'query_test' } }
35
+ });
36
+ return daoAdmin('query_test').db().new('demo', 'id');
37
+ }
38
+
39
+ test('控制参数不进入查询条件,真值赋给数据管理器', () => {
40
+ const dao = new Dao({ name: 'q_ctrl', table: 'demo', query: {} });
41
+ const db = makeTable();
42
+ const where = dao.toWhere(db, {
43
+ method: 'get',
44
+ page: '2',
45
+ size: '10',
46
+ orderby: 'id',
47
+ field: 'id',
48
+ count_ret: 'true',
49
+ db: 'org',
50
+ groupby: 'name'
51
+ });
52
+ assert.strictEqual(where, '');
53
+ assert.strictEqual(String(db.page), '2');
54
+ assert.strictEqual(String(db.size), '10');
55
+ assert.strictEqual(db.field, 'id');
56
+ assert.strictEqual(db.orderby, 'id');
57
+ assert.strictEqual(db.count_ret, 'true');
58
+ });
59
+
60
+ test('控制参数的假值同样被抽取,且不覆盖数据管理器默认值', () => {
61
+ const dao = new Dao({ name: 'q_falsy', table: 'demo', query: {} });
62
+ const db = makeTable();
63
+ const where = dao.toWhere(db, { method: 'get', page: '0', size: '' });
64
+ assert.strictEqual(where, '');
65
+ assert.strictEqual(db.size, 30);
66
+ });
67
+
68
+ test('业务非表字段按 filter 声明后抽取', () => {
69
+ const dao = new Dao({
70
+ name: 'q_org',
71
+ table: 'demo',
72
+ query: {},
73
+ filter: { org_id: '' }
74
+ });
75
+ const where = dao.toWhere(makeTable(), { method: 'get', org_id: '2' });
76
+ assert.strictEqual(where, '');
77
+ });
78
+
79
+ test('未声明的字段仍按等值条件处理', () => {
80
+ const dao = new Dao({ name: 'q_plain', table: 'demo', query: {} });
81
+ const where = dao.toWhere(makeTable(), { method: 'get', org_id: '2' });
82
+ assert.strictEqual(where, "`org_id` = '2'");
83
+ });
84
+
85
+ test('声明业务字段不会丢掉默认控制参数', () => {
86
+ const dao = new Dao({
87
+ name: 'q_merge',
88
+ table: 'demo',
89
+ query: {},
90
+ filter: { org_id: '' }
91
+ });
92
+ const where = dao.toWhere(makeTable(), { method: 'get', org_id: '2', db: 'org', groupby: 'name' });
93
+ assert.strictEqual(where, '');
94
+ });
95
+
96
+ test('业务查询条件正常保留', () => {
97
+ const dao = new Dao({
98
+ name: 'q_biz',
99
+ table: 'demo',
100
+ query: { name: "`name` like '%{0}%'" },
101
+ filter: { org_id: '' }
102
+ });
103
+ const where = dao.toWhere(makeTable(), { method: 'get', org_id: '2', name: '张三' });
104
+ assert.strictEqual(where, "`name` like '%张三%'");
105
+ });
106
+
107
+ test('空值不作为查询条件', () => {
108
+ const dao = new Dao({ name: 'q_null', table: 'demo', query: {} });
109
+ const where = dao.toWhere(makeTable(), { method: 'get', file: undefined, url: null });
110
+ assert.strictEqual(where, '');
111
+ });
112
+
113
+ test('filter 支持自定义参数名映射', () => {
114
+ const dao = new Dao({
115
+ name: 'q_alias',
116
+ table: 'demo',
117
+ query: {},
118
+ filter: { size: 'limit' }
119
+ });
120
+ const db = makeTable();
121
+ const where = dao.toWhere(db, { method: 'get', limit: '5' });
122
+ assert.strictEqual(where, '');
123
+ assert.strictEqual(String(db.size), '5');
124
+ });
125
+
126
+ test('固定显示字段时前端传参行为保持不变', () => {
127
+ const dao = new Dao({ name: 'q_fixed', table: 'demo', field: 'id,name', query: {} });
128
+ const db = makeTable();
129
+ const where = dao.toWhere(db, { method: 'get', field: 'id' });
130
+ assert.strictEqual(db.field, 'id,name');
131
+ assert.strictEqual(where, "`field` = 'id'");
132
+ });
133
+
134
+ test('固定排序时前端传参行为保持不变', () => {
135
+ const dao = new Dao({ name: 'q_fixed_sort', table: 'demo', orderby: 'id desc', query: {} });
136
+ const db = makeTable();
137
+ const where = dao.toWhere(db, { method: 'get', orderby: 'name asc' });
138
+ assert.strictEqual(db.orderby, 'id desc');
139
+ assert.strictEqual(where, "`orderby` = 'name asc'");
140
+ });
@@ -0,0 +1,91 @@
1
+ 'use strict';
2
+
3
+ /**
4
+ * 数据域测试
5
+ * @description 验证 daoAdmin(域) 的实例复用、域间独立与数据源绑定
6
+ */
7
+
8
+ const test = require('node:test');
9
+ const assert = require('node:assert');
10
+ const fs = require('fs');
11
+ const os = require('os');
12
+ const path = require('path');
13
+ const { daoAdmin } = require('../index');
14
+ const { getSql } = require('mm_sql');
15
+
16
+ const db_dir = path.join(os.tmpdir(), 'mm_dao_scope_test') + path.sep;
17
+
18
+ /**
19
+ * 创建测试用 SQLite 目录
20
+ * @returns {void}
21
+ */
22
+ function ensureDir() {
23
+ if (!fs.existsSync(db_dir)) {
24
+ fs.mkdirSync(db_dir, { recursive: true });
25
+ }
26
+ }
27
+
28
+ test('同一域复用同一管理器实例', () => {
29
+ const first = daoAdmin('test_same');
30
+ const second = daoAdmin('test_same');
31
+ assert.strictEqual(first, second);
32
+ });
33
+
34
+ test('不同域的管理器相互独立', () => {
35
+ const user = daoAdmin('test_user');
36
+ const org = daoAdmin('test_org_only');
37
+ assert.notStrictEqual(user, org);
38
+ assert.strictEqual(user.config.name, 'test_user');
39
+ assert.strictEqual(org.config.name, 'test_org_only');
40
+ });
41
+
42
+ test('配置 sql 时按域绑定独立数据源', () => {
43
+ ensureDir();
44
+ const manager = daoAdmin('test_bound', {
45
+ sql: { way: 'sqlite', sqlite: { dir: db_dir, database: 'test_bound' } }
46
+ });
47
+ assert.strictEqual(manager.db().getParent().config.database, 'test_bound');
48
+ });
49
+
50
+ test('两个域配置不同数据库时互不干扰', () => {
51
+ ensureDir();
52
+ const a = daoAdmin('test_db_a', {
53
+ sql: { way: 'sqlite', sqlite: { dir: db_dir, database: 'db_a' } }
54
+ });
55
+ const b = daoAdmin('test_db_b', {
56
+ sql: { way: 'sqlite', sqlite: { dir: db_dir, database: 'db_b' } }
57
+ });
58
+ assert.strictEqual(a.db().getParent().config.database, 'db_a');
59
+ assert.strictEqual(b.db().getParent().config.database, 'db_b');
60
+ });
61
+
62
+ test('未配置 sql 的域回落主库实例', () => {
63
+ const manager = daoAdmin('test_fallback');
64
+ assert.strictEqual(manager._getSql(), getSql());
65
+ });
66
+
67
+ test('默认域为 os', () => {
68
+ const manager = daoAdmin();
69
+ assert.strictEqual(manager.config.name, 'os');
70
+ assert.strictEqual(manager._getSql(), getSql());
71
+ });
72
+
73
+ test('含 {org_id} 的数据源配置只登记模板,不建实例', () => {
74
+ const ret = daoAdmin('test_org_tpl', {
75
+ sql: { way: 'sqlite', sqlite: { dir: db_dir, database: 'tpl_{org_id}' } }
76
+ });
77
+ assert.strictEqual(ret, null);
78
+ });
79
+
80
+ test('按机构派生出独立库,且同机构复用', () => {
81
+ ensureDir();
82
+ daoAdmin('test_org_tpl2', {
83
+ sql: { way: 'sqlite', sqlite: { dir: db_dir, database: 'tpl2_{org_id}' } }
84
+ });
85
+ const one = daoAdmin('test_org_tpl2', { org_id: 1 });
86
+ const two = daoAdmin('test_org_tpl2', { org_id: 2 });
87
+ assert.strictEqual(one.db().database(), 'tpl2_1');
88
+ assert.strictEqual(two.db().database(), 'tpl2_2');
89
+ assert.strictEqual(daoAdmin('test_org_tpl2', { org_id: 1 }), one);
90
+ assert.strictEqual(one.config.name, 'test_org_tpl2_1');
91
+ });