mm_datas 5.3.0 → 5.3.2

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.
@@ -0,0 +1,112 @@
1
+ 'use strict';
2
+
3
+ const { cacheAdmin } = require('mm_cache');
4
+ const { decode, encode } = require('./backend_codec.js');
5
+
6
+ /**
7
+ * mm_cache 适配器:热数据 / 查询结果缓存,默认 memory 方式
8
+ */
9
+ class CacheAdapter {
10
+ /**
11
+ * 构造函数
12
+ * @param {object} [config] 适配器配置(scope/way/ttl/enabled)
13
+ */
14
+ constructor(config) {
15
+ this.name = 'mm_cache';
16
+ this.config = Object.assign({ scope: 'mm_datas', way: 'memory', ttl: 0 }, config || {});
17
+ this.enabled = !!(config && config.enabled !== false);
18
+ this.connected = false;
19
+ this.reason = '';
20
+ this.client = null;
21
+ this.factory = 'cacheAdmin';
22
+ this.stats = { hit: 0, miss: 0, set: 0, del: 0 };
23
+ }
24
+
25
+ /** 未连接即报错,不提供进程内替代实现 */
26
+ _client() {
27
+ if (!this.connected) throw new Error('mm_cache 未连接,请先调用 connect()');
28
+ return this.client;
29
+ }
30
+
31
+ /**
32
+ * 连接缓存客户端
33
+ * @returns {Promise<object>} 状态信息
34
+ * @throws {Error} 连接失败时抛出
35
+ */
36
+ async open() {
37
+ if (!this.enabled) { this.reason = '已禁用'; return this.status(); }
38
+ let client = cacheAdmin(this.config.scope, this.config);
39
+ let ok = await client.connect();
40
+ if (ok === false) throw new Error('mm_cache 连接失败');
41
+ this.client = client;
42
+ this.connected = true;
43
+ return this.status();
44
+ }
45
+
46
+ /**
47
+ * 获取状态信息
48
+ * @returns {object} 状态信息
49
+ */
50
+ status() {
51
+ return {
52
+ name: this.name, enabled: this.enabled, factory: this.factory,
53
+ scope: this.config.scope, connected: this.connected,
54
+ way: this.config.way, reason: this.reason, stats: this.stats
55
+ };
56
+ }
57
+
58
+ /**
59
+ * 取缓存值
60
+ * @param {string} key 缓存键
61
+ * @returns {Promise<*>} 缓存值,未命中为 null
62
+ */
63
+ async get(key) {
64
+ let value = await this._client().get(key);
65
+ if (value !== null && value !== undefined) {
66
+ this.stats.hit++;
67
+ return decode(value);
68
+ }
69
+ this.stats.miss++;
70
+ return null;
71
+ }
72
+
73
+ /**
74
+ * 写缓存值
75
+ * @param {string} key 缓存键
76
+ * @param {*} value 缓存值
77
+ * @param {number} [ttl] 过期秒数,缺省用配置 ttl
78
+ * @returns {Promise<boolean>} 写入成功
79
+ */
80
+ async set(key, value, ttl) {
81
+ let seconds = ttl === undefined ? this.config.ttl : ttl;
82
+ await this._client().set(key, encode(value), seconds);
83
+ this.stats.set++;
84
+ return true;
85
+ }
86
+
87
+ /**
88
+ * 删除缓存键
89
+ * @param {string} key 缓存键
90
+ * @returns {Promise<boolean>} 删除成功
91
+ */
92
+ async del(key) {
93
+ await this._client().del(key);
94
+ this.stats.del++;
95
+ return true;
96
+ }
97
+
98
+ /**
99
+ * 清空前缀匹配的缓存键
100
+ * @param {string} prefix 键前缀
101
+ * @returns {Promise<number>} 清空条数
102
+ */
103
+ async clearPrefix(prefix) {
104
+ let client = this._client();
105
+ let keys = await client.keys(prefix + '*');
106
+ let list = Array.isArray(keys) ? keys : [];
107
+ await Promise.all(list.map(function (key) { return client.del(key); }));
108
+ return list.length;
109
+ }
110
+ }
111
+
112
+ module.exports = CacheAdapter;
@@ -0,0 +1,19 @@
1
+ 'use strict';
2
+
3
+ /**
4
+ * 数据错误:核心 API 抛异常,工具适配层捕获后转成 { error: { code, message } }
5
+ */
6
+ class DataError extends Error {
7
+ /**
8
+ * 构造函数
9
+ * @param {string} code 错误码(见 errors.js CODES)
10
+ * @param {string} message 错误信息
11
+ */
12
+ constructor(code, message) {
13
+ super(message);
14
+ this.name = 'DataError';
15
+ this.code = code;
16
+ }
17
+ }
18
+
19
+ module.exports = DataError;
package/lib/errors.js CHANGED
@@ -1,20 +1,21 @@
1
1
  'use strict';
2
2
 
3
+ const DataError = require('./data_error.js');
4
+
3
5
  /**
4
- * 数据错误:核心 API 抛异常,工具适配层捕获后转成 { error: { code, message } }
6
+ * 抛出带错误码的 DataError
7
+ * @param {string} code 错误码(见 CODES)
8
+ * @param {string} message 错误信息
9
+ * @throws {DataError} 总是抛出
5
10
  */
6
- class DataError extends Error {
7
- constructor(code, message) {
8
- super(message);
9
- this.name = 'DataError';
10
- this.code = code;
11
- }
12
- }
13
-
14
11
  function raise(code, message) {
15
12
  throw new DataError(code, message);
16
13
  }
17
14
 
15
+ /**
16
+ * 错误码表
17
+ * @type {Object<string, string>}
18
+ */
18
19
  const CODES = {
19
20
  MODEL_NOT_FOUND: '模型未注册',
20
21
  MODEL_DUPLICATE: '模型重复定义',
@@ -32,4 +33,4 @@ const CODES = {
32
33
  SCHEMA_TYPE_UNSUPPORTED: 'schema 使用了不支持的类型'
33
34
  };
34
35
 
35
- module.exports = { DataError, raise, CODES };
36
+ module.exports = { raise, CODES };
@@ -0,0 +1,225 @@
1
+ 'use strict';
2
+
3
+ const fs = require('fs');
4
+ const path = require('path');
5
+ const MemoryStore = require('./memory_store.js');
6
+ const B = require('./backend.js');
7
+
8
+ /**
9
+ * v5 默认布局:每种模型对应 data/ 下的一个目录
10
+ * - kind:static → data/<name>/000001.json(一条记录一个文件,主键 6 位补零)
11
+ * - kind:dynamic → mm_cache 缓存 + 本地文件快照;显式启用 mm_mongodb / mm_sql 后
12
+ * 再同步一份外部副本,连接或调用失败直接抛错
13
+ *
14
+ * 同步 CRUD 始终走内存工作集(MemoryStore),外部依赖只在显式异步入口调用:
15
+ * connect() / flush() / restore() / cacheGet() / cacheList()。
16
+ */
17
+ class HybridStore extends MemoryStore {
18
+ /**
19
+ * 构造函数
20
+ * @param {object} [config] 配置(dir/persist/auto_save/flush_interval/namespace/cache/mongodb/sql)
21
+ */
22
+ constructor(config) {
23
+ super();
24
+ config = config || {};
25
+ this.dir = config.dir || path.join(process.cwd(), 'data');
26
+ this.backend = 'hybrid';
27
+ this.persist = config.persist !== false;
28
+ this.auto_save = !!config.auto_save;
29
+ this.flush_interval = Math.max(0, Number(config.flush_interval) || 0);
30
+ this.namespace = config.namespace || 'mm_datas';
31
+ // 文件层也走 jsondbAdmin 实例池,scope 需带上命名空间与目录
32
+ this.layout = new B.JsonDbLayout(this.dir, this.namespace);
33
+ this.adapters = B.createAdapters(config);
34
+ }
35
+
36
+ /**
37
+ * 取模型定义
38
+ * @param {string} name 模型名
39
+ * @returns {object|null} 模型定义
40
+ * @private
41
+ */
42
+ _model(name) { return this.models ? this.models.get(name) : null; }
43
+
44
+ /**
45
+ * 取集合数据类别:落盘只分两类,static → 逐文件;其余(dynamic / link / 未定义)→ 缓存 + 持久
46
+ * @param {string} name 集合名
47
+ * @returns {string} 'static' 或 'dynamic'
48
+ * @private
49
+ */
50
+ _kind(name) { let m = this._model(name); return m && m.kind === 'static' ? 'static' : 'dynamic'; }
51
+
52
+ /**
53
+ * 取主键字段名
54
+ * @param {string} name 集合名
55
+ * @returns {string} 主键字段名
56
+ * @private
57
+ */
58
+ _key(name) { let m = this._model(name); return m ? m.key : 'id'; }
59
+
60
+ /**
61
+ * 同步落盘:静态逐文件 + 动态整表快照(不触碰外部依赖)
62
+ * @param {string} [dir] 数据目录,传入时更新实例目录
63
+ * @returns {object} 保存结果
64
+ */
65
+ save(dir) {
66
+ if (dir) { this.dir = dir; this.layout._bind(dir); }
67
+ fs.mkdirSync(this.dir, { recursive: true });
68
+ let names = this.tableNames().filter(function (n) { return n.charAt(0) !== '_'; });
69
+ let staticFiles = 0;
70
+ let dynamicFiles = 0;
71
+ for (let i = 0; i < names.length; i++) {
72
+ let name = names[i];
73
+ let rows = this.getRows(name);
74
+ if (this._kind(name) === 'static') {
75
+ staticFiles += this.layout.saveStatic(name, this._key(name), rows);
76
+ } else {
77
+ dynamicFiles += this.layout.saveDynamic(name, rows);
78
+ }
79
+ }
80
+ this.dirty = false;
81
+ return {
82
+ ok: true, backend: 'hybrid', dir: this.dir, tables: names.length,
83
+ table_names: names, static_files: staticFiles, dynamic_snapshots: dynamicFiles
84
+ };
85
+ }
86
+
87
+ /**
88
+ * 从 data/ 下的模型目录恢复;动态集合可被 mm_mongodb / mm_sql 覆盖
89
+ * @param {Array} [modelNames] 模型名列表
90
+ * @param {string} [dir] 数据目录,传入时更新实例目录
91
+ * @returns {object} 恢复结果
92
+ */
93
+ load(modelNames, dir) {
94
+ let that = this;
95
+ let res = this.layout.load(function (name, rows) { that.setTable(name, rows); }, dir);
96
+ if (dir) this.dir = dir;
97
+ // 以模型定义为准修正 kind(模型先于数据恢复装载)
98
+ if (res.collections) {
99
+ for (let i = 0; i < res.collections.length; i++) {
100
+ res.collections[i].kind = this._kind(res.collections[i].name);
101
+ }
102
+ }
103
+ return res;
104
+ }
105
+
106
+ /**
107
+ * 显式连接已启用的外部数据源;连接失败直接抛错
108
+ * @returns {Promise<object>} 各数据源状态
109
+ */
110
+ async connect() {
111
+ let out = await B.openAll(this.adapters);
112
+ out.file_layer = await this.layout.open();
113
+ return out;
114
+ }
115
+
116
+ /**
117
+ * 获取后端状态
118
+ * @returns {object} 状态信息
119
+ */
120
+ backends() {
121
+ return {
122
+ backend: 'hybrid', dir: this.dir,
123
+ // 文件层单独报告,不塞进 adapters 以免破坏既有三适配器的契约
124
+ file_layer: this.layout.status(),
125
+ adapters: {
126
+ cache: this.adapters.cache.status(),
127
+ mongodb: this.adapters.mongo.status(),
128
+ sql: this.adapters.sql.status()
129
+ }
130
+ };
131
+ }
132
+
133
+ /**
134
+ * 把内存工作集推到外部层:静态逐文件、动态缓存 + 本地快照 + 已启用的数据源
135
+ * @returns {Promise<object>} 推送报告
136
+ */
137
+ async flush() {
138
+ let report = {
139
+ ok: true, static_files: 0, cache: 0, mongodb: 0, sql: 0,
140
+ snapshots: 0, collections: []
141
+ };
142
+ let names = this.tableNames().filter(function (n) { return n.charAt(0) !== '_'; });
143
+ for (let i = 0; i < names.length; i++) {
144
+ let name = names[i];
145
+ let rows = this.getRows(name);
146
+ let one = { name: name, kind: this._kind(name), rows: rows.length };
147
+ if (one.kind === 'static') {
148
+ one.files = await this.layout.flushStatic(name, this._key(name), rows);
149
+ report.static_files += one.files;
150
+ } else {
151
+ await this.adapters.cache.set('rows:' + this.namespace + ':' + name, rows);
152
+ report.cache++;
153
+ // 本地快照与外部数据源的推送相互独立,并行执行以缩短整体耗时
154
+ let ext_jobs = [this.layout.flushDynamic(name, rows)];
155
+ if (this.adapters.mongo.enabled) {
156
+ ext_jobs.push(this.adapters.mongo.push(name, rows).then(function (pushed) {
157
+ if (pushed.ok) { report.mongodb++; one.mongodb = true; }
158
+ }));
159
+ }
160
+ if (this.adapters.sql.enabled) {
161
+ ext_jobs.push(this.adapters.sql.push(name, this._key(name), rows).then(function (sql) {
162
+ if (sql.ok) { report.sql++; one.sql = sql.table; }
163
+ }));
164
+ }
165
+ await Promise.all(ext_jobs);
166
+ report.snapshots++;
167
+ }
168
+ report.collections.push(one);
169
+ }
170
+ return report;
171
+ }
172
+
173
+ /**
174
+ * 恢复:集合清单以模型定义为准(目录里可能没有动态集合),
175
+ * 先读 data/ 下的静态逐文件与动态快照,再用已连接的数据源覆盖动态集合。
176
+ * @param {string} [dir] 数据目录,传入时更新实例目录
177
+ * @returns {Promise<object>} 恢复报告
178
+ */
179
+ async restore(dir) {
180
+ let that = this;
181
+ let loaded = await this.layout.restore(function (name, rows) { that.setTable(name, rows); }, dir);
182
+ if (dir) this.dir = dir;
183
+ // 以模型定义为准修正 kind(模型先于数据恢复装载)
184
+ if (loaded.collections) {
185
+ for (let i = 0; i < loaded.collections.length; i++) {
186
+ loaded.collections[i].kind = this._kind(loaded.collections[i].name);
187
+ }
188
+ }
189
+ let names = this.models ? Array.from(this.models.keys()) : [];
190
+ for (let i = 0; i < loaded.table_names.length; i++) {
191
+ if (names.indexOf(loaded.table_names[i]) === -1) names.push(loaded.table_names[i]);
192
+ }
193
+ names.sort();
194
+ let sources = {};
195
+ for (let i = 0; i < names.length; i++) {
196
+ let name = names[i];
197
+ if (this._kind(name) !== 'dynamic') {
198
+ sources[name] = 'mm_jsondb';
199
+ continue;
200
+ }
201
+ // 外部数据源按优先级覆盖:mongodb > sql > 文件快照(快照是主存储,不算回退)
202
+ let rows = null;
203
+ let source = 'file-snapshot';
204
+ if (this.adapters.mongo.connected) {
205
+ rows = await this.adapters.mongo.pull(name);
206
+ if (Array.isArray(rows)) source = 'mm_mongodb';
207
+ }
208
+ if (!Array.isArray(rows) && this.adapters.sql.connected) {
209
+ rows = await this.adapters.sql.pull(name);
210
+ if (Array.isArray(rows)) source = 'mm_sql';
211
+ }
212
+ if (Array.isArray(rows)) {
213
+ this.setTable(name, rows);
214
+ sources[name] = source;
215
+ } else {
216
+ if (loaded.table_names.indexOf(name) === -1) this.setTable(name, []);
217
+ sources[name] = 'file-snapshot';
218
+ }
219
+ }
220
+ this.seq.clear();
221
+ return { ok: true, backend: 'hybrid', dir: this.dir, table_names: names, sources: sources };
222
+ }
223
+ }
224
+
225
+ module.exports = HybridStore;
@@ -0,0 +1,266 @@
1
+ 'use strict';
2
+
3
+ const fs = require('fs');
4
+ const path = require('path');
5
+ const crypto = require('crypto');
6
+ const { jsondbAdmin } = require('mm_jsondb');
7
+
8
+ /**
9
+ * 静态数据目录布局:data/<集合名>/000001.json
10
+ * 动态数据快照:data/<集合名>/_rows.json(整表快照)
11
+ *
12
+ * 文件 I/O 全部委托 mm_jsondb 的 Store 文件层:
13
+ * database:'.' 归一化掉库目录层,pad:6 由 Store 负责补零,
14
+ * 适配层只传原始主键即可得到 000001.json 且字段原样。
15
+ * 同步 save()/load() 使用 fs 同步 I/O,异步 flush()/restore() 走 Store 的异步接口。
16
+ */
17
+ class JsonDbLayout {
18
+ /**
19
+ * 构造函数
20
+ * @param {string} [dir] 数据根目录,缺省为运行目录下 data
21
+ * @param {string} [namespace] 命名空间,用于实例池隔离
22
+ */
23
+ constructor(dir, namespace) {
24
+ this.dir = dir || path.join(process.cwd(), 'data');
25
+ this.namespace = namespace || 'mm_datas';
26
+ this.backend = 'mm_jsondb';
27
+ this.factory = 'jsondbAdmin';
28
+ this._bind(this.dir);
29
+ }
30
+
31
+ /** 实例池 scope:同一「命名空间 + 目录」复用实例,不同目录不串库 */
32
+ _scope() {
33
+ let key = this.namespace + '|' + this.dir;
34
+ let hash = crypto.createHash('sha1').update(key).digest('hex').slice(0, 16);
35
+ return 'mm_datas:jsondb:' + hash;
36
+ }
37
+
38
+ /**
39
+ * 绑定 mm_jsondb 实例
40
+ * @param {string} [dir] 数据根目录
41
+ * @throws {Error} mm_jsondb 未提供 Store 文件层或版本过低时抛出
42
+ * @private
43
+ */
44
+ _bind(dir) {
45
+ this.dir = dir || this.dir;
46
+ let db = jsondbAdmin(this._scope(),
47
+ { dir: this.dir, database: '.', pad: 6 });
48
+ let store = db.getStore();
49
+ if (!store || typeof store._getTableDir !== 'function' || typeof store.writeRow !== 'function') {
50
+ throw new Error('mm_jsondb 未提供 Store 文件层');
51
+ }
52
+ if (typeof store.getRowPath !== 'function' || !store._pad) {
53
+ throw new Error('mm_jsondb 版本过低:缺少 getRowPath / pad 配置');
54
+ }
55
+ this.db = db;
56
+ this.store = store;
57
+ }
58
+
59
+ /**
60
+ * 获取集合目录路径
61
+ * @param {string} name 集合名
62
+ * @returns {string} 集合目录
63
+ */
64
+ collectionDir(name) { return this.store._getTableDir(String(name)); }
65
+
66
+ /**
67
+ * 获取记录文件路径
68
+ * @param {string} name 集合名
69
+ * @param {*} keyValue 主键值
70
+ * @returns {string} 记录文件路径
71
+ */
72
+ fileFor(name, keyValue) { return this.store.getRowPath(String(name), keyValue); }
73
+
74
+ /**
75
+ * 获取布局状态
76
+ * @returns {object} 状态信息
77
+ */
78
+ status() {
79
+ return {
80
+ backend: this.backend, factory: this.factory,
81
+ scope: this._scope(), dir: this.dir, database: '.',
82
+ pad: this.store._pad, row_naming: 'pad=6 + .json',
83
+ async_api: 'Store.createTableDir/writeRow/readRow/deleteRow/listRowIds/listTables'
84
+ };
85
+ }
86
+
87
+ /**
88
+ * 打开并初始化 Store
89
+ * @returns {Promise<object>} 状态信息
90
+ */
91
+ async open() {
92
+ if (typeof this.store.init === 'function') await this.store.init();
93
+ return this.status();
94
+ }
95
+
96
+ /** 只清理本模块自己写在该集合目录下的 .json,不递归、不触碰其它文件 */
97
+ _clean(dir) {
98
+ if (!fs.existsSync(dir)) return;
99
+ let files = fs.readdirSync(dir, { withFileTypes: true });
100
+ for (let i = 0; i < files.length; i++) {
101
+ if (files[i].isFile() && /\.json$/i.test(files[i].name)) {
102
+ fs.unlinkSync(path.join(dir, files[i].name));
103
+ }
104
+ }
105
+ }
106
+
107
+ /**
108
+ * 取记录主键:无主键时按序号补
109
+ * @param {object} row 记录
110
+ * @param {string} key 主键字段名
111
+ * @param {number} index 序号
112
+ * @returns {*} 主键值
113
+ * @private
114
+ */
115
+ _rowId(row, key, index) { return row[key] === undefined ? index + 1 : row[key]; }
116
+
117
+ // ---------- 同步落盘入口:save() / load() ----------
118
+
119
+ /**
120
+ * 同步写入静态集合
121
+ * @param {string} name 集合名
122
+ * @param {string} key 主键字段名
123
+ * @param {Array} rows 记录列表
124
+ * @returns {number} 写入条数
125
+ */
126
+ saveStatic(name, key, rows) {
127
+ let dir = this.collectionDir(name);
128
+ fs.mkdirSync(dir, { recursive: true });
129
+ this._clean(dir);
130
+ for (let i = 0; i < rows.length; i++) {
131
+ fs.writeFileSync(this.fileFor(name, this._rowId(rows[i], key, i)),
132
+ JSON.stringify(rows[i], null, 2), 'utf8');
133
+ }
134
+ return rows.length;
135
+ }
136
+
137
+ /**
138
+ * 同步写入动态集合快照
139
+ * @param {string} name 集合名
140
+ * @param {Array} rows 记录列表
141
+ * @returns {number} 写入条数
142
+ */
143
+ saveDynamic(name, rows) {
144
+ let dir = this.collectionDir(name);
145
+ fs.mkdirSync(dir, { recursive: true });
146
+ fs.writeFileSync(path.join(dir, '_rows.json'), JSON.stringify(rows, null, 2), 'utf8');
147
+ return 1;
148
+ }
149
+
150
+ /**
151
+ * 同步读取目录下全部集合
152
+ * @param {Function} setTable 写回回调 setTable(name, rows)
153
+ * @param {string} [dir] 数据根目录,传入时重新绑定
154
+ * @returns {object} 读取结果
155
+ */
156
+ load(setTable, dir) {
157
+ if (dir) this._bind(dir);
158
+ if (!fs.existsSync(this.dir)) {
159
+ return { ok: false, reason: '目录不存在', backend: 'hybrid', dir: this.dir, table_names: [], collections: [] };
160
+ }
161
+ let names = fs.readdirSync(this.dir, { withFileTypes: true })
162
+ .filter(function (e) { return e.isDirectory() && e.name.charAt(0) !== '_'; })
163
+ .map(function (e) { return e.name; }).sort();
164
+ let info = [];
165
+ for (let i = 0; i < names.length; i++) {
166
+ let name = names[i];
167
+ let dir_name = this.collectionDir(name);
168
+ let snapshot = path.join(dir_name, '_rows.json');
169
+ let rows;
170
+ let kind;
171
+ if (fs.existsSync(snapshot)) {
172
+ rows = JSON.parse(fs.readFileSync(snapshot, 'utf8'));
173
+ kind = 'dynamic';
174
+ } else {
175
+ let files = fs.readdirSync(dir_name)
176
+ .filter(function (f) { return /\.json$/i.test(f) && f !== '_rows.json' && f !== '_meta.json'; }).sort();
177
+ rows = [];
178
+ for (let j = 0; j < files.length; j++) {
179
+ rows.push(JSON.parse(fs.readFileSync(path.join(dir_name, files[j]), 'utf8')));
180
+ }
181
+ kind = 'static';
182
+ }
183
+ setTable(name, rows);
184
+ info.push({ name: name, kind: kind, rows: rows.length });
185
+ }
186
+ return { ok: true, backend: 'hybrid', dir: this.dir, table_names: names, collections: info };
187
+ }
188
+
189
+ // ---------- 异步主路径:flush() / restore() 全量走 Store ----------
190
+
191
+ /**
192
+ * 异步写入静态集合
193
+ * @param {string} name 集合名
194
+ * @param {string} key 主键字段名
195
+ * @param {Array} rows 记录列表
196
+ * @returns {Promise<number>} 写入条数
197
+ */
198
+ async flushStatic(name, key, rows) {
199
+ let s = this.store;
200
+ await s.createTableDir(name);
201
+ let ids = await s.listRowIds(name);
202
+ let del_jobs = [];
203
+ for (let i = 0; i < ids.length; i++) {
204
+ if (ids[i] !== '_meta' && ids[i] !== '_rows') del_jobs.push(s.deleteRow(name, ids[i]));
205
+ }
206
+ let write_jobs = [];
207
+ for (let i = 0; i < rows.length; i++) {
208
+ write_jobs.push(s.writeRow(name, this._rowId(rows[i], key, i), rows[i]));
209
+ }
210
+ await Promise.all([...del_jobs, ...write_jobs]);
211
+ return rows.length;
212
+ }
213
+
214
+ /**
215
+ * 异步写入动态集合快照
216
+ * @param {string} name 集合名
217
+ * @param {Array} rows 记录列表
218
+ * @returns {Promise<number>} 写入条数
219
+ */
220
+ async flushDynamic(name, rows) {
221
+ let s = this.store;
222
+ await s.createTableDir(name);
223
+ await s.writeRow(name, '_rows', rows); // → <集合>/_rows.json
224
+ return 1;
225
+ }
226
+
227
+ /**
228
+ * 异步还原目录下全部集合
229
+ * @param {Function} setTable 写回回调 setTable(name, rows)
230
+ * @param {string} [dir] 数据根目录,传入时重新绑定
231
+ * @returns {Promise<object>} 还原结果
232
+ */
233
+ async restore(setTable, dir) {
234
+ if (dir) this._bind(dir);
235
+ if (!fs.existsSync(this.dir)) {
236
+ return { ok: false, reason: '目录不存在', backend: 'hybrid', dir: this.dir, table_names: [], collections: [] };
237
+ }
238
+ let s = this.store;
239
+ let names = (await s.listTables()).slice().sort();
240
+ let info = [];
241
+ for (let i = 0; i < names.length; i++) {
242
+ let name = names[i];
243
+ let ids = (await s.listRowIds(name)).filter(function (id) { return id !== '_meta'; });
244
+ let rows;
245
+ let kind;
246
+ if (ids.indexOf('_rows') !== -1) {
247
+ rows = await s.readRow(name, '_rows');
248
+ kind = 'dynamic';
249
+ } else {
250
+ rows = [];
251
+ let rowIds = ids.filter(function (id) { return id !== '_rows'; });
252
+ for (let j = 0; j < rowIds.length; j++) {
253
+ let row = await s.readRow(name, rowIds[j]);
254
+ if (row) rows.push(row);
255
+ }
256
+ kind = 'static';
257
+ }
258
+ if (!Array.isArray(rows)) rows = [];
259
+ setTable(name, rows);
260
+ info.push({ name: name, kind: kind, rows: rows.length });
261
+ }
262
+ return { ok: true, backend: 'hybrid', dir: this.dir, table_names: names, collections: info };
263
+ }
264
+ }
265
+
266
+ module.exports = JsonDbLayout;