mm_datas 0.0.0-stage → 5.3.1

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.
Files changed (42) hide show
  1. package/example/custom_demo.js +237 -0
  2. package/example/model/item_model.json +46 -0
  3. package/example/model/map_model.json +53 -0
  4. package/example/model/player_model.json +65 -0
  5. package/example/model/role_model.json +61 -0
  6. package/example/model/skill_model.json +60 -0
  7. package/example/preset_demo.js +44 -0
  8. package/example/rpg_cache.js +179 -0
  9. package/example/rpg_crud.js +170 -0
  10. package/example/rpg_demo.js +61 -0
  11. package/example/rpg_model/bag_model.json +74 -0
  12. package/example/rpg_model/character_model.json +165 -0
  13. package/example/rpg_model/character_skill_model.json +61 -0
  14. package/example/rpg_model/drop_model.json +103 -0
  15. package/example/rpg_model/item_model.json +189 -0
  16. package/example/rpg_model/job_model.json +96 -0
  17. package/example/rpg_model/level_exp_model.json +111 -0
  18. package/example/rpg_model/map_model.json +166 -0
  19. package/example/rpg_model/map_state_model.json +63 -0
  20. package/example/rpg_model/monster_model.json +115 -0
  21. package/example/rpg_model/npc_model.json +103 -0
  22. package/example/rpg_model/quest_model.json +106 -0
  23. package/example/rpg_model/quest_progress_model.json +61 -0
  24. package/example/rpg_model/save_model.json +42 -0
  25. package/example/rpg_model/skill_model.json +124 -0
  26. package/example/rpg_persistence.js +151 -0
  27. package/example/rpg_relations.js +196 -0
  28. package/example/rpg_world.js +149 -0
  29. package/example/storage_demo.js +194 -0
  30. package/index.js +122 -0
  31. package/lib/backend.js +597 -0
  32. package/lib/errors.js +35 -0
  33. package/lib/manager.js +717 -0
  34. package/lib/model.js +540 -0
  35. package/lib/pool.js +277 -0
  36. package/lib/relation.js +175 -0
  37. package/lib/store.js +430 -0
  38. package/package.json +64 -5
  39. package/test.js +748 -0
  40. package/tool/data/index.js +107 -0
  41. package/tool/data/tool.json +211 -0
  42. package/README.md +0 -3
package/test.js ADDED
@@ -0,0 +1,748 @@
1
+ 'use strict';
2
+ /**
3
+ * mm_datas 测试:mm_admin 实例池 + DataManager + 标准 JSON Schema(禁用 int/integer)
4
+ * 规则判定委托 mm_validator。运行:node test.js
5
+ */
6
+ const fs = require('fs');
7
+ const os = require('os');
8
+ const path = require('path');
9
+ const mm = require('./index.js');
10
+ const S = require('./lib/store.js');
11
+ const M = require('./lib/model.js');
12
+ const tool = require('./tool/data/index.js');
13
+
14
+ const DRAFT = 'http://json-schema.org/draft-07/schema#';
15
+ let pass = 0;
16
+ let fail = 0;
17
+ const fails = [];
18
+
19
+ function ok(name, cond, extra) {
20
+ if (cond) { pass++; console.log(' PASS ' + name); }
21
+ else { fail++; fails.push(name); console.log(' FAIL ' + name + (extra ? ' → ' + JSON.stringify(extra) : '')); }
22
+ }
23
+ function eq(name, actual, expected) {
24
+ ok(name, JSON.stringify(actual) === JSON.stringify(expected), { actual: actual, expected: expected });
25
+ }
26
+ function throws(name, fn, code) {
27
+ try { fn(); ok(name, false, '未抛异常'); }
28
+ catch (e) { ok(name, !code || e.code === code, { code: e.code, message: e.message }); }
29
+ }
30
+ function hasError(name, errs, fragment) {
31
+ ok(name, errs.some(function (e) { return e.indexOf(fragment) > -1; }), errs);
32
+ }
33
+ function group(t) { console.log('\n--- ' + t + ' ---'); }
34
+
35
+ /** 延时等待 */
36
+ function sleep(ms) { return new Promise(function (resolve) { setTimeout(resolve, ms); }); }
37
+
38
+ /** 构造一份标准 JSON Schema 的快捷函数 */
39
+ function standard(properties, required, additionalProperties) {
40
+ return {
41
+ $schema: DRAFT, type: 'object', properties: properties,
42
+ required: required || [],
43
+ additionalProperties: additionalProperties === undefined ? false : additionalProperties
44
+ };
45
+ }
46
+
47
+ async function run() {
48
+ // ============ 1. mm_admin 实例池 / DataManager ============
49
+ group('1. 基于 mm_admin 实例池,管理类统一为 DataManager');
50
+ mm.dataAdmin.reset();
51
+ ok('dataAdmin 是函数', typeof mm.dataAdmin === 'function');
52
+ ok('dataAdmin() 返回 mm_admin 的 Admin 实例', mm.dataAdmin() instanceof mm.Admin);
53
+ ok('池绑定了 DataManager 类', mm.dataAdmin().getClass() === mm.DataManager);
54
+ ok('池通过 setServer 注入共享 store', !!mm.dataAdmin().getServer().models);
55
+ ok('mm_admin 全局注册表里有 mm_datas', mm.list().indexOf('mm_datas') > -1);
56
+ eq('初始注册表为空', mm.dataAdmin.registry().models().length, 0);
57
+
58
+ const role = mm.dataAdmin('role');
59
+ ok('dataAdmin("role") 是 DataManager 实例', role instanceof mm.DataManager);
60
+ eq('集合名就是 name', role.name, 'role');
61
+ eq('mm_admin 注入的 config.name', role.config.name, 'role');
62
+ ok('同名复用池中的同一实例', mm.dataAdmin('role') === role);
63
+ eq('实例已在池中缓存', mm.dataAdmin().has('role'), true);
64
+ ok('所有集合共享同一个 store', role.store === mm.dataAdmin('map').store);
65
+ eq('自由集合无约束', role.constrained, false);
66
+ eq('自由集合 schema() 为 null', role.schema(), null);
67
+ eq('自由集合默认主键', role.key, 'id');
68
+
69
+ // ============ 2. 自由集合 ============
70
+ group('2. 自由集合:任意字段 / 自动主键 / 直接拿数据');
71
+ const r1 = role.add({ name: '亚瑟', level: 10, tags: ['tank'], extra: { a: 1 } });
72
+ eq('自动分配主键 id=1', r1.id, 1);
73
+ role.add({ name: '梅林', level: 22, job: 'mage' });
74
+ eq('两条记录', role.size, 2);
75
+ eq('角色字段完全自由', role.get(1).tags, ['tank']);
76
+ eq('all() 返回数组', Array.isArray(role.all()), true);
77
+ eq('toJSON() 也是数据数组', JSON.stringify(role).indexOf('亚瑟') > -1, true);
78
+ eq('可迭代', Array.from(role).length, 2);
79
+ eq('first()', role.first({ level: { $gt: 20 } }).name, '梅林');
80
+ eq('where()', role.where({ name: '亚瑟' }).length, 1);
81
+ eq('map()', role.map(function (r) { return r.name; }), ['亚瑟', '梅林']);
82
+
83
+ const map = mm.dataAdmin('map');
84
+ map.seed([{ map_id: 1001, name: '新手村' }, { map_id: 1002, name: '幽暗森林' }]);
85
+ eq('集合之间数据隔离', role.size, 2);
86
+ eq('另一个集合独立', map.size, 2);
87
+ eq('任意名字都可用', mm.dataAdmin('宠物').add({ name: '小火龙' }).id, 1);
88
+
89
+ // ============ 3. 标准 JSON Schema 的严格约束 ============
90
+ group('3. model.schema 是标准 JSON Schema(draft-07 子集)');
91
+ const heroSchema = standard({
92
+ name: { type: 'string', minLength: 1, maxLength: 12 },
93
+ level: { type: 'number', minimum: 1, maximum: 99, default: 1 },
94
+ job: { type: 'string', enum: ['warrior', 'mage'], default: 'warrior' },
95
+ code: { type: 'string', pattern: '^[A-Z]{2}[0-9]+$' },
96
+ slot: { type: 'number', const: 4 },
97
+ attrs: {
98
+ type: 'object',
99
+ properties: {
100
+ hp: { type: 'number', minimum: 0 },
101
+ mp: { type: 'number', minimum: 0 },
102
+ element: { type: 'string', enum: ['fire', 'water'] }
103
+ },
104
+ required: ['hp'], additionalProperties: false
105
+ },
106
+ tags: { type: 'array', items: { type: 'string' }, maxItems: 3 }
107
+ }, ['name']);
108
+ const hero = mm.dataAdmin('hero', { key: 'hero_id', schema: heroSchema });
109
+
110
+ eq('schema() 返回标准文档', hero.schema().type, 'object');
111
+ eq('schema() 带 $schema', hero.schema().$schema, DRAFT);
112
+ eq('schema() 带 required 数组', hero.schema().required, ['name']);
113
+ eq('schema() 带 additionalProperties', hero.schema().additionalProperties, false);
114
+ eq('声明 schema 后启用约束', hero.constrained, true);
115
+ eq('additionalProperties:false 即严格', hero.strict, true);
116
+ ok('properties 是标准字段表', !!hero.schema().properties.level);
117
+ ok('主键自动补入 properties(不误判未知字段)', !!hero.schema().properties.hero_id);
118
+ eq('保留原始 jsonSchema', hero.model().jsonSchema.$schema, DRAFT);
119
+
120
+ eq('合法 object 通过 validate()', hero.validate({
121
+ name: '亚瑟', attrs: { hp: 100, mp: 20 }, tags: ['tank'], code: 'AB12'
122
+ }).ok, true);
123
+ eq('合法 object 写入', hero.add({
124
+ name: '亚瑟', level: 10, attrs: { hp: 100, mp: 20 }, tags: ['tank'], code: 'AB12'
125
+ }).id, 1);
126
+ eq('默认值生效', hero.get(1).job, 'warrior');
127
+
128
+ throws('未知字段被拒绝', function () { hero.add({ name: 'B', evil: 1 }); }, 'SCHEMA_VALIDATION');
129
+ throws('必填缺失被拒绝', function () { hero.add({ level: 2 }); }, 'SCHEMA_VALIDATION');
130
+ throws('类型不符被拒绝', function () { hero.add({ name: 'B', level: '高' }); }, 'SCHEMA_VALIDATION');
131
+ throws('minimum 越界被拒绝', function () { hero.add({ name: 'B', level: 0 }); }, 'SCHEMA_VALIDATION');
132
+ throws('maximum 越界被拒绝', function () { hero.add({ name: 'B', level: 1000 }); }, 'SCHEMA_VALIDATION');
133
+ throws('枚举不符被拒绝', function () { hero.add({ name: 'B', job: 'thief' }); }, 'SCHEMA_VALIDATION');
134
+ throws('const 不符被拒绝', function () { hero.add({ name: 'B', slot: 5 }); }, 'SCHEMA_VALIDATION');
135
+ throws('maxLength 不符被拒绝', function () { hero.add({ name: 'A'.repeat(20) }); }, 'SCHEMA_VALIDATION');
136
+ throws('minLength 不符被拒绝', function () { hero.add({ name: '' }); }, 'SCHEMA_VALIDATION');
137
+ throws('pattern 不符被拒绝', function () { hero.add({ name: 'B', code: 'xx' }); }, 'SCHEMA_VALIDATION');
138
+ throws('嵌套未声明属性被拒绝', function () {
139
+ hero.add({ name: 'B', attrs: { hp: 1, evil: 9 } });
140
+ }, 'SCHEMA_VALIDATION');
141
+ throws('嵌套属性类型不符被拒绝', function () {
142
+ hero.add({ name: 'B', attrs: { hp: '一百' } });
143
+ }, 'SCHEMA_VALIDATION');
144
+ throws('嵌套缺必填属性被拒绝', function () {
145
+ hero.add({ name: 'B', attrs: { mp: 5 } });
146
+ }, 'SCHEMA_VALIDATION');
147
+ throws('数组元素类型不符被拒绝', function () {
148
+ hero.add({ name: 'B', tags: [1, 2] });
149
+ }, 'SCHEMA_VALIDATION');
150
+ throws('maxItems 超长被拒绝', function () {
151
+ hero.add({ name: 'B', tags: ['a', 'b', 'c', 'd'] });
152
+ }, 'SCHEMA_VALIDATION');
153
+
154
+ hasError('错误信息带嵌套路径', hero.validate({ name: 'B', attrs: { hp: 1, evil: 9 } }).errors, 'attrs.evil');
155
+ hasError('错误信息带数组下标', hero.validate({ name: 'B', tags: [1] }).errors, 'tags[0]');
156
+ hasError('范围错误消息来自 mm_validator', hero.validate({ name: 'B', level: 1000 }).errors, '不能大于 99');
157
+ hasError('类型错误消息来自 mm_validator', hero.validate({ name: 'B', level: '高' }).errors, '类型应为');
158
+
159
+ const loose = mm.dataAdmin('loose', { schema: standard({ a: { type: 'number', minimum: 1 } }, [], true) });
160
+ eq('additionalProperties:true 不严格', loose.strict, false);
161
+ eq('additionalProperties:true 允许额外字段', loose.add({ a: 1, whatever: 'x' }).affected, 1);
162
+ throws('additionalProperties:true 仍校验已声明字段', function () { loose.add({ a: 0 }); }, 'SCHEMA_VALIDATION');
163
+
164
+ throws('set 写入非法值被拒绝', function () { hero.set(1, { level: 5000 }); }, 'SCHEMA_VALIDATION');
165
+ eq('set 被拒后原值不变(原子性)', hero.get(1).level, 10);
166
+ throws('patch 让结果越界被拒绝', function () { hero.patch(1, { $inc: { level: 999 } }); }, 'SCHEMA_VALIDATION');
167
+ eq('patch 被拒后原值不变', hero.get(1).level, 10);
168
+ eq('合法 patch 生效', (function () { hero.patch(1, { $inc: { level: 5 } }); return hero.get(1).level; })(), 15);
169
+ throws('addMany 有一条非法则整批不写入', function () {
170
+ hero.addMany([{ name: 'C' }, { name: 'D', level: -1 }]);
171
+ }, 'SCHEMA_VALIDATION');
172
+ eq('addMany 失败后集合行数不变', hero.size, 1);
173
+ throws('seed 默认也执行 schema 约束', function () { hero.seed([{ name: 'X', level: -5 }]); }, 'SCHEMA_VALIDATION');
174
+ eq('seed 失败不破坏已有数据', hero.size, 1);
175
+ eq('seed({raw:true}) 构建期装载可用', hero.seed([{ name: 'X', level: 3 }], { raw: true }).count, 1);
176
+ eq('validate 只校验不写入', hero.validate({ name: 'B', level: -1 }).ok, false);
177
+ eq('validate 不产生新行', hero.size, 1);
178
+
179
+ // ============ 4. 类型白名单:int / integer 一律禁用 ============
180
+ group('4. 不要 int 类型:定义阶段即拒绝,整数统一 number');
181
+ throws('顶层 integer 被拒绝', function () {
182
+ mm.dataAdmin('bad_1', { schema: standard({ lv: { type: 'integer' } }) });
183
+ }, 'SCHEMA_TYPE_UNSUPPORTED');
184
+ throws('int 被拒绝', function () {
185
+ mm.dataAdmin('bad_2', { schema: standard({ lv: { type: 'int' } }) });
186
+ }, 'SCHEMA_TYPE_UNSUPPORTED');
187
+ throws('any 被拒绝', function () {
188
+ mm.dataAdmin('bad_3', { schema: standard({ lv: { type: 'any' } }) });
189
+ }, 'SCHEMA_TYPE_UNSUPPORTED');
190
+ throws('嵌套 properties 里的 integer 被拒绝', function () {
191
+ mm.dataAdmin('bad_4', { schema: standard({
192
+ attrs: { type: 'object', properties: { hp: { type: 'integer' } } }
193
+ }) });
194
+ }, 'SCHEMA_TYPE_UNSUPPORTED');
195
+ throws('items 里的 integer 被拒绝', function () {
196
+ mm.dataAdmin('bad_5', { schema: standard({
197
+ tags: { type: 'array', items: { type: 'integer' } }
198
+ }) });
199
+ }, 'SCHEMA_TYPE_UNSUPPORTED');
200
+ throws('运行时 field() 里的 integer 被拒绝', function () {
201
+ hero.field('bad_int_field', { type: 'integer' });
202
+ }, 'SCHEMA_TYPE_UNSUPPORTED');
203
+ ok('错误消息提示改用 number', (function () {
204
+ try { mm.dataAdmin('bad_6', { schema: standard({ lv: { type: 'integer' } }) }); return false; }
205
+ catch (e) { return e.message.indexOf('请改用 "number"') > -1; }
206
+ })());
207
+ eq('validator().allowed_types 无 int', mm.validator().allowed_types,
208
+ ['string', 'number', 'boolean', 'object', 'array', 'null']);
209
+ ok('validator().forbidden_types 含 integer', mm.validator().forbidden_types.indexOf('integer') > -1);
210
+ eq('validator().schema_draft', mm.validator().schema_draft, DRAFT);
211
+ eq('number 类型正常工作', mm.dataAdmin('num_ok', {
212
+ schema: standard({ lv: { type: 'number', minimum: 1 } })
213
+ }).add({ lv: 2 }).affected, 1);
214
+ throws('number 仍校验范围', function () { mm.dataAdmin('num_ok').add({ lv: 0 }); }, 'SCHEMA_VALIDATION');
215
+
216
+ // 全仓示例模型不含任何 int 类型
217
+ const modelFiles = fs.readdirSync(mm.EXAMPLE_MODEL_DIR).filter(function (f) { return /\.json$/i.test(f); });
218
+ let intHits = 0;
219
+ let nonStandard = 0;
220
+ modelFiles.forEach(function (f) {
221
+ const def = JSON.parse(fs.readFileSync(path.join(mm.EXAMPLE_MODEL_DIR, f), 'utf8'));
222
+ const text = JSON.stringify(def.schema);
223
+ if (/:\s*"integer"|:\s*"int"|:\s*"any"/.test(text)) intHits++;
224
+ if (def.schema.type !== 'object' || !def.schema.properties || !Array.isArray(def.schema.required)) nonStandard++;
225
+ });
226
+ eq('15 个示例模型文件', modelFiles.length, 15);
227
+ eq('示例模型零 int 类型', intHits, 0);
228
+ eq('示例模型全部是标准 JSON Schema', nonStandard, 0);
229
+ eq('示例模型 $schema 一致', (function () {
230
+ const def = JSON.parse(fs.readFileSync(path.join(mm.EXAMPLE_MODEL_DIR, 'item_model.json'), 'utf8'));
231
+ return def.schema.$schema;
232
+ })(), DRAFT);
233
+
234
+ // ============ 5. 运行时自定义定义 ============
235
+ group('5. 集合定义完全由使用者给,运行时可改');
236
+ eq('自定义主键生效', hero.key, 'hero_id');
237
+ hero.field('title', { type: 'string', default: '见习' });
238
+ eq('field() 后数据保留', hero.size, 1);
239
+ eq('field() 写入标准 properties', hero.schema().properties.title.type, 'string');
240
+ eq('field() 默认值可用', hero.add({ name: 'D' }).obj.title, '见习');
241
+ eq('field() 不写 type 即无约束', (function () {
242
+ hero.field('free_field', {});
243
+ return hero.schema().properties.free_field.type === undefined;
244
+ })(), true);
245
+ eq('getField 可读字段定义', M.getField(hero.schema(), 'title').default, '见习');
246
+ eq('drop 删除集合', (function () { mm.dataAdmin('tmp').drop(); return mm.dataAdmin.registry().has('tmp'); })(), false);
247
+ eq('clear 只清数据保留定义', (function () { hero.clear(); return hero.model().key; })(), 'hero_id');
248
+
249
+ // 旧扁平格式自动升级为标准文档
250
+ const legacy = mm.dataAdmin('legacy', { schema: { a: { type: 'number', min: 1, required: true } } });
251
+ eq('旧扁平格式升级为标准 JSON Schema', legacy.schema().type, 'object');
252
+ eq('旧 min 升级成 minimum', legacy.schema().properties.a.minimum, 1);
253
+ eq('旧 required:true 升级成顶层 required 数组', legacy.schema().required, ['a']);
254
+ throws('升级后约束仍生效', function () { legacy.add({ a: 0 }); }, 'SCHEMA_VALIDATION');
255
+
256
+ // ============ 6. 静态 / 动态集合关联 ============
257
+ group('6. 静态 / 动态集合关联(运行时声明)');
258
+ const item = mm.dataAdmin('item', {
259
+ kind: 'static', key: 'item_id', version: 12,
260
+ schema: standard({ name: { type: 'string' }, price: { type: 'number', default: 0 } }, ['name']),
261
+ seed: [{ item_id: 1001, name: '铁剑', price: 120 }, { item_id: 3001, name: '小红药水', price: 20 }]
262
+ });
263
+ eq('静态集合种子就位', item.size, 2);
264
+ throws('静态集合默认只读', function () { item.add({ name: 'x' }); }, 'READONLY');
265
+ eq('force:true 可写', item.add({ item_id: 9999, name: 'x' }, { force: true }).affected, 1);
266
+
267
+ const bag = mm.dataAdmin('bag', {
268
+ key: 'bag_id',
269
+ schema: standard({
270
+ hero_id: { type: 'number' }, item_id: { type: 'number' },
271
+ quantity: { type: 'number', minimum: 1, default: 1 },
272
+ item_name: { type: 'string', default: '' }, cfg_ver: { type: 'number', default: 0 }
273
+ }, [], false)
274
+ });
275
+ bag.ref('item_id', 'item', { as: 'item_info', select: ['item_id', 'name'] });
276
+ bag.field('item_name', { type: 'string', default: '', snapshot: 'item.name' });
277
+ bag.field('cfg_ver', { type: 'number', default: 0 });
278
+ eq('ref() 写入标准 properties', !!bag.schema().properties.item_id.ref, true);
279
+ const bagRow = bag.add({ hero_id: 1, item_id: 1001, quantity: 2 });
280
+ eq('写时快照冗余静态字段', bagRow.obj.item_name, '铁剑');
281
+ eq('写时钉扎配置版本', bagRow.obj.cfg_ver, 12);
282
+ throws('悬空引用被拒绝', function () { bag.add({ hero_id: 1, item_id: 88888 }); }, 'REF_MISSING');
283
+ eq('with 展开关联', bag.get(bagRow.id, { with: ['item_info'] }).item_info.name, '铁剑');
284
+ eq('select 投影生效', bag.get(bagRow.id, { with: ['item_info'] }).item_info.price, undefined);
285
+
286
+ hero.clear();
287
+ hero.add({ name: '持剑者' });
288
+ hero.add({ name: '法师' });
289
+ bag.add({ hero_id: 1, item_id: 3001, quantity: 5 });
290
+ hero.hasMany('items', { model: 'bag', via: 'hero_id', local: 'hero_id' });
291
+ eq('一对多展开', hero.get(1, { with: ['items'] }).items.length, 2);
292
+ eq('空批量不报错', hero.addMany([]).affected, 0);
293
+
294
+ role.store.calls.list = 0;
295
+ hero.list({}, { limit: -1, with: ['items'] });
296
+ eq('关联展开不产生 N+1(本表 1 次 + 关联 1 次)', role.store.calls.list, 2);
297
+ eq('全局引用完整性', mm.dataAdmin.registry().verify().ok, true);
298
+ eq('集合级引用完整性', bag.verify().ok, true);
299
+ eq('reverse 找到引用者(谁引用了 item 1001)', item.reverse(1001).count >= 1, true);
300
+
301
+ item.reload([
302
+ { item_id: 1001, name: '精铁剑', price: 180 },
303
+ { item_id: 3001, name: '小红药水', price: 20 }
304
+ ], { version: 13 });
305
+ eq('静态集合换版', item.version, 13);
306
+ eq('换版后配置已更新', item.get(1001).name, '精铁剑');
307
+ eq('旧快照不被改版污染', bag.get(bagRow.id).item_name, '铁剑');
308
+
309
+ // ============ 7. CRUD / 查询 / 造数 ============
310
+ group('7. CRUD、查询与批量');
311
+ eq('set 更新', hero.set(2, { level: 30 }).affected, 1);
312
+ throws('写操作必须带条件', function () { hero.set({}, { level: 1 }); }, 'QUERY_REQUIRED');
313
+ eq('allow_all 允许全表', hero.set({}, { title: '骑士' }, { allow_all: true }).affected, 2);
314
+ eq('upsert 新增', hero.upsert({ hero_id: 99 }, { name: '新来的' }).id, 99);
315
+ eq('upsert 更新', hero.upsert({ hero_id: 99 }, { title: '改名' }).affected, 1);
316
+ eq('del 删除', hero.del(99).affected, 1);
317
+ eq('条件查询 $gte', hero.list({ level: { $gte: 30 } }, { limit: -1 }).count, 1);
318
+ eq('$or', hero.list({ $or: [{ name: '持剑者' }, { name: '无此人' }] }).count, 1);
319
+ eq('$in', bag.list({ item_id: { $in: [1001, 3001] } }).count, 2);
320
+ const p1 = hero.list({}, { limit: 1, order: 'hero_id ASC', fields: ['name'] });
321
+ ok('游标存在', p1.next_cursor !== null);
322
+ const p2 = hero.list({}, { limit: 1, order: 'hero_id ASC', fields: ['name'], cursor: p1.next_cursor });
323
+ eq('游标第二页不重复', p2.list[0] && p2.list[0].hero_id !== p1.list[0].hero_id, true);
324
+
325
+ const gen = mm.dataAdmin('log', { generate: { count: 3, template: {
326
+ seq: '{{ $index }}', map_id: '{{ ref:map.map_id }}', rnd: '{{ random(1,9) }}'
327
+ } } });
328
+ eq('generate 造数条数', gen.generate().affected, 3);
329
+ eq('模板 $index', gen.get(1).seq, 0);
330
+ ok('模板 ref 取自真实集合键', [1001, 1002].indexOf(gen.get(1).map_id) > -1);
331
+ ok('模板 random 是数字', typeof gen.get(1).rnd === 'number');
332
+
333
+ // ============ 8. 独立实例池 / 存储可插拔 / 持久化 ============
334
+ group('8. mm_admin 多池隔离 / 自定义 adapter / 持久化');
335
+ const w1 = mm.createPool('w1');
336
+ const w2 = mm.createPool('w2');
337
+ w1.data('role').add({ name: 'A1' });
338
+ eq('不同池的同名集合互不干扰', w2.data('role').size, 0);
339
+ eq('默认池不受影响', mm.dataAdmin('role').size, 2);
340
+ ok('池彼此不同', w1 !== w2);
341
+
342
+ class CountingStore extends S.MemoryStore {
343
+ constructor() { super(); this.queries = 0; }
344
+ list() { this.queries++; return super.list.apply(this, arguments); }
345
+ }
346
+ const cs = new CountingStore();
347
+ const w3 = mm.createPool('w3', { store: cs });
348
+ w3.data('x').add({ v: 1 });
349
+ w3.data('x').list({});
350
+ eq('自定义存储 adapter 被使用', cs.queries >= 1, true);
351
+ eq('adapter 上挂了共享 models', !!cs.models, true);
352
+
353
+ const dir = path.join(os.tmpdir(), 'mm_data_v4_test_' + Date.now());
354
+ const d1 = mm.createPool('disk1', { store: 'json', dir: dir });
355
+ d1.data('role').add({ name: '存档A' });
356
+ d1.data('role').save();
357
+ const d2 = mm.createPool('disk2', { store: 'json', dir: dir });
358
+ const loaded = mm.dataAdmin.registry(d2).load();
359
+ eq('load 恢复表清单', (loaded.table_names || []).indexOf('role') > -1, true);
360
+ eq('load 恢复数据', d2.data('role').get(1).name, '存档A');
361
+ fs.rmSync(dir, { recursive: true, force: true });
362
+
363
+ group('8.1 持久化策略:persist / autoSave / flush_interval');
364
+ const policyDir = path.join(os.tmpdir(), 'mm_data_policy_' + Date.now());
365
+ const manualPool = mm.createPool('policy_manual', { store: 'json', dir: policyDir });
366
+ manualPool.data('role').add({ name: '手动' });
367
+ eq('默认不自动落盘', fs.existsSync(path.join(policyDir, 'role.json')), false);
368
+ eq('persistStatus 标记脏数据', manualPool.persistStatus().dirty, true);
369
+ eq('手动 flushNow 落盘', manualPool.flushNow().backend, 'json');
370
+ eq('flushNow 后文件存在', fs.existsSync(path.join(policyDir, 'role.json')), true);
371
+ eq('落盘后脏标记清除', manualPool.persistStatus().dirty, false);
372
+
373
+ const autoDir = path.join(os.tmpdir(), 'mm_data_policy_auto_' + Date.now());
374
+ const autoPool = mm.createPool('policy_auto', { store: 'json', dir: autoDir, autoSave: true });
375
+ autoPool.data('role').add({ name: '立即' });
376
+ eq('autoSave 写入即落盘', fs.existsSync(path.join(autoDir, 'role.json')), true);
377
+
378
+ const intervalDir = path.join(os.tmpdir(), 'mm_data_policy_interval_' + Date.now());
379
+ const intervalPool = mm.createPool('policy_interval', { store: 'json', dir: intervalDir, flush_interval: 20 });
380
+ intervalPool.data('role').add({ name: '定时' });
381
+ eq('定时未到不落盘', fs.existsSync(path.join(intervalDir, 'role.json')), false);
382
+ await sleep(80);
383
+ eq('定时到点落盘', fs.existsSync(path.join(intervalDir, 'role.json')), true);
384
+ intervalPool.data('role').add({ name: '定时二' });
385
+ intervalPool.close();
386
+ eq('close 收尾落盘', JSON.parse(fs.readFileSync(path.join(intervalDir, 'role.json'), 'utf8')).length, 2);
387
+
388
+ const offDir = path.join(os.tmpdir(), 'mm_data_policy_off_' + Date.now());
389
+ const offPool = mm.createPool('policy_off', { store: 'json', dir: offDir, persist: false, autoSave: true });
390
+ offPool.data('role').add({ name: '不落盘' });
391
+ eq('persist=false 不落盘', fs.existsSync(offDir) && fs.readdirSync(offDir).length > 0, false);
392
+ eq('persist=false 状态', offPool.persistStatus().persist, false);
393
+ fs.rmSync(policyDir, { recursive: true, force: true });
394
+ fs.rmSync(autoDir, { recursive: true, force: true });
395
+ fs.rmSync(intervalDir, { recursive: true, force: true });
396
+
397
+ // ============ 9. 可选示例模型(证明不是写死的) ============
398
+ group('9. RPG 模型仅是可选示例,显式加载才有');
399
+ eq('新池只有自己创建的集合', mm.createPool('empty_probe').data('probe').models().length, 1);
400
+ const preset = mm.createPool('preset', { models: mm.EXAMPLE_MODEL_DIR });
401
+ eq('显式加载示例模型集', preset.data('map').models().length, 15);
402
+ eq('示例静态种子自动就位', preset.data('map').get(1001).name, '晨曦之城');
403
+ eq('示例模型的 schema 是标准文档', preset.data('character').schema().$schema, DRAFT);
404
+ eq('示例动态集合可写(标准 schema)', preset.data('character').add({
405
+ player_id: 1, name: '示例角色', job_id: 1, level: 10, map_id: 1001
406
+ }).affected, 1);
407
+ eq('示例关联展开可用', preset.data('character').get(1, { with: ['job', 'map'] }).job.name, '战士');
408
+ eq('示例完整性', preset.data('character').verify().ok, true);
409
+ eq('示例不污染默认池', mm.dataAdmin.registry().has('character'), false);
410
+ eq('loadModels 不留引导集合', preset.getServer().tableNames().indexOf('__bootstrap__') === -1, true);
411
+ const pdir = path.join(os.tmpdir(), 'mm_data_v4_preset_' + Date.now());
412
+ const pdisk = mm.createPool('preset_disk', { store: 'json', dir: pdir, models: mm.EXAMPLE_MODEL_DIR });
413
+ mm.dataAdmin.registry(pdisk).save();
414
+ eq('示例模型落盘不含引导集合', fs.existsSync(path.join(pdir, '__bootstrap__.json')), false);
415
+ eq('示例模型落盘表数', JSON.parse(fs.readFileSync(path.join(pdir, '_tables.json'), 'utf8')).length, 15);
416
+ fs.rmSync(pdir, { recursive: true, force: true });
417
+
418
+ // ============ 10. 工具面 ============
419
+ group('10. AI / 工作流工具契约');
420
+ const tp = mm.createPool('tool');
421
+ let ctx = {};
422
+ let out = await tool.main({ action: 'add', model: 'role', body: { name: '工具建的' }, admin: tp }, ctx);
423
+ eq('工具 CRUD 自动建集合', out.affected, 1);
424
+ eq('工具写 ctx.output', ctx.output.affected, 1);
425
+ out = await tool.main({ action: 'collection', model: 'role', admin: tp }, {});
426
+ eq('工具 info 返回集合名', out.obj.name, 'role');
427
+ out = await tool.main({ action: 'define', model: 'role', body: { def: {
428
+ schema: standard({ name: { type: 'string' }, level: { type: 'number', minimum: 1 } }, ['name'])
429
+ } }, admin: tp }, {});
430
+ eq('工具定义标准 schema 成功', out.msg, '集合已定义');
431
+ out = await tool.main({ action: 'add', model: 'role', body: { name: 'x', level: -1 }, admin: tp }, {});
432
+ eq('工具写入违反 schema 被拒绝', out.error.code, 'SCHEMA_VALIDATION');
433
+ out = await tool.main({ action: 'validate', model: 'role', body: { name: 'x', level: 5 }, admin: tp }, {});
434
+ eq('工具 validate 通过', out.obj.ok, true);
435
+ out = await tool.main({ action: 'ref', model: 'role', body: { field: 'map_id', target: 'map' }, admin: tp }, {});
436
+ eq('工具运行时声明关联', out.msg, '关联已声明');
437
+ out = await tool.main({ action: 'add', model: 'map', body: { map_id: 7, name: '工具地图' }, admin: tp }, {});
438
+ eq('工具自动建被引用集合', out.affected, 1);
439
+ out = await tool.main({ action: 'get', model: 'role', query: 1, with: ['map'], admin: tp }, {});
440
+ eq('工具 with 空关联为 null', out.obj.map === null || out.obj.map === undefined, true);
441
+ out = await tool.main({ action: 'add', model: 'role', body: { name: 'y', level: 2, map_id: 999 }, admin: tp }, {});
442
+ eq('工具异常格式', out.error.code, 'REF_MISSING');
443
+ eq('listTools 契约扫描', mm.listTools(), ['data']);
444
+ ok('getToolConfig 可读', !!mm.getToolConfig('data'));
445
+ ok('tool.json 描述含 JSON Schema', JSON.stringify(mm.getToolConfig('data')).indexOf('JSON Schema') > -1);
446
+
447
+ // ============ 11. 规则判定确实由 mm_validator 执行 ============
448
+ group('11. 标准 schema → mm_validator 工具调用');
449
+ const V = require('mm_validator');
450
+ const paramsTool = require(path.join(V.TOOL_DIR, 'params'));
451
+ const originalMain = paramsTool.main;
452
+ let spyCalls = 0;
453
+ paramsTool.main = function () { spyCalls++; return originalMain.apply(this, arguments); };
454
+
455
+ const vinfo = mm.validator();
456
+ eq('校验器包名', vinfo.package, 'mm_validator');
457
+ ok('校验器已加载', vinfo.loaded === true);
458
+ ok('mm_validator 工具目录存在', !!vinfo.tool_dir && fs.existsSync(vinfo.tool_dir));
459
+ eq('提供 16 个校验工具', vinfo.available_tools.length, 16);
460
+ ok('引擎所需工具齐全', vinfo.engine_tools.every(function (t) {
461
+ return vinfo.available_tools.indexOf(t) > -1;
462
+ }));
463
+
464
+ const vrole = mm.dataAdmin('v_role', {
465
+ key: 'v_id',
466
+ schema: standard({
467
+ name: { type: 'string', maxLength: 8, pattern: '^[A-Z]' },
468
+ lv: { type: 'number', minimum: 1, maximum: 99 },
469
+ job: { type: 'string', enum: ['warrior', 'mage'] },
470
+ code: { type: 'string', enum: ['A', 'B'], pattern: '^[A-Z]+$' },
471
+ attrs: { type: 'object', properties: { hp: { type: 'number', minimum: 0 } }, required: ['hp'], additionalProperties: false },
472
+ tags: { type: 'array', items: { type: 'string' }, maxItems: 2 }
473
+ }, ['name'])
474
+ });
475
+ const before = spyCalls;
476
+ eq('合法 object 通过', vrole.validate({
477
+ name: 'Arthur', lv: 10, attrs: { hp: 100 }, tags: ['tank']
478
+ }).ok, true);
479
+ ok('校验确实调用了 mm_validator/params', spyCalls > before);
480
+ hasError('maxLength 由 mm_validator 判定', vrole.validate({ name: 'A'.repeat(20) }).errors, '长度不能大于 8');
481
+ hasError('minimum 由 mm_validator 判定', vrole.validate({ name: 'A', lv: 0 }).errors, '不能小于 1');
482
+ hasError('类型错误消息来自 mm_validator', vrole.validate({ name: 'A', lv: '高' }).errors, '类型应为');
483
+ throws('类型不符被拦截', function () { vrole.add({ name: 'A', lv: '高' }); }, 'SCHEMA_VALIDATION');
484
+ throws('枚举不符被拦截', function () { vrole.add({ name: 'A', job: 'thief' }); }, 'SCHEMA_VALIDATION');
485
+ throws('范围越界被拦截', function () { vrole.add({ name: 'A', lv: 1000 }); }, 'SCHEMA_VALIDATION');
486
+ throws('正则不符被拦截', function () { vrole.add({ name: 'abc' }); }, 'SCHEMA_VALIDATION');
487
+
488
+ const blankErrs = vrole.validate({ name: '', lv: 1 }).errors;
489
+ hasError('空串仍被 mm_validator/required 拦截', blankErrs, '为必填项');
490
+ hasError('空串仍被 mm_validator/pattern 补检', blankErrs, '不匹配正则');
491
+ hasError('空串枚举被 mm_validator/enum 补检',
492
+ vrole.validate({ name: 'A', code: '' }).errors, '不在允许范围内');
493
+ hasError('嵌套属性路径保留',
494
+ vrole.validate({ name: 'A', attrs: { hp: 1, evil: 2 } }).errors, 'attrs.evil');
495
+ hasError('数组下标路径保留',
496
+ vrole.validate({ name: 'A', tags: [1] }).errors, 'tags[0]');
497
+
498
+ eq('DataManager.validator() 与模块级一致', vrole.validator().package, 'mm_validator');
499
+ ok('engine_tools 含 params', vrole.validator().engine_tools.indexOf('params') > -1);
500
+ ok('engine_tools 含单项补检工具', vrole.validator().engine_tools.some(function (t) {
501
+ return ['length', 'pattern', 'enum', 'type'].indexOf(t) > -1;
502
+ }));
503
+ out = await tool.main({ action: 'validator' }, {});
504
+ eq('工具 validator 可查询校验器', out.obj.package, 'mm_validator');
505
+ out = await tool.main({ action: 'info', model: 'v_role' }, {});
506
+ eq('工具 info 带校验器信息', out.obj.validator.package, 'mm_validator');
507
+ eq('工具 info 带标准 schema', out.obj.schema.$schema, DRAFT);
508
+ ok('校验器调用计数持续增长', mm.validator().calls > vinfo.calls);
509
+ paramsTool.main = originalMain;
510
+
511
+ // ---- 11. 工具契约:parameters 对齐 OpenAI function calling ----
512
+ console.log('\n--- 11. 工具契约对齐 OpenAI 工具格式 ---');
513
+ const contract = JSON.parse(fs.readFileSync(path.join(__dirname, 'tool', 'data', 'tool.json'), 'utf8'));
514
+ eq('type 保持工作流通道 data', contract.type, 'data');
515
+ ok('顶层 parameters 存在', !!contract.parameters);
516
+ eq('parameters.type 为 object', contract.parameters.type, 'object');
517
+ ok('parameters.properties 存在', !!contract.parameters.properties);
518
+ ok('parameters.required 为数组', Array.isArray(contract.parameters.required));
519
+ eq('params 与 parameters 同源', contract.params, contract.parameters);
520
+ const privateKeys = ['handler', 'title', 'group', 'returns', 'options', 'params', 'name'];
521
+ ok('parameters 不含仓库私有字段', privateKeys.every(function (k) {
522
+ return !(k in contract.parameters);
523
+ }));
524
+ for (const pf in contract.parameters.properties) {
525
+ const pd = contract.parameters.properties[pf];
526
+ ok('字段 ' + pf + ' 带 type', typeof pd.type === 'string');
527
+ ok('字段 ' + pf + ' 带 description', typeof pd.description === 'string' && pd.description.length > 0);
528
+ }
529
+ function scanBadTypes(o, bad) {
530
+ if (!o || typeof o !== 'object') return bad;
531
+ if (typeof o.type === 'string' && ['integer', 'int', 'any', 'float'].indexOf(o.type) > -1) bad.push(o.type);
532
+ for (const k in o) if (o[k] && typeof o[k] === 'object') scanBadTypes(o[k], bad);
533
+ return bad;
534
+ }
535
+ eq('parameters 无 int/integer 类型', scanBadTypes(contract.parameters, []), []);
536
+ const fnTool = mm.getFunctionTool('data');
537
+ eq('function 工具定义 type', fnTool.type, 'function');
538
+ eq('function.name', fnTool.function.name, 'data');
539
+ ok('function.description 非空', fnTool.function.description.length > 0);
540
+ eq('function.parameters 与契约同源', fnTool.function.parameters, contract.parameters);
541
+ eq('function 视图只含标准三字段', Object.keys(fnTool.function).sort(), ['description', 'name', 'parameters']);
542
+ eq('listFunctionTools 含 data', mm.listFunctionTools().map(function (t) {
543
+ return t.function.name;
544
+ }), ['data']);
545
+ const cfgView = mm.getToolConfig('data');
546
+ ok('getToolConfig 同时带 parameters/params', !!cfgView.parameters && !!cfgView.params);
547
+ out = await tool.main({ action: 'add', model: 'llm_probe', body: { name: 'LLM' } }, {});
548
+ eq('OpenAI 顶层参数可直接调用', out.affected, 1);
549
+
550
+ // ============ v5:*_model.json / 目录布局 / 外部依赖 ============
551
+ group('v5 模型文件决定集合');
552
+ const mfiles = mm.modelFiles(mm.EXAMPLE_MODEL_DIR);
553
+ eq('15 个规范模型文件', mfiles.length, 15);
554
+ ok('全部以 _model.json 结尾', mfiles.every(function (f) { return /_model\.json$/i.test(f.file); }));
555
+ eq('文件名推导集合名', mfiles.map(function (f) { return f.name; }).sort(), [
556
+ 'bag', 'character', 'character_skill', 'drop', 'item', 'job', 'level_exp',
557
+ 'map', 'map_state', 'monster', 'npc', 'quest', 'quest_progress', 'save', 'skill'
558
+ ].sort());
559
+ const v5modelPool = mm.createPool('v5_models', {
560
+ models: mm.EXAMPLE_MODEL_DIR, dir: path.join(os.tmpdir(), 'mm_data_v5_models')
561
+ });
562
+ eq('文件数 == 集合数', mm.dataAdmin.registry(v5modelPool).models().length, mfiles.length);
563
+
564
+ const legacyDir = path.join(os.tmpdir(), 'mm_data_legacy_' + Date.now());
565
+ fs.mkdirSync(legacyDir, { recursive: true });
566
+ fs.writeFileSync(path.join(legacyDir, 'a.json'), JSON.stringify({ key: 'id' }));
567
+ fs.writeFileSync(path.join(legacyDir, 'b.json'), JSON.stringify({ key: 'id' }));
568
+ eq('兼容旧命名 *.json', mm.modelFiles(legacyDir).map(function (f) { return f.name; }), ['a', 'b']);
569
+
570
+ const deps = require('./package.json').dependencies;
571
+ ok('package.json 声明依赖',
572
+ !!(deps.mm_cache && deps.mm_sql && deps.mm_mongodb && deps.mm_jsondb) &&
573
+ !!deps.mm_admin && !!deps.mm_validator);
574
+ eq('probe 返回四字段', Object.keys(mm.probe()).sort(),
575
+ ['mm_cache', 'mm_jsondb', 'mm_mongodb', 'mm_sql']);
576
+ ok('mm_cache 可解析', mm.probe().mm_cache === true);
577
+ ok('mm_jsondb 可解析', mm.probe().mm_jsondb === true);
578
+
579
+ group('v5 静态逐文件 / 动态缓存+持久');
580
+ const MODEL_DIR = path.join(__dirname, 'example', 'model');
581
+ const v5dir = path.join(os.tmpdir(), 'mm_data_v5_store');
582
+ const v5dir2 = path.join(os.tmpdir(), 'mm_data_v5_fallback');
583
+ const mem = new Map();
584
+ const mongoClient = {
585
+ async set(k, v) { mem.set(k, v); return 1; },
586
+ async get(k) { return mem.has(k) ? mem.get(k) : null; }
587
+ };
588
+ const v5 = mm.createPool('v5_store', {
589
+ store: 'hybrid', dir: v5dir, models: MODEL_DIR, mongodb: { client: mongoClient }
590
+ });
591
+ const reg5 = mm.dataAdmin.registry(v5);
592
+ eq('5 个 *_model.json = 5 种集合', reg5.models().length, 5);
593
+ const saved5 = reg5.save();
594
+ eq('save 后端', saved5.backend, 'hybrid');
595
+ eq('静态文件数', saved5.static_files, 10);
596
+ ok('data/role/000001.json 生成', fs.existsSync(path.join(v5dir, 'role', '000001.json')));
597
+ eq('000001.json 内容', JSON.parse(fs.readFileSync(path.join(v5dir, 'role', '000001.json'), 'utf8')).name, '战士');
598
+ eq('data/role 三个文件', fs.readdirSync(path.join(v5dir, 'role')).sort(),
599
+ ['000001.json', '000002.json', '000003.json']);
600
+ ok('动态集合不生成逐条文件', !fs.existsSync(path.join(v5dir, 'player', '000001.json')));
601
+ eq('每种模型一个目录', fs.readdirSync(v5dir, { withFileTypes: true })
602
+ .filter(function (e) { return e.isDirectory(); }).length, 5);
603
+
604
+ const player5 = v5.data('player');
605
+ const added5 = player5.add({ name: '亚瑟', role_id: 1, map_id: 1, level: 10 });
606
+ eq('动态新增主键', added5.id, 1);
607
+ eq('关联展开', player5.get(1, { with: ['role', 'map'] }).role.name, '战士');
608
+
609
+ const conn5 = await v5.connect();
610
+ ok('mm_cache 已连接', conn5.cache.connected === true);
611
+ ok('mm_mongodb 注入客户端可用', conn5.mongodb.connected === true);
612
+ eq('后端报告含三适配器', Object.keys(v5.backends().adapters).sort(), ['cache', 'mongodb', 'sql']);
613
+ eq('connect 报告文件层', conn5.file_layer.backend, 'mm_jsondb');
614
+ eq('backends 文件层', v5.backends().file_layer.backend, 'mm_jsondb');
615
+ eq('文件层库目录归一', v5.backends().file_layer.database, '.');
616
+ const flush5 = await v5.flush();
617
+ eq('flush 静态文件', flush5.static_files, 10);
618
+ eq('flush 写入 mongodb', flush5.mongodb, 1);
619
+ eq('flush 缓存集合', flush5.cache, 1);
620
+ ok('动态本地快照', fs.existsSync(path.join(v5dir, 'player', '_rows.json')));
621
+
622
+ // v5.1:异步主路径全量走 mm_jsondb,输出仍是 000001.json 且行数据字段原样
623
+ const jsondbRow = JSON.parse(fs.readFileSync(path.join(v5dir, 'role', '000001.json'), 'utf8'));
624
+ eq('mm_jsondb 落盘主键不丢失', jsondbRow.role_id, 1);
625
+ eq('mm_jsondb 不注入 id 字段', Object.prototype.hasOwnProperty.call(jsondbRow, 'id'), false);
626
+ eq('mm_jsondb 目录只有行文件', fs.readdirSync(path.join(v5dir, 'role')).sort(),
627
+ ['000001.json', '000002.json', '000003.json']);
628
+ ok('mm_jsondb 未生成 _meta.json', !fs.existsSync(path.join(v5dir, 'role', '_meta.json')));
629
+ ok('mm_jsondb 未生成 _index/', !fs.existsSync(path.join(v5dir, 'role', '_index')));
630
+
631
+ const c1 = await player5.cacheGet(1);
632
+ await player5.cacheGet(1);
633
+ eq('cacheGet 返回数据', c1.name, '亚瑟');
634
+ ok('cacheGet 命中缓存', v5.backends().adapters.cache.stats.hit >= 1);
635
+ ok('invalidateCache 生效', (await player5.invalidateCache()) > 0);
636
+
637
+ const v5b = mm.createPool('v5_store_restore', {
638
+ store: 'hybrid', dir: v5dir, models: MODEL_DIR, mongodb: { client: mongoClient }
639
+ });
640
+ eq('恢复前动态表为空', v5b.data('player').size, 0);
641
+ await v5b.connect();
642
+ const rr = await v5b.restore();
643
+ eq('恢复集合数', rr.table_names.length, 5);
644
+ eq('动态数据来源 mm_mongodb', rr.sources.player, 'mm_mongodb');
645
+ eq('静态数据来源 mm_jsondb', rr.sources.role, 'mm_jsondb');
646
+ eq('恢复玩家', v5b.data('player').get(1).name, '亚瑟');
647
+ eq('恢复静态配置', v5b.data('role').get(1).name, '战士');
648
+ ok('恢复后引用完整', v5b.data('player').verify().ok === true);
649
+
650
+ const v5c = mm.createPool('v5_fallback', { store: 'hybrid', dir: v5dir2, models: MODEL_DIR });
651
+ await v5c.connect();
652
+ eq('未启用 mm_mongodb', v5c.backends().adapters.mongodb.enabled, false);
653
+ const f3 = await v5c.flush();
654
+ eq('依赖不可用时回退本地文件', f3.file_fallback, 1);
655
+ const rr3 = await v5c.restore();
656
+ eq('降级恢复来源', rr3.sources.player, 'local-snapshot');
657
+ ok('降级后集合仍完整', rr3.table_names.length === 5);
658
+
659
+ group('v5.1 mm_jsondb 文件层 / 降级');
660
+ const B = require('./lib/backend.js');
661
+ const jl = new B.JsonDbLayout(v5dir);
662
+ eq('文件层绑定 mm_jsondb', jl.backend, 'mm_jsondb');
663
+ eq('文件层集合目录', jl.collectionDir('role'), path.join(v5dir, 'role'));
664
+ eq('文件层补零命名', jl.fileFor('role', 12), path.join(v5dir, 'role', '000012.json'));
665
+ eq('补零由 mm_jsondb 负责', jl.nativePad, true);
666
+ eq('文件层报告 pad 宽度', jl.status().pad, 6);
667
+ eq('非数字 id 不补零', jl.fileFor('role', '_rows'), path.join(v5dir, 'role', '_rows.json'));
668
+ eq('backends 文件层 pad', v5.backends().file_layer.pad, 6);
669
+
670
+ // 模拟 mm_jsondb 1.1.x(无 pad 配置):适配层兜底补零,输出格式不变
671
+ const jdirOld = path.join(os.tmpdir(), 'mm_data_jsondb_oldpad_' + Date.now());
672
+ const jlOld = new B.JsonDbLayout(jdirOld);
673
+ jlOld.nativePad = false;
674
+ eq('老版本适配层兜底命名', jlOld.fileFor('role', 5), path.join(jdirOld, 'role', '000005.json'));
675
+ await jlOld.flushStatic('role', 'role_id', [{ role_id: 9, name: '老版本' }]);
676
+ ok('老版本 flush 仍补零', fs.existsSync(path.join(jdirOld, 'role', '000009.json')));
677
+
678
+ const jdir = path.join(os.tmpdir(), 'mm_data_jsondb_direct_' + Date.now());
679
+ const jl2 = new B.JsonDbLayout(jdir);
680
+ await jl2.flushStatic('role', 'role_id', [{ role_id: 7, name: '游侠' }]);
681
+ await jl2.flushDynamic('player', [{ id: 1, name: '亚瑟' }]);
682
+ eq('直接 flushStatic 输出 000007.json',
683
+ JSON.parse(fs.readFileSync(path.join(jdir, 'role', '000007.json'), 'utf8')).name, '游侠');
684
+ const restoredRows = await jl2.restore(function () {}, jdir);
685
+ eq('异步 restore 列出两种集合', restoredRows.table_names.sort(), ['player', 'role']);
686
+
687
+ // 依赖缺失时同步 / 异步都回退到 fs 实现,且输出格式不变
688
+ const jdir2 = path.join(os.tmpdir(), 'mm_data_jsondb_fallback_' + Date.now());
689
+ const jl3 = new B.JsonDbLayout(jdir2);
690
+ jl3.mod = null;
691
+ jl3._bind(jdir2);
692
+ eq('依赖缺失回退 fs', jl3.backend, 'fs-fallback');
693
+ eq('降级 flushStatic', await jl3.flushStatic('role', 'role_id', [{ role_id: 3, name: '骑士' }]), 1);
694
+ eq('降级仍输出 000003.json',
695
+ JSON.parse(fs.readFileSync(path.join(jdir2, 'role', '000003.json'), 'utf8')).name, '骑士');
696
+
697
+ group('v5.3 四个依赖统一走 xxxAdmin / mm_sql way:jsondb');
698
+ const cacheAdmin = require('mm_cache').cacheAdmin;
699
+ const sqlAdmin = require('mm_sql').sqlAdmin;
700
+ const jsondbAdmin = require('mm_jsondb').jsondbAdmin;
701
+ const b5 = v5.backends();
702
+ eq('缓存经 cacheAdmin', b5.adapters.cache.factory, 'cacheAdmin');
703
+ eq('SQL 经 sqlAdmin', b5.adapters.sql.factory, 'sqlAdmin');
704
+ eq('文件层经 jsondbAdmin', b5.file_layer.factory, 'jsondbAdmin');
705
+ eq('注入客户端不冒充 mongodbAdmin', b5.adapters.mongodb.factory, 'injected-client');
706
+ eq('未注入时 mongodb 声明 mongodbAdmin',
707
+ new B.MongoAdapter({ scope: 'mm_datas:mongo_scope_probe' }).status().factory, 'mongodbAdmin');
708
+
709
+ // 池返回的实例与 xxxAdmin 直接取到的是同一个对象,证明确实经 mm_admin 实例池
710
+ ok('cacheAdmin 同一实例',
711
+ cacheAdmin(b5.adapters.cache.scope, { way: 'memory' }) === v5.getServer().adapters.cache.client);
712
+ ok('jsondbAdmin 同一实例',
713
+ jsondbAdmin(jl._scope(), { dir: v5dir, database: '.', pad: 6 }) === jl.db);
714
+
715
+ const sqlScope = 'mm_datas:sqladmin_probe';
716
+ const sa = new B.SqlAdapter({
717
+ enabled: true, scope: sqlScope, db_type: 'sqlite',
718
+ sqlite: { dir: path.join(os.tmpdir(), 'mm_data_sqladmin_probe'), database: 'p' }
719
+ });
720
+ ok('sqlAdmin 方式可连接', (await sa.open()).connected === true);
721
+ ok('sqlAdmin 同一实例', sqlAdmin(sqlScope, sa.config) === sa.client);
722
+ ok('sqlAdmin 方式可查询', (await sa.query('SELECT 1')) !== null);
723
+ try { await sa.client.close(); } catch (e) { /* 适配器已关闭则忽略 */ }
724
+
725
+ ok('文件层 scope 按命名空间隔离',
726
+ new B.JsonDbLayout(v5dir, 'nsA')._scope() !== new B.JsonDbLayout(v5dir, 'nsB')._scope());
727
+ ok('文件层 scope 按目录隔离',
728
+ new B.JsonDbLayout(v5dir)._scope() !== new B.JsonDbLayout(jdir)._scope());
729
+
730
+ // mm_sql 主名称改为 way:jsondb,旧称 way:json / config.json 仍兼容
731
+ const { Sql } = require('mm_sql');
732
+ const sqlCanonical = new Sql({ name: 'way_canonical_probe', way: 'jsondb', jsondb: { dir: jdir, database: 'p' } });
733
+ eq('mm_sql 主名称 way:jsondb', sqlCanonical.config.way, 'jsondb');
734
+ const sqlAlias = new Sql({ name: 'way_alias_probe', way: 'json', json: { dir: jdir, database: 'p' } });
735
+ eq('mm_sql 旧称 way:json 归一', sqlAlias.config.way, 'jsondb');
736
+ eq('mm_sql config.json 归一为 jsondb', sqlAlias.config.jsondb.database, 'p');
737
+
738
+ console.log('\n========================================');
739
+ console.log(' 通过 ' + pass + ' / ' + (pass + fail) + (fail ? ',失败 ' + fail + ' 项: ' + fails.join(', ') : ',全部通过'));
740
+ console.log('========================================');
741
+ if (fail) process.exitCode = 1;
742
+ }
743
+
744
+ run().catch(function (e) {
745
+ console.error('\n测试异常终止: ' + (e.code || 'ERROR') + ' - ' + e.message);
746
+ console.error(e.stack);
747
+ process.exitCode = 1;
748
+ });