w-orm-lowdb 1.0.2 → 1.0.3

package/src/WOrmLowdb.mjs

@@ -2,7 +2,6 @@ import events from 'events'
 import { Low } from 'lowdb'
 import { JSONFile } from 'lowdb/node'
 import { Query } from 'mingo' //須指定安裝6.5.6, 若6.6.0無法匯入Query
-import { Mutex } from 'async-mutex'
 import get from 'lodash-es/get.js'
 import each from 'lodash-es/each.js'
 import map from 'lodash-es/map.js'
@@ -18,6 +17,12 @@ import iseobj from 'wsemi/src/iseobj.mjs'
 import isearr from 'wsemi/src/isearr.mjs'
 import haskey from 'wsemi/src/haskey.mjs'
 import arrPullAt from 'wsemi/src/arrPullAt.mjs'
+import waitFun from 'wsemi/src/waitFun.mjs'
+
+
+//全域鎖, 一次僅能執行一種操作函數
+//select理論上是不用鎖, 但因為操作上db.jon.tmp更名回db.json時似乎非rename而是串流寫入, 導致有機會撈到不完整json數據進而出錯, 故還是得要上鎖以策安全
+let glock = false
 
 
 /**
@@ -59,9 +64,6 @@ function WOrmLowdb(opt = {}) {
     //lowdb
     let lowdb = new Low(adapter, {})
 
-    //mutex
-    let mutex = new Mutex()
-
     // //default, 此處偵測會失效, 因操作函數內會通過lowdb.read()初始化, 預設創建空陣列會被取代
     // if (!haskey(lowdb.data, key)) {
     //     lowdb.data[key] = []
@@ -77,7 +79,7 @@ function WOrmLowdb(opt = {}) {
      * @param {Object} [find={}] 輸入查詢條件物件
      * @returns {Promise} 回傳Promise，resolve回傳數據，reject回傳錯誤訊息
      */
-    async function select(find = {}) {
+    async function selectCore(find = {}) {
         let isErr = false
 
         //res
@@ -119,6 +121,18 @@ function WOrmLowdb(opt = {}) {
         }
         return res
     }
+    async function select(find = {}) {
+        if (glock) {
+            await waitFun(() => {
+                return !glock
+            })
+        }
+        glock = true
+        return await selectCore(find)
+            .finally(() => {
+                glock = false
+            })
+    }
 
     /**
      * 插入數據，插入同樣數據會自動產生不同_id，故insert前需自行判斷有無重複
@@ -127,97 +141,107 @@ function WOrmLowdb(opt = {}) {
      * @param {Object|Array} data 輸入數據物件或陣列
      * @returns {Promise} 回傳Promise，resolve回傳插入結果，reject回傳錯誤訊息
      */
-    async function insert(data) {
-        return await mutex.runExclusive(async () => {
-            let isErr = false
-
-            //check
-            if (!iseobj(data) && !isearr(data)) {
-                return Promise.reject(`data is not an effective object or array`)
-            }
-
-            //cloneDeep, 與外部數據脫勾
-            data = cloneDeep(data)
+    async function insertCore(data) {
+        let isErr = false
 
-            //res
-            let res = null
-            try {
+        //check
+        if (!iseobj(data) && !isearr(data)) {
+            return Promise.reject(`data is not an effective object or array`)
+        }
 
-                //check
-                if (!isarr(data)) {
-                    data = [data]
-                }
+        //cloneDeep, 與外部數據脫勾
+        data = cloneDeep(data)
 
-                //check id
-                data = map(data, function(v) {
-                    if (!isestr(v.id)) {
-                        v.id = genID()
-                    }
-                    return v
-                })
+        //res
+        let res = null
+        try {
 
-                //read
-                await lowdb.read()
+            //check
+            if (!isarr(data)) {
+                data = [data]
+            }
 
-                //default, 使用lowdb.read()初始化後須馬上檢測, 若無key則須先創建空陣列
-                if (!haskey(lowdb.data, key)) {
-                    lowdb.data[key] = []
+            //check id
+            data = map(data, function(v) {
+                if (!isestr(v.id)) {
+                    v.id = genID()
                 }
+                return v
+            })
 
-                //kp
-                let kp = {}
-                each(lowdb.data[key], (v, k) => {
-                    kp[v.id] = { k, v }
-                })
+            //read
+            await lowdb.read()
 
-                //each
-                let nAll = size(data)
-                let nPush = 0
-                let b = false
-                each(data, (v) => {
+            //default, 使用lowdb.read()初始化後須馬上檢測, 若無key則須先創建空陣列
+            if (!haskey(lowdb.data, key)) {
+                lowdb.data[key] = []
+            }
 
-                    //check
-                    if (!haskey(kp, v.id)) {
-                        //未存在v.id
+            //kp
+            let kp = {}
+            each(lowdb.data[key], (v, k) => {
+                kp[v.id] = { k, v }
+            })
 
-                        //push
-                        lowdb.data[key].push(v)
+            //each
+            let nAll = size(data)
+            let nPush = 0
+            let b = false
+            each(data, (v) => {
 
-                        nPush++
-                        b = true
-                    }
-                    else {
-                        //已存在v.id則不push
-                    }
+                //check
+                if (!haskey(kp, v.id)) {
+                    //未存在v.id
 
-                })
+                    //push
+                    lowdb.data[key].push(v)
 
-                //write
-                if (b) {
-                    await lowdb.write()
+                    nPush++
+                    b = true
                 }
-
-                //res
-                res = {
-                    n: nAll,
-                    nInserted: nPush,
-                    ok: 1,
+                else {
+                    //已存在v.id則不push
                 }
 
-                //emit
-                ee.emit('change', 'insert', data, res)
+            })
 
-            }
-            catch (err) {
-                isErr = true
-                res = err
+            //write
+            if (b) {
+                await lowdb.write()
             }
 
-            if (isErr) {
-                return Promise.reject(res)
+            //res
+            res = {
+                n: nAll,
+                nInserted: nPush,
+                ok: 1,
             }
-            return res
-        })
+
+            //emit
+            ee.emit('change', 'insert', data, res)
+
+        }
+        catch (err) {
+            isErr = true
+            res = err
+        }
+
+        if (isErr) {
+            return Promise.reject(res)
+        }
+        return res
+    }
+    async function insert(data) {
+        if (glock) {
+            await waitFun(() => {
+                return !glock
+            })
+        }
+        glock = true
+        return await insertCore(data)
+            .finally(() => {
+                glock = false
+            })
     }
 
     /**
@@ -229,122 +253,132 @@ function WOrmLowdb(opt = {}) {
      * @param {boolean} [option.autoInsert=true] 輸入是否於儲存時發現原本無數據，則自動改以插入處理，預設為true
      * @returns {Promise} 回傳Promise，resolve回傳儲存結果，reject回傳錯誤訊息
      */
-    async function save(data, option = {}) {
-        return await mutex.runExclusive(async () => {
-            let isErr = false
-
-            //check
-            if (!iseobj(data) && !isearr(data)) {
-                return Promise.reject(`data is not an effective object or array`)
-            }
-
-            //cloneDeep, 與外部數據脫勾
-            data = cloneDeep(data)
+    async function saveCore(data, option = {}) {
+        let isErr = false
 
-            //autoInsert
-            let autoInsert = get(option, 'autoInsert', true)
+        //check
+        if (!iseobj(data) && !isearr(data)) {
+            return Promise.reject(`data is not an effective object or array`)
+        }
 
-            //res
-            let res = null
-            try {
+        //cloneDeep, 與外部數據脫勾
+        data = cloneDeep(data)
 
-                //check
-                if (!isarr(data)) {
-                    data = [data]
-                }
+        //autoInsert
+        let autoInsert = get(option, 'autoInsert', true)
 
-                //check id
-                data = map(data, function(v) {
-                    if (!isestr(v.id)) {
-                        v.id = genID()
-                    }
-                    return v
-                })
+        //res
+        let res = null
+        try {
 
-                //read
-                await lowdb.read()
+            //check
+            if (!isarr(data)) {
+                data = [data]
+            }
 
-                //default, 使用lowdb.read()初始化後須馬上檢測, 若無key則須先創建空陣列
-                if (!haskey(lowdb.data, key)) {
-                    lowdb.data[key] = []
+            //check id
+            data = map(data, function(v) {
+                if (!isestr(v.id)) {
+                    v.id = genID()
                 }
+                return v
+            })
 
-                //kp
-                let kp = {}
-                each(lowdb.data[key], (v, k) => {
-                    kp[v.id] = { k, v }
-                })
+            //read
+            await lowdb.read()
 
-                //pmSeries
-                let b = false
-                res = await pmSeries(data, async(v) => {
+            //default, 使用lowdb.read()初始化後須馬上檢測, 若無key則須先創建空陣列
+            if (!haskey(lowdb.data, key)) {
+                lowdb.data[key] = []
+            }
 
-                    //rest
-                    let rest = null
+            //kp
+            let kp = {}
+            each(lowdb.data[key], (v, k) => {
+                kp[v.id] = { k, v }
+            })
 
-                    //查找資料表內v.id
-                    let r = get(kp, v.id, null)
+            //pmSeries
+            let b = false
+            res = await pmSeries(data, async(v) => {
 
-                    //check
-                    if (iseobj(r)) {
-                        //已存在v.id
-                        if (isEqual(v, r.v)) {
-                            //內容相同不更新
-                        }
-                        else {
-                            //內容不同須更新
+                //rest
+                let rest = null
 
-                            //merge
-                            lowdb.data[key][r.k] = merge(lowdb.data[key][r.k], v)
+                //查找資料表內v.id
+                let r = get(kp, v.id, null)
 
-                            rest = { update: true }
-                            b = true
-                        }
-                    }
-
-                    //rest
-                    if (iseobj(rest)) {
-                        rest = {
-                            n: 1,
-                            nModified: 1,
-                            ok: 1,
-                        }
+                //check
+                if (iseobj(r)) {
+                    //已存在v.id
+                    if (isEqual(v, r.v)) {
+                        //內容相同不更新
                     }
                     else {
-                        rest = {
-                            n: 0,
-                            nModified: 0,
-                            ok: 1,
-                        }
-                    }
+                        //內容不同須更新
 
-                    //autoInsert
-                    if (autoInsert && rest.n === 0) {
-                        rest = await insert(v)
+                        //merge
+                        lowdb.data[key][r.k] = merge(lowdb.data[key][r.k], v)
+
+                        rest = { update: true }
+                        b = true
                     }
+                }
 
-                    return rest
-                })
+                //rest
+                if (iseobj(rest)) {
+                    rest = {
+                        n: 1,
+                        nModified: 1,
+                        ok: 1,
+                    }
+                }
+                else {
+                    rest = {
+                        n: 0,
+                        nModified: 0,
+                        ok: 1,
+                    }
+                }
 
-                //write
-                if (b) {
-                    await lowdb.write()
+                //autoInsert
+                if (autoInsert && rest.n === 0) {
+                    rest = await insertCore(v)
                 }
 
-                //emit
-                ee.emit('change', 'save', data, res)
+                return rest
+            })
 
-            }
-            catch (err) {
-                isErr = true
-                res = err
+            //write
+            if (b) {
+                await lowdb.write()
             }
 
-            if (isErr) {
-                return Promise.reject(res)
-            }
-            return res
-        })
+            //emit
+            ee.emit('change', 'save', data, res)
+
+        }
+        catch (err) {
+            isErr = true
+            res = err
+        }
+
+        if (isErr) {
+            return Promise.reject(res)
+        }
+        return res
+    }
+    async function save(data, option = {}) {
+        if (glock) {
+            await waitFun(() => {
+                return !glock
+            })
+        }
+        glock = true
+        return await saveCore(data, option)
+            .finally(() => {
+                glock = false
+            })
     }
 
     /**
@@ -354,127 +388,137 @@ function WOrmLowdb(opt = {}) {
      * @param {Object|Array} data 輸入數據物件或陣列
      * @returns {Promise} 回傳Promise，resolve回傳刪除結果，reject回傳錯誤訊息
      */
-    async function del(data) {
-        return await mutex.runExclusive(async () => {
-            let isErr = false
-
-            //check
-            if (!iseobj(data) && !isearr(data)) {
-                return Promise.reject(`data is not an effective object or array`)
-            }
-
-            //cloneDeep, 與外部數據脫勾
-            data = cloneDeep(data)
-
-            //res
-            let res = null
-            try {
+    async function delCore(data) {
+        let isErr = false
 
-                //check
-                if (!isarr(data)) {
-                    data = [data]
-                }
+        //check
+        if (!iseobj(data) && !isearr(data)) {
+            return Promise.reject(`data is not an effective object or array`)
+        }
 
-                //read
-                await lowdb.read()
+        //cloneDeep, 與外部數據脫勾
+        data = cloneDeep(data)
 
-                //default, 使用lowdb.read()初始化後須馬上檢測, 若無key則須先創建空陣列
-                if (!haskey(lowdb.data, key)) {
-                    lowdb.data[key] = []
-                }
+        //res
+        let res = null
+        try {
 
-                //kp
-                let kp = {}
-                each(lowdb.data[key], (v, k) => {
-                    kp[v.id] = { k, v }
-                })
+            //check
+            if (!isarr(data)) {
+                data = [data]
+            }
 
-                //pmSeries
-                let ks = []
-                let b = false
-                res = await pmSeries(data, async(v) => {
+            //read
+            await lowdb.read()
 
-                    //rest
-                    let rest = null
+            //default, 使用lowdb.read()初始化後須馬上檢測, 若無key則須先創建空陣列
+            if (!haskey(lowdb.data, key)) {
+                lowdb.data[key] = []
+            }
 
-                    //id
-                    let id = get(v, 'id', '')
+            //kp
+            let kp = {}
+            each(lowdb.data[key], (v, k) => {
+                kp[v.id] = { k, v }
+            })
 
-                    //check
-                    if (isestr(id)) {
+            //pmSeries
+            let ks = []
+            let b = false
+            res = await pmSeries(data, async(v) => {
 
-                        //查找資料表內v.id為_v
-                        let r = get(kp, id, null)
+                //rest
+                let rest = null
 
-                        //check
-                        if (iseobj(r)) {
-                            //已存在v.id則須刪除
+                //id
+                let id = get(v, 'id', '')
 
-                            //push
-                            ks.push(r.k)
+                //check
+                if (isestr(id)) {
 
-                            b = true
+                    //查找資料表內v.id為_v
+                    let r = get(kp, id, null)
 
-                            //rest
-                            rest = {
-                                n: 1,
-                                nDeleted: 1,
-                                ok: 1,
-                            }
+                    //check
+                    if (iseobj(r)) {
+                        //已存在v.id則須刪除
 
-                        }
-                        else {
-                            //不存在v.id則不刪除
+                        //push
+                        ks.push(r.k)
 
-                            //rest
-                            rest = {
-                                n: 1,
-                                nDeleted: 0,
-                                ok: 1,
-                            }
+                        b = true
 
+                        //rest
+                        rest = {
+                            n: 1,
+                            nDeleted: 1,
+                            ok: 1,
                         }
 
                     }
                     else {
-                        //未給v.id則不刪除
+                        //不存在v.id則不刪除
 
                         //rest
                         rest = {
                             n: 1,
                             nDeleted: 0,
-                            ok: 0, //未給v.id視為有問題數據, 故ok給0
+                            ok: 1,
                         }
 
                     }
 
-                    return rest
-                })
-
-                //update
-                if (b) {
-                    lowdb.data[key] = arrPullAt(lowdb.data[key], ks)
                 }
+                else {
+                    //未給v.id則不刪除
+
+                    //rest
+                    rest = {
+                        n: 1,
+                        nDeleted: 0,
+                        ok: 0, //未給v.id視為有問題數據, 故ok給0
+                    }
 
-                //write
-                if (b) {
-                    await lowdb.write()
                 }
 
-                //emit
-                ee.emit('change', 'del', data, res)
+                return rest
+            })
 
-            }
-            catch (err) {
-                isErr = true
-                res = err
+            //update
+            if (b) {
+                lowdb.data[key] = arrPullAt(lowdb.data[key], ks)
             }
 
-            if (isErr) {
-                return Promise.reject(res)
+            //write
+            if (b) {
+                await lowdb.write()
             }
-            return res
-        })
+
+            //emit
+            ee.emit('change', 'del', data, res)
+
+        }
+        catch (err) {
+            isErr = true
+            res = err
+        }
+
+        if (isErr) {
+            return Promise.reject(res)
+        }
+        return res
+    }
+    async function del(data) {
+        if (glock) {
+            await waitFun(() => {
+                return !glock
+            })
+        }
+        glock = true
+        return await delCore(data)
+            .finally(() => {
+                glock = false
+            })
     }
 
     /**
@@ -484,112 +528,122 @@ function WOrmLowdb(opt = {}) {
      * @param {Object} [find={}] 輸入刪除條件物件
      * @returns {Promise} 回傳Promise，resolve回傳刪除結果，reject回傳錯誤訊息
      */
-    async function delAll(find = {}) {
-        return await mutex.runExclusive(async () => {
-            let isErr = false
-
-            //res
-            let res = null
-            try {
-
-                //read
-                await lowdb.read()
-
-                //default, 使用lowdb.read()初始化後須馬上檢測, 若無key則須先創建空陣列
-                if (!haskey(lowdb.data, key)) {
-                    lowdb.data[key] = []
-                }
+    async function delAllCore(find = {}) {
+        let isErr = false
 
-                //filter
-                let nAll = size(lowdb.data[key])
-                let nDel = 0
-                let b = false
-                if (iseobj(find)) {
+        //res
+        let res = null
+        try {
 
-                    //q
-                    let q = new Query(find)
-                    // console.log('q', q)
+            //read
+            await lowdb.read()
 
-                    //find
-                    let _res = q.find(lowdb.data[key]).all()
-                    // console.log('_res', _res)
+            //default, 使用lowdb.read()初始化後須馬上檢測, 若無key則須先創建空陣列
+            if (!haskey(lowdb.data, key)) {
+                lowdb.data[key] = []
+            }
 
-                    //nDel
-                    nDel = size(_res)
-                    // console.log('nDel', nDel)
+            //filter
+            let nAll = size(lowdb.data[key])
+            let nDel = 0
+            let b = false
+            if (iseobj(find)) {
 
-                    if (nDel === 0) {
-                        //未有find結果等於不刪除
-                    }
-                    else if (nAll === nDel) {
-                        //全在find結果內等於全部刪除
+                //q
+                let q = new Query(find)
+                // console.log('q', q)
 
-                        //empty
-                        lowdb.data[key] = []
+                //find
+                let _res = q.find(lowdb.data[key]).all()
+                // console.log('_res', _res)
 
-                        b = true
-                    }
-                    else {
-                        //部份在find結果內
-
-                        //_kp
-                        let _kp = {}
-                        each(_res, (v, k) => {
-                            _kp[v.id] = { k, v }
-                        })
-
-                        //arr
-                        let arr = []
-                        each(lowdb.data[key], (v, k) => {
-                            if (!haskey(_kp, v.id)) {
-                                //未在find結果內代表須保留
-                                arr.push(v)
-                            }
-                        })
-
-                        //update
-                        lowdb.data[key] = arr
+                //nDel
+                nDel = size(_res)
+                // console.log('nDel', nDel)
 
-                        b = true
-                    }
+                if (nDel === 0) {
+                    //未有find結果等於不刪除
                 }
-                else {
-
-                    //nDel
-                    nDel = nAll
+                else if (nAll === nDel) {
+                    //全在find結果內等於全部刪除
 
                     //empty
                     lowdb.data[key] = []
 
                     b = true
                 }
+                else {
+                    //部份在find結果內
+
+                    //_kp
+                    let _kp = {}
+                    each(_res, (v, k) => {
+                        _kp[v.id] = { k, v }
+                    })
+
+                    //arr
+                    let arr = []
+                    each(lowdb.data[key], (v, k) => {
+                        if (!haskey(_kp, v.id)) {
+                            //未在find結果內代表須保留
+                            arr.push(v)
+                        }
+                    })
 
-                //write
-                if (b) {
-                    await lowdb.write()
-                }
+                    //update
+                    lowdb.data[key] = arr
 
-                //res
-                res = {
-                    n: nAll,
-                    nDeleted: nDel,
-                    ok: 1,
+                    b = true
                 }
+            }
+            else {
 
-                //emit
-                ee.emit('change', 'delAll', null, res)
+                //nDel
+                nDel = nAll
+
+                //empty
+                lowdb.data[key] = []
 
+                b = true
             }
-            catch (err) {
-                isErr = true
-                res = err
+
+            //write
+            if (b) {
+                await lowdb.write()
             }
 
-            if (isErr) {
-                return Promise.reject(res)
+            //res
+            res = {
+                n: nAll,
+                nDeleted: nDel,
+                ok: 1,
             }
-            return res
-        })
+
+            //emit
+            ee.emit('change', 'delAll', null, res)
+
+        }
+        catch (err) {
+            isErr = true
+            res = err
+        }
+
+        if (isErr) {
+            return Promise.reject(res)
+        }
+        return res
+    }
+    async function delAll(find = {}) {
+        if (glock) {
+            await waitFun(() => {
+                return !glock
+            })
+        }
+        glock = true
+        return await delAllCore(find)
+            .finally(() => {
+                glock = false
+            })
     }
 
     //bind