w-orm-lmdb 1.0.16 → 1.0.18

package/src/WOrmLmdb.mjs

@@ -23,12 +23,30 @@ import waitFun from 'wsemi/src/waitFun.mjs'
 /**
  * 操作資料庫(LMDB)
  *
+ * 回傳物件為EventEmitter，除各操作函數外另發出change與error兩事件，供呼叫端於單一處集中觀察資料異動與失敗。
+ * 事件僅為附加通知，其所送出之資訊皆另有正規管道(操作結果經resolve、整批性錯誤經reject、逐筆失敗經該筆之err欄位)，
+ * 故不監聽亦能取得完整資訊，且監聽與否不改變任何操作之回傳值。
+ *
+ * change事件，參數為(mode, data, res)，於資料實際異動成功後發出：
+ * mode為操作別字串，可為'insert'、'save'、'del'、'delAll'；save內若逐筆走自動插入則該筆另發出mode為'insert'之事件。
+ * data為本次操作之輸入數據，delAll固定為null。
+ * res為本次操作之回傳結果。
+ * 逐筆函數以整批為單位發出一次而不逐筆發出，select與selectByPk不發出本事件。
+ *
+ * error事件，參數為(mode, data, err)，於操作發生錯誤時發出：
+ * mode為操作別字串，可為'select'、'selectByPk'、'insert'、'save'、'del'、'delAll'。
+ * data為本次操作之輸入數據，無輸入數據者為null。
+ * err為錯誤訊息字串，內容與正規管道所送出者一致。
+ * 整批性錯誤於reject之前發出；逐筆失敗於該筆結果定案後發出，每筆一次。
+ * 註: 逐筆失敗時整批仍resolve，故收到本事件不表示該次呼叫失敗；正常結果(如查無數據、主鍵未命中、全數已存在)不發出本事件。
+ *
  * @class
  * @param {Object} [opt={}] 輸入設定物件，預設{}
  * @param {String} [opt.url='_db'] 輸入資料庫用資料夾字串，預設'_db'
  * @param {String} [opt.db='worm'] 輸入使用資料庫名稱字串，預設'worm'
  * @param {String} [opt.cl='test'] 輸入使用資料表名稱字串，預設'test'
  * @param {Boolean} [opt.useCache=false] 輸入是否使用select快取，適用於單程序操作，預設false
+ * @param {Boolean} [opt.autoGenPk=true] 輸入insert與save於數據未帶有效主鍵(本套件為id欄位)時是否自動產生主鍵值，預設true；給false代表主鍵改由呼叫端自備，套件不產生亦不檢查其唯一性與格式，未帶有效主鍵者將reject
  * @returns {Object} 回傳操作資料庫物件，各事件功能詳見說明
  */
 function WOrmLmdb(opt = {}) {
@@ -60,6 +78,13 @@ function WOrmLmdb(opt = {}) {
         useCache = false
     }
 
+    //autoGenPk, 主鍵由誰產生為整個資料表之政策, 故為建構層設定, 不可於insert與save之option逐次覆寫,
+    //否則同一資料表將混入兩種來源之主鍵而難以追溯
+    let autoGenPk = get(opt, 'autoGenPk')
+    if (!isbol(autoGenPk)) {
+        autoGenPk = true
+    }
+
     //storage
     let storage = `${url}/${db}/${cl}`
     // console.log('storage',storage)
@@ -110,7 +135,30 @@ function WOrmLmdb(opt = {}) {
         })
     }
 
-    //getErrMsg, 取錯誤訊息字串, 供逐筆結果之err欄位使用
+    //emitChange, 資料實際異動成功後發出, 事件僅為附加通知不承擔回傳義務
+    //一律包try/catch, 令訂閱函數自身拋錯不影響本次操作之結果
+    let emitChange = (mode, data, res) => {
+        try {
+            ee.emit('change', mode, data, res)
+        }
+        catch (err) {
+            console.log(err)
+        }
+    }
+
+    //emitError, 操作發生錯誤時發出, 錯誤訊息一律轉為字串
+    //此try/catch除攔訂閱函數之例外外另有必要: Node之EventEmitter於'error'無監聽者時會將錯誤直接拋出,
+    //若不攔則同一次操作會因呼叫端有無註冊監聽而走向不同結果
+    let emitError = (mode, data, err) => {
+        try {
+            ee.emit('error', mode, data, getErrMsg(err))
+        }
+        catch (errEmit) {
+            console.log(errEmit)
+        }
+    }
+
+    //getErrMsg, 取錯誤訊息字串, 供逐筆結果之err欄位與error事件使用
     let getErrMsg = (err) => {
         let m = get(err, 'message')
         if (isestr(m)) {
@@ -119,6 +167,26 @@ function WOrmLmdb(opt = {}) {
         return String(err)
     }
 
+    //procPk, 依autoGenPk處理各數據之主鍵, 供insert與save共用
+    //autoGenPk為true時補值; 為false時不補值, 未帶有效主鍵者屬呼叫端未履行契約, 拋出為整批性錯誤,
+    //且檢查於任何寫入之前完成, 故不會有部份筆數已寫入而整批失敗之情形
+    let procPk = (data, fnName) => {
+        if (autoGenPk) {
+            return map(data, function(v) {
+                if (!isestr(v.id)) {
+                    v.id = genIDSeq()
+                }
+                return v
+            })
+        }
+        each(data, function(v, k) {
+            if (!isestr(get(v, 'id'))) {
+                throw new Error(`can not ${fnName} by data[${k}] without valid id when autoGenPk is false`)
+            }
+        })
+        return data
+    }
+
     //getValue
     let getValue = async (key) => {
         let value = null
@@ -184,6 +252,10 @@ function WOrmLmdb(opt = {}) {
 
         //check
         if (isErr) {
+
+            //emit, 整批性錯誤須於reject之前發出
+            emitError('select', null, res)
+
             return Promise.reject(res)
         }
 
@@ -233,6 +305,10 @@ function WOrmLmdb(opt = {}) {
 
         //check
         if (isErr) {
+
+            //emit, 整批性錯誤須於reject之前發出
+            emitError('selectByPk', null, res)
+
             return Promise.reject(res)
         }
 
@@ -271,12 +347,7 @@ function WOrmLmdb(opt = {}) {
             }
 
             //check id
-            data = map(data, function(v) {
-                if (!isestr(v.id)) {
-                    v.id = genIDSeq()
-                }
-                return v
-            })
+            data = procPk(data, 'insert')
 
             //each
             //ifNoExists, 由LMDB於同一寫交易內原子完成[檢查v.id未存在]與[寫入], 併發時同一v.id僅有一次成功,
@@ -321,19 +392,15 @@ function WOrmLmdb(opt = {}) {
 
         //emit, 於change可能須使用select, 故須放在重設快取之後
         if (!isErr) {
-            try {
-
-                //emit
-                ee.emit('change', 'insert', data, res)
-
-            }
-            catch (err) {
-                console.log(err)
-            }
+            emitChange('insert', data, res)
         }
 
         //check
         if (isErr) {
+
+            //emit, 整批性錯誤須於reject之前發出
+            emitError('insert', data, res)
+
             return Promise.reject(res)
         }
 
@@ -373,12 +440,7 @@ function WOrmLmdb(opt = {}) {
             }
 
             //check id
-            data = map(data, function(v) {
-                if (!isestr(v.id)) {
-                    v.id = genIDSeq()
-                }
-                return v
-            })
+            data = procPk(data, 'save')
 
             //pmSeries
             res = await pmSeries(data, async(v) => {
@@ -507,16 +569,15 @@ function WOrmLmdb(opt = {}) {
                     //update, 不能保證插入多少, 一律重設快取
                     _cache = null
 
-                    try {
-
-                        //emit
-                        ee.emit('change', 'insert', [v], rest)
+                    //emit
+                    emitChange('insert', [v], rest)
 
-                    }
-                    catch (err) {
-                        console.log(err)
-                    }
+                }
 
+                //emit, 逐筆失敗於該筆結果定案後發出, 每筆一次
+                //此事件之發出不表示整批失敗, 整批仍resolve, 該筆以ok為0回報
+                if (rest.ok === 0) {
+                    emitError('save', [v], rest.err)
                 }
 
                 return rest
@@ -532,20 +593,17 @@ function WOrmLmdb(opt = {}) {
         _cache = null
 
         //emit, 於change可能須使用select, 故須放在重設快取之後
+        //逐筆失敗之error事件已於各筆定案時發出, 故必早於本整批change
         if (!isErr) {
-            try {
-
-                //emit
-                ee.emit('change', 'save', data, res)
-
-            }
-            catch (err) {
-                console.log(err)
-            }
+            emitChange('save', data, res)
         }
 
         //check
         if (isErr) {
+
+            //emit, 整批性錯誤須於reject之前發出
+            emitError('save', data, res)
+
             return Promise.reject(res)
         }
 
@@ -594,38 +652,42 @@ function WOrmLmdb(opt = {}) {
                     if (!isestr(id)) {
                         //未給有效v.id視為該筆數據有問題而無法處理, 以ok為0並附err回報,
                         //與[已給v.id但查無數據]之ok為1有別, 二者須可由ok分辨
-                        return {
+                        //註: 此處不可直接return, 否則會跳過本回調末尾之error事件發出
+                        rest = {
                             n: 0,
                             nDeleted: 0,
                             ok: 0,
                             err: `can not delete by invalid id[${id}]`,
                         }
                     }
+                    else {
 
-                    //查找資料表內v.id
-                    let vv = await getValue(id) //不會有catch
+                        //查找資料表內v.id
+                        let vv = await getValue(id) //不會有catch
 
-                    //check
-                    if (iseobj(vv)) {
-                        //已存在v.id則須刪除
+                        //check
+                        if (iseobj(vv)) {
+                            //已存在v.id則須刪除
 
-                        //del
-                        await client.del(id)
+                            //del
+                            await client.del(id)
+
+                            //rest
+                            rest = {
+                                n: 1,
+                                nDeleted: 1,
+                                ok: 1,
+                            }
 
-                        //rest
-                        rest = {
-                            n: 1,
-                            nDeleted: 1,
-                            ok: 1,
                         }
+                        else {
+                            //不存在v.id則不刪除, 未命中故n為0
+                            rest = {
+                                n: 0,
+                                nDeleted: 0,
+                                ok: 1,
+                            }
 
-                    }
-                    else {
-                        //不存在v.id則不刪除, 未命中故n為0
-                        rest = {
-                            n: 0,
-                            nDeleted: 0,
-                            ok: 1,
                         }
 
                     }
@@ -643,6 +705,12 @@ function WOrmLmdb(opt = {}) {
 
                 }
 
+                //emit, 逐筆失敗於該筆結果定案後發出, 每筆一次
+                //此事件之發出不表示整批失敗, 整批仍resolve, 該筆以ok為0回報
+                if (rest.ok === 0) {
+                    emitError('del', [v], rest.err)
+                }
+
                 return rest
             })
 
@@ -656,20 +724,17 @@ function WOrmLmdb(opt = {}) {
         _cache = null
 
         //emit, 於change可能須使用select, 故須放在重設快取之後
+        //逐筆失敗之error事件已於各筆定案時發出, 故必早於本整批change
         if (!isErr) {
-            try {
-
-                //emit
-                ee.emit('change', 'del', data, res)
-
-            }
-            catch (err) {
-                console.log(err)
-            }
+            emitChange('del', data, res)
         }
 
         //check
         if (isErr) {
+
+            //emit, 整批性錯誤須於reject之前發出
+            emitError('del', data, res)
+
             return Promise.reject(res)
         }
 
@@ -771,19 +836,15 @@ function WOrmLmdb(opt = {}) {
 
         //emit, 於change可能須使用select, 故須放在重設快取之後
         if (!isErr) {
-            try {
-
-                //emit
-                ee.emit('change', 'delAll', null, res)
-
-            }
-            catch (err) {
-                console.log(err)
-            }
+            emitChange('delAll', null, res)
         }
 
         //check
         if (isErr) {
+
+            //emit, 整批性錯誤須於reject之前發出
+            emitError('delAll', null, res)
+
             return Promise.reject(res)
         }
 

package/test/unit-autogenpk.test.mjs

@@ -0,0 +1,188 @@
+import assert from 'assert'
+import _ from 'lodash-es'
+import w from 'wsemi'
+import WOrm from '../src/WOrmLmdb.mjs'
+
+
+describe('autoGenPk', function() {
+    let rt = null
+    let vans = {}
+    let vget = {}
+
+    before(async function() {
+
+        w.fsDeleteFolder('./_db_autogenpk')
+
+        let url = './_db_autogenpk'
+
+        //預設值須為true, 未帶id者自動補值
+        let woDef = WOrm({ url, db: 'worm', cl: 'def' })
+        await woDef.insert({ name: 'peter' })
+        let rsDef = await woDef.select()
+        vget[1] = _.size(rsDef)
+        vget[2] = w.isestr(_.get(rsDef, '0.id'))
+        await woDef.close()
+
+        //明確給true, 行為須與預設相同
+        let woTrue = WOrm({ url, db: 'worm', cl: 'ptrue', autoGenPk: true })
+        rt = null
+        // vans[3] = { n: 2, nInserted: 2, ok: 1 }
+        await woTrue.insert([{ name: 'a' }, { name: 'b' }])
+            .then(function(msg) {
+                rt = msg
+            })
+            .catch(function(msg) {
+                rt = 'reject: ' + msg.toString()
+            })
+        vget[3] = rt
+        vget[4] = _.size(_.filter(await woTrue.select(), function(v) {
+            return w.isestr(v.id)
+        }))
+        await woTrue.close()
+
+        //給false且自備id, 須正常寫入且沿用呼叫端所給之id
+        let woFalse = WOrm({ url, db: 'worm', cl: 'pfalse', autoGenPk: false })
+        rt = null
+        // vans[5] = { n: 2, nInserted: 2, ok: 1 }
+        await woFalse.insert([{ id: 'own-1', name: 'a' }, { id: 'own-2', name: 'b' }])
+            .then(function(msg) {
+                rt = msg
+            })
+            .catch(function(msg) {
+                rt = 'reject: ' + msg.toString()
+            })
+        vget[5] = rt
+        vget[6] = _.map(_.sortBy(await woFalse.select(), 'id'), 'id')
+
+        //給false且save自備id, 須正常處理
+        rt = null
+        // vans[7] = [{ n: 1, nInserted: 0, nModified: 1, ok: 1 }]
+        await woFalse.save({ id: 'own-1', name: 'a2' })
+            .then(function(msg) {
+                rt = msg
+            })
+            .catch(function(msg) {
+                rt = 'reject: ' + msg.toString()
+            })
+        vget[7] = rt
+
+        //給false而insert未帶有效id, 須reject且不得有任何寫入
+        rt = null
+        await woFalse.insert({ name: 'no-id' })
+            .then(function(msg) {
+                rt = 'resolve: ' + JSON.stringify(msg)
+            })
+            .catch(function(msg) {
+                rt = 'reject'
+            })
+        vget[8] = rt
+
+        //給false而save未帶有效id, 須reject
+        rt = null
+        await woFalse.save({ name: 'no-id' })
+            .then(function(msg) {
+                rt = 'resolve: ' + JSON.stringify(msg)
+            })
+            .catch(function(msg) {
+                rt = 'reject'
+            })
+        vget[9] = rt
+
+        //給false而整批內僅部份未帶有效id, 須整批reject且不得有部份筆數已寫入
+        rt = null
+        await woFalse.insert([{ id: 'own-3', name: 'c' }, { name: 'no-id' }])
+            .then(function(msg) {
+                rt = 'resolve: ' + JSON.stringify(msg)
+            })
+            .catch(function(msg) {
+                rt = 'reject'
+            })
+        vget[10] = rt
+        vget[11] = _.map(_.sortBy(await woFalse.select(), 'id'), 'id')
+        await woFalse.close()
+
+        //del不受autoGenPk影響, 未帶有效id者為該筆問題而非整批性錯誤
+        let woDel = WOrm({ url, db: 'worm', cl: 'pdel', autoGenPk: false })
+        await woDel.insert({ id: 'd1', name: 'x' })
+        rt = null
+        await woDel.del([{ id: 'd1' }, { name: 'no-id' }])
+            .then(function(msg) {
+                rt = _.map(msg, function(v) {
+                    return _.omit(v, 'err')
+                })
+            })
+            .catch(function(msg) {
+                rt = 'reject: ' + msg.toString()
+            })
+        vget[12] = rt
+        await woDel.close()
+
+    })
+
+    vans[1] = 1
+    it(`should get ${JSON.stringify(vans[1])} for records by insert without id in default`, async function() {
+        assert.strict.deepStrictEqual(vget[1], vans[1])
+    })
+
+    vans[2] = true
+    it(`should get ${JSON.stringify(vans[2])} for id generated by default`, async function() {
+        assert.strict.deepStrictEqual(vget[2], vans[2])
+    })
+
+    vans[3] = { n: 2, nInserted: 2, ok: 1 }
+    it(`should get ${JSON.stringify(vans[3])} for insert without id by autoGenPk=true`, async function() {
+        assert.strict.deepStrictEqual(vget[3], vans[3])
+    })
+
+    vans[4] = 2
+    it(`should get ${JSON.stringify(vans[4])} for records with generated id by autoGenPk=true`, async function() {
+        assert.strict.deepStrictEqual(vget[4], vans[4])
+    })
+
+    vans[5] = { n: 2, nInserted: 2, ok: 1 }
+    it(`should get ${JSON.stringify(vans[5])} for insert with own id by autoGenPk=false`, async function() {
+        assert.strict.deepStrictEqual(vget[5], vans[5])
+    })
+
+    vans[6] = ['own-1', 'own-2']
+    it(`should get ${JSON.stringify(vans[6])} for keeping own id by autoGenPk=false`, async function() {
+        assert.strict.deepStrictEqual(vget[6], vans[6])
+    })
+
+    vans[7] = [{ n: 1, nInserted: 0, nModified: 1, ok: 1 }]
+    it(`should get ${JSON.stringify(vans[7])} for save with own id by autoGenPk=false`, async function() {
+        assert.strict.deepStrictEqual(vget[7], vans[7])
+    })
+
+    //autoGenPk為false而未帶有效主鍵屬呼叫端未履行契約, 須為整批性錯誤而非該筆ok為0
+    vans[8] = 'reject'
+    it(`should get ${JSON.stringify(vans[8])} for insert without id by autoGenPk=false`, async function() {
+        assert.strict.deepStrictEqual(vget[8], vans[8])
+    })
+
+    vans[9] = 'reject'
+    it(`should get ${JSON.stringify(vans[9])} for save without id by autoGenPk=false`, async function() {
+        assert.strict.deepStrictEqual(vget[9], vans[9])
+    })
+
+    vans[10] = 'reject'
+    it(`should get ${JSON.stringify(vans[10])} for insert by array partially without id by autoGenPk=false`, async function() {
+        assert.strict.deepStrictEqual(vget[10], vans[10])
+    })
+
+    //檢查須於任何寫入之前完成, 故整批reject時同批之有效筆數亦不得被寫入
+    vans[11] = ['own-1', 'own-2']
+    it(`should get ${JSON.stringify(vans[11])} for no partial writing when batch rejected`, async function() {
+        assert.strict.deepStrictEqual(vget[11], vans[11])
+    })
+
+    //del不受autoGenPk影響
+    vans[12] = [
+        { n: 1, nDeleted: 1, ok: 1 },
+        { n: 0, nDeleted: 0, ok: 0 },
+    ]
+    it(`should get ${JSON.stringify(vans[12])} for del not affected by autoGenPk=false`, async function() {
+        assert.strict.deepStrictEqual(vget[12], vans[12])
+    })
+
+})