w-orm-lowdb 1.0.13 → 1.0.14

package/src/WOrmLowdb.mjs

@@ -1,777 +1,1066 @@
-import path from 'path'
-import events from 'events'
-import { Low } from 'lowdb'
-import { JSONFile } from 'lowdb/node'
-import { Query } from 'mingo'
-import get from 'lodash-es/get.js'
-import each from 'lodash-es/each.js'
-import map from 'lodash-es/map.js'
-import merge from 'lodash-es/merge.js'
-import isEqual from 'lodash-es/isEqual.js'
-import size from 'lodash-es/size.js'
-import cloneDeep from 'lodash-es/cloneDeep.js'
-import genID from 'wsemi/src/genID.mjs'
-import pmSeries from 'wsemi/src/pmSeries.mjs'
-import isarr from 'wsemi/src/isarr.mjs'
-import isbol from 'wsemi/src/isbol.mjs'
-import isestr from 'wsemi/src/isestr.mjs'
-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'
-
-
-//kpGlock
-let kpGlock = {}
-
-
-/**
- * 操作資料庫(lowdb)
- *
- * @class
- * @param {Object} [opt={}] 輸入設定物件，預設{}
- * @param {String} [opt.url='./db.json'] 輸入資料庫位置字串，預設'./db.json'
- * @param {String} [opt.db='worm'] 輸入使用資料庫名稱字串，預設'worm'
- * @param {String} [opt.cl='test'] 輸入使用資料表名稱字串，預設'test'
- * @param {Boolean} [opt.useCache=false] 輸入是否使用select快取，適用於單程序操作，預設false
- * @returns {Object} 回傳操作資料庫物件，各事件功能詳見說明
- */
-function WOrmLowdb(opt = {}) {
-
-    //_cache
-    let _cache = null
-
-    //url
-    let url = get(opt, 'url')
-    if (!isestr(url)) {
-        url = './db.json'
-    }
-
-    //db
-    let db = get(opt, 'db')
-    if (!isestr(db)) {
-        db = 'worm'
-    }
-
-    //cl
-    let cl = get(opt, 'cl')
-    if (!isestr(cl)) {
-        cl = 'test'
-    }
-
-    //useCache
-    let useCache = get(opt, 'useCache')
-    if (!isbol(useCache)) {
-        useCache = false
-    }
-
-    //key
-    let key = `${db}:${cl}`
-
-    //adapter
-    let adapter = new JSONFile(url)
-
-    //lowdb
-    let lowdb = new Low(adapter, {})
-
-    // //default, 此處偵測會失效, 因操作函數內會通過lowdb.read()初始化, 預設創建空陣列會被取代
-    // if (!haskey(lowdb.data, key)) {
-    //     lowdb.data[key] = []
-    // }
-
-    //ee
-    let ee = new events.EventEmitter()
-
-    //gkey, 基於url也就是以檔案路徑為準, 同檔案路徑須使用全域鎖
-    let gkey = path.resolve(url)
-
-    //全域鎖初始化, 一次僅能執行一種操作函數, 使各類操作url(db.json)時能為獨占模式
-    //select理論上是不用鎖, 但因為操作上db.jon.tmp更名回db.json時似乎非rename而是串流寫入, 導致有機會撈到不完整json數據進而出錯, 故還是得要上鎖以策安全
-    if (!haskey(kpGlock, gkey)) {
-        kpGlock[gkey] = false
-    }
-
-    //getData
-    let getData = async() => {
-
-        //check
-        if (useCache && isarr(_cache)) {
-            return cloneDeep(_cache) //與外部使用數據脫勾
-        }
-
-        //read
-        await lowdb.read()
-
-        //default, 使用lowdb.read()初始化後須馬上檢測, 若無key則須先創建空陣列
-        if (!haskey(lowdb.data, key)) {
-            lowdb.data[key] = []
-        }
-
-        //ltdt
-        let ltdt = cloneDeep(lowdb.data[key]) //數據為lowdb內部的記憶體狀態本體, 須cloneDeep與外部使用數據脫勾
-
-        if (useCache) {
-            _cache = ltdt
-            return cloneDeep(ltdt) //與外部使用數據脫勾
-        }
-        return ltdt
-    }
-
-    /**
-     * 查詢數據
-     *
-     * @memberOf WOrmLowdb
-     * @param {Object} [find={}] 輸入查詢條件物件
-     * @returns {Promise} 回傳Promise，resolve回傳數據，reject回傳錯誤訊息
-     */
-    async function selectCore(find = {}) {
-        let isErr = false
-
-        //res
-        let res = null
-        try {
-
-            //ltdt
-            let ltdt = await getData()
-
-            //filter
-            if (iseobj(find)) {
-
-                //q
-                let q = new Query(find)
-                // console.log('q', q)
-
-                //find
-                res = q.find(ltdt).all()
-                // console.log('res', res)
-
-            }
-            else {
-                res = ltdt
-            }
-
-        }
-        catch (err) {
-            isErr = true
-            res = err
-        }
-
-        if (isErr) {
-            return Promise.reject(res)
-        }
-        return res
-    }
-    async function select(find = {}) {
-        if (kpGlock[gkey]) {
-            await waitFun(() => {
-                return !kpGlock[gkey]
-            })
-        }
-        kpGlock[gkey] = true
-        return await selectCore(find)
-            .finally(() => {
-                kpGlock[gkey] = false
-            })
-    }
-
-    /**
-     * 插入數據，插入同樣數據會自動產生不同_id，故insert前需自行判斷有無重複
-     *
-     * @memberOf WOrmLowdb
-     * @param {Object|Array} data 輸入數據物件或陣列
-     * @returns {Promise} 回傳Promise，resolve回傳插入結果，reject回傳錯誤訊息
-     */
-    async function insertCore(data) {
-        let isErr = false
-
-        //check
-        if (!iseobj(data) && !isearr(data)) {
-            return {
-                n: 0,
-                nInserted: 0,
-                ok: 1,
-            }
-        }
-
-        //cloneDeep, 與外部數據脫勾
-        data = cloneDeep(data)
-
-        //res
-        let res = null
-        try {
-
-            //check
-            if (!isarr(data)) {
-                data = [data]
-            }
-
-            //check id
-            data = map(data, function(v) {
-                if (!isestr(v.id)) {
-                    v.id = genID()
-                }
-                return v
-            })
-
-            //read
-            await lowdb.read()
-
-            //default, 使用lowdb.read()初始化後須馬上檢測, 若無key則須先創建空陣列
-            if (!haskey(lowdb.data, key)) {
-                lowdb.data[key] = []
-            }
-
-            //kp
-            let kp = {}
-            each(lowdb.data[key], (v, k) => {
-                kp[v.id] = { k, v }
-            })
-
-            //each
-            let nAll = size(data)
-            let nPush = 0
-            let b = false
-            each(data, (v) => {
-
-                //check
-                if (!haskey(kp, v.id)) {
-                    //未存在v.id
-
-                    //push
-                    lowdb.data[key].push(v)
-
-                    nPush++
-                    b = true
-                }
-                else {
-                    //已存在v.id則不push
-                }
-
-            })
-
-            //write
-            if (b) {
-                await lowdb.write()
-            }
-
-            //res
-            res = {
-                n: nAll,
-                nInserted: nPush,
-                ok: 1,
-            }
-
-        }
-        catch (err) {
-            isErr = true
-            res = err
-        }
-
-        //update, 不能保證插入多少, 一律重設快取
-        _cache = null
-
-        //emit, 於change可能須使用select, 故須放在重設快取之後
-        if (!isErr) {
-            try {
-
-                //emit
-                ee.emit('change', 'insert', data, res)
-
-            }
-            catch (err) {
-                console.log(err)
-            }
-        }
-
-        if (isErr) {
-            return Promise.reject(res)
-        }
-        return res
-    }
-    async function insert(data) {
-        if (kpGlock[gkey]) {
-            await waitFun(() => {
-                return !kpGlock[gkey]
-            })
-        }
-        kpGlock[gkey] = true
-        return await insertCore(data)
-            .finally(() => {
-                kpGlock[gkey] = false
-            })
-    }
-
-    /**
-     * 儲存數據
-     *
-     * @memberOf WOrmLowdb
-     * @param {Object|Array} data 輸入數據物件或陣列
-     * @param {Object} [option={}] 輸入設定物件，預設為{}
-     * @param {boolean} [option.autoInsert=true] 輸入是否於儲存時發現原本無數據，則自動改以插入處理，預設為true
-     * @returns {Promise} 回傳Promise，resolve回傳儲存結果，reject回傳錯誤訊息
-     */
-    async function saveCore(data, option = {}) {
-        let isErr = false
-
-        //check
-        if (!iseobj(data) && !isearr(data)) {
-            return []
-        }
-
-        //cloneDeep, 與外部數據脫勾
-        data = cloneDeep(data)
-
-        //autoInsert
-        let autoInsert = get(option, 'autoInsert', true)
-
-        //res
-        let res = null
-        try {
-
-            //check
-            if (!isarr(data)) {
-                data = [data]
-            }
-
-            //check id
-            data = map(data, function(v) {
-                if (!isestr(v.id)) {
-                    v.id = genID()
-                }
-                return v
-            })
-
-            //read
-            await lowdb.read()
-
-            //default, 使用lowdb.read()初始化後須馬上檢測, 若無key則須先創建空陣列
-            if (!haskey(lowdb.data, key)) {
-                lowdb.data[key] = []
-            }
-
-            //kp
-            let kp = {}
-            each(lowdb.data[key], (v, k) => {
-                kp[v.id] = { k, v }
-            })
-
-            //pmSeries
-            let b = false
-            res = await pmSeries(data, async(v) => {
-
-                //rest
-                let rest = null
-
-                //查找資料表內v.id
-                let r = get(kp, v.id, null)
-
-                //existed
-                let existed = iseobj(r)
-
-                //check
-                if (existed) {
-                    //已存在v.id
-                    if (isEqual(v, r.v)) {
-                        //內容相同不更新
-                    }
-                    else {
-                        //內容不同須更新
-
-                        //merge
-                        lowdb.data[key][r.k] = merge(lowdb.data[key][r.k], v)
-
-                        rest = { update: true }
-                        b = true
-                    }
-                }
-                else {
-                    //內容不存在
-                }
-
-                //rest
-                if (iseobj(rest)) {
-                    rest = {
-                        n: 1,
-                        nModified: 1,
-                        ok: 1,
-                    }
-                }
-                else {
-                    rest = {
-                        n: 0,
-                        nModified: 0,
-                        ok: 1,
-                    }
-                }
-                //rest.n === 0:
-                // 內容相同不更新, 不須update
-                // 內容不存在, 若autoInsert則須insert
-
-                //autoInsert
-                if (autoInsert && rest.n === 0 && !existed) {
-                    let k = size(lowdb.data[key])
-                    lowdb.data[key].push(v)
-                    kp[v.id] = {
-                        k,
-                        v: lowdb.data[key][k],
-                    }
-                    b = true
-                    rest = {
-                        n: 1,
-                        nInserted: 1,
-                        ok: 1,
-                    }
-                }
-
-                return rest
-            })
-
-            //write
-            if (b) {
-                await lowdb.write()
-            }
-
-        }
-        catch (err) {
-            isErr = true
-            res = err
-        }
-
-        //update, 不能保證變更多少, 一律重設快取
-        _cache = null
-
-        //emit, 於change可能須使用select, 故須放在重設快取之後
-        if (!isErr) {
-            try {
-
-                //emit
-                ee.emit('change', 'save', data, res)
-
-            }
-            catch (err) {
-                console.log(err)
-            }
-        }
-
-        if (isErr) {
-            return Promise.reject(res)
-        }
-        return res
-    }
-    async function save(data, option = {}) {
-        if (kpGlock[gkey]) {
-            await waitFun(() => {
-                return !kpGlock[gkey]
-            })
-        }
-        kpGlock[gkey] = true
-        return await saveCore(data, option)
-            .finally(() => {
-                kpGlock[gkey] = false
-            })
-    }
-
-    /**
-     * 刪除數據
-     *
-     * @memberOf WOrmLowdb
-     * @param {Object|Array} data 輸入數據物件或陣列
-     * @returns {Promise} 回傳Promise，resolve回傳刪除結果，reject回傳錯誤訊息
-     */
-    async function delCore(data) {
-        let isErr = false
-
-        //check
-        if (!iseobj(data) && !isearr(data)) {
-            return []
-        }
-
-        //cloneDeep, 與外部數據脫勾
-        data = cloneDeep(data)
-
-        //res
-        let res = null
-        try {
-
-            //check
-            if (!isarr(data)) {
-                data = [data]
-            }
-
-            //read
-            await lowdb.read()
-
-            //default, 使用lowdb.read()初始化後須馬上檢測, 若無key則須先創建空陣列
-            if (!haskey(lowdb.data, key)) {
-                lowdb.data[key] = []
-            }
-
-            //kp
-            let kp = {}
-            each(lowdb.data[key], (v, k) => {
-                kp[v.id] = { k, v }
-            })
-
-            //pmSeries
-            let ks = []
-            let b = false
-            res = await pmSeries(data, async(v) => {
-
-                //rest
-                let rest = null
-
-                //id
-                let id = get(v, 'id', '')
-
-                //check
-                if (isestr(id)) {
-
-                    //查找資料表內v.id為_v
-                    let r = get(kp, id, null)
-
-                    //check
-                    if (iseobj(r)) {
-                        //已存在v.id則須刪除
-
-                        //push
-                        ks.push(r.k)
-
-                        b = true
-
-                        //rest
-                        rest = {
-                            n: 1,
-                            nDeleted: 1,
-                            ok: 1,
-                        }
-
-                    }
-                    else {
-                        //不存在v.id則不刪除
-
-                        //rest
-                        rest = {
-                            n: 1,
-                            nDeleted: 0,
-                            ok: 1,
-                        }
-
-                    }
-
-                }
-                else {
-                    //未給v.id則不刪除
-
-                    //rest
-                    rest = {
-                        n: 1,
-                        nDeleted: 0,
-                        ok: 0, //未給v.id視為有問題數據, 故ok給0
-                    }
-
-                }
-
-                return rest
-            })
-
-            //update
-            if (b) {
-                lowdb.data[key] = arrPullAt(lowdb.data[key], ks)
-            }
-
-            //write
-            if (b) {
-                await lowdb.write()
-            }
-
-        }
-        catch (err) {
-            isErr = true
-            res = err
-        }
-
-        //update, 不能保證刪除多少, 一律重設快取
-        _cache = null
-
-        //emit, 於change可能須使用select, 故須放在重設快取之後
-        if (!isErr) {
-            try {
-
-                //emit
-                ee.emit('change', 'del', data, res)
-
-            }
-            catch (err) {
-                console.log(err)
-            }
-        }
-
-        if (isErr) {
-            return Promise.reject(res)
-        }
-        return res
-    }
-    async function del(data) {
-        if (kpGlock[gkey]) {
-            await waitFun(() => {
-                return !kpGlock[gkey]
-            })
-        }
-        kpGlock[gkey] = true
-        return await delCore(data)
-            .finally(() => {
-                kpGlock[gkey] = false
-            })
-    }
-
-    /**
-     * 刪除全部數據，需與del分開，避免未傳數據導致直接刪除全表
-     *
-     * @memberOf WOrmLowdb
-     * @param {Object} [find={}] 輸入刪除條件物件
-     * @returns {Promise} 回傳Promise，resolve回傳刪除結果，reject回傳錯誤訊息
-     */
-    async function delAllCore(find = {}) {
-        let isErr = false
-
-        //res
-        let res = null
-        try {
-
-            //read
-            await lowdb.read()
-
-            //default, 使用lowdb.read()初始化後須馬上檢測, 若無key則須先創建空陣列
-            if (!haskey(lowdb.data, key)) {
-                lowdb.data[key] = []
-            }
-
-            //filter
-            let nAll = size(lowdb.data[key])
-            let nDel = 0
-            let b = false
-            if (iseobj(find)) {
-
-                //q
-                let q = new Query(find)
-                // console.log('q', q)
-
-                //find
-                let _res = q.find(lowdb.data[key]).all()
-                // console.log('_res', _res)
-
-                //nDel
-                nDel = size(_res)
-                // console.log('nDel', nDel)
-
-                if (nDel === 0) {
-                    //未有find結果等於不刪除
-                }
-                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)
-                        }
-                    })
-
-                    //update
-                    lowdb.data[key] = arr
-
-                    b = true
-                }
-            }
-            else {
-
-                //nDel
-                nDel = nAll
-
-                //empty
-                lowdb.data[key] = []
-
-                b = true
-            }
-
-            //write
-            if (b) {
-                await lowdb.write()
-            }
-
-            //res
-            res = {
-                n: nAll,
-                nDeleted: nDel,
-                ok: 1,
-            }
-
-        }
-        catch (err) {
-            isErr = true
-            res = err
-        }
-
-        //update, 不能保證刪除多少, 一律重設快取
-        _cache = null
-
-        //emit, 於change可能須使用select, 故須放在重設快取之後
-        if (!isErr) {
-            try {
-
-                //emit
-                ee.emit('change', 'delAll', null, res)
-
-            }
-            catch (err) {
-                console.log(err)
-            }
-        }
-
-        if (isErr) {
-            return Promise.reject(res)
-        }
-        return res
-    }
-    async function delAll(find = {}) {
-        if (kpGlock[gkey]) {
-            await waitFun(() => {
-                return !kpGlock[gkey]
-            })
-        }
-        kpGlock[gkey] = true
-        return await delAllCore(find)
-            .finally(() => {
-                kpGlock[gkey] = false
-            })
-    }
-
-    //bind
-    ee.select = select
-    ee.insert = insert
-    ee.save = save
-    ee.del = del
-    ee.delAll = delAll
-
-    return ee
-}
-
-
-export default WOrmLowdb
+import path from 'path'
+import { Low } from 'lowdb'
+import { JSONFile } from 'lowdb/node'
+import { Query } from 'mingo'
+import get from 'lodash-es/get.js'
+import each from 'lodash-es/each.js'
+import map from 'lodash-es/map.js'
+import filter from 'lodash-es/filter.js'
+import merge from 'lodash-es/merge.js'
+import isEqual from 'lodash-es/isEqual.js'
+import size from 'lodash-es/size.js'
+import cloneDeep from 'lodash-es/cloneDeep.js'
+import evem from 'wsemi/src/evem.mjs'
+import genIDSeq from 'wsemi/src/genIDSeq.mjs'
+import pmSeries from 'wsemi/src/pmSeries.mjs'
+import isarr from 'wsemi/src/isarr.mjs'
+import isbol from 'wsemi/src/isbol.mjs'
+import isestr from 'wsemi/src/isestr.mjs'
+import iseobj from 'wsemi/src/iseobj.mjs'
+import isearr from 'wsemi/src/isearr.mjs'
+import haskey from 'wsemi/src/haskey.mjs'
+
+
+//kpGqueue, 以資料庫檔案路徑為鍵之全域序列化佇列, 詳見下方serialize說明
+let kpGqueue = {}
+
+
+/**
+ * 操作資料庫(lowdb)
+ *
+ * 回傳物件為EventEmitter，除各操作函數外另發出change與error兩事件，供呼叫端於單一處集中觀察資料異動與失敗。
+ * 事件僅為附加通知，其所送出之資訊皆另有正規管道(操作結果經resolve、整批性錯誤經reject、逐筆失敗經該筆之err欄位)，
+ * 故不監聽亦能取得完整資訊，且監聽與否不改變任何操作之回傳值。
+ *
+ * change事件，參數為(mode, data, res)，於資料實際異動成功後發出：
+ * mode為操作別字串，可為'insert'、'insertBulk'、'save'、'del'、'delAll'；save內若逐筆走自動插入則該筆另發出mode為'insert'之事件。
+ * data為本次操作之輸入數據，delAll固定為null。
+ * res為本次操作之回傳結果。
+ * 逐筆函數以整批為單位發出一次而不逐筆發出，select與selectByPk不發出本事件。
+ *
+ * error事件，參數為(mode, data, err)，於操作發生錯誤時發出：
+ * mode為操作別字串，可為'select'、'selectByPk'、'insert'、'insertBulk'、'save'、'del'、'delAll'。
+ * data為本次操作之輸入數據，無輸入數據者為null。
+ * err為錯誤訊息字串，內容與正規管道所送出者一致。
+ * 整批性錯誤於reject之前發出；逐筆失敗於該筆結果定案後發出，每筆一次。
+ * 註: 逐筆失敗時整批仍resolve，故收到本事件不表示該次呼叫失敗；正常結果(如查無數據、主鍵未命中、全數已存在)不發出本事件。
+ *
+ * 註: 本套件之主鍵欄位固定為id，尚未支援指定其他欄位為主鍵。
+ * 註: 本套件之寫入為[整檔讀出、記憶體修改、整檔寫回]，其原子性由行程內之序列化佇列提供，
+ * 故僅單一行程內併發成立，跨行程併發不成立，詳見README之併發保證宣告。
+ *
+ * @class
+ * @param {Object} [opt={}] 輸入設定物件，預設{}
+ * @param {String} [opt.url='./db.json'] 輸入資料庫位置字串，預設'./db.json'
+ * @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、insertBulk與save於數據未帶有效主鍵(本套件為id欄位)時是否自動產生主鍵值，預設true；給false代表主鍵改由呼叫端自備，套件不產生亦不檢查其唯一性與格式，未帶有效主鍵者將reject
+ * @returns {Object} 回傳操作資料庫物件，各事件功能詳見說明
+ */
+function WOrmLowdb(opt = {}) {
+
+    //_cache
+    let _cache = null
+
+    //url
+    let url = get(opt, 'url')
+    if (!isestr(url)) {
+        url = './db.json'
+    }
+
+    //db
+    let db = get(opt, 'db')
+    if (!isestr(db)) {
+        db = 'worm'
+    }
+
+    //cl
+    let cl = get(opt, 'cl')
+    if (!isestr(cl)) {
+        cl = 'test'
+    }
+
+    //useCache
+    let useCache = get(opt, 'useCache')
+    if (!isbol(useCache)) {
+        useCache = false
+    }
+
+    //autoGenPk, 主鍵由誰產生為整個資料表之政策, 故為建構層設定, 不可於各寫入函數之option逐次覆寫,
+    //否則同一資料表將混入兩種來源之主鍵而難以追溯
+    let autoGenPk = get(opt, 'autoGenPk')
+    if (!isbol(autoGenPk)) {
+        autoGenPk = true
+    }
+
+    //key
+    let key = `${db}:${cl}`
+
+    //adapter
+    let adapter = new JSONFile(url)
+
+    //lowdb
+    let lowdb = new Low(adapter, {})
+
+    //ee
+    let ee = evem() //採eventemitter3, 其於'error'無監聽者時僅回傳false而不拋出, 故操作行為不因監聽者之有無而改變
+
+    //gkey, 基於url也就是以檔案路徑為準, 同檔案路徑須使用同一佇列
+    let gkey = path.resolve(url)
+
+    //佇列初始化, 同一資料庫檔案之全部操作一律序列化
+    if (!haskey(kpGqueue, gkey)) {
+        kpGqueue[gkey] = Promise.resolve()
+    }
+
+    /**
+     * 序列化同一資料庫檔案之操作
+     *
+     * 本套件之寫入為[整檔讀出、記憶體修改、整檔寫回]，lowdb無條件寫入亦無比較並交換，
+     * 故insert之[檢查主鍵不存在與寫入]與save之[查找主鍵與更新或插入]，其原子性只能由行程內之序列化達成。
+     * 採Promise鏈而非[布林旗標配合輪詢等待]，係因後者之[檢查旗標]與[設定旗標]之間隔有await，
+     * 並非原子之test-and-set，多個等候者之輪詢若落在同一批timer觸發即會同時進入臨界區；
+     * 且輪詢函數逾時後為resolve而非reject，等滿即照樣放行。Promise鏈為嚴格FIFO且無逾時放行，由結構保證互斥。
+     * select亦納入序列化，令其不致與寫入之整檔替換交錯。
+     *
+     * 註: 佇列為module層之變數，僅同一行程內共享，故跨行程併發不受此保護。
+     */
+    let serialize = (fn) => {
+
+        //pmPrev, 恆為已攔截錯誤之Promise, 故前一次操作失敗不會中斷佇列
+        let pmPrev = kpGqueue[gkey]
+
+        //pm
+        let pm = pmPrev.then(() => {
+            return fn()
+        })
+
+        //update, 存入已攔截錯誤者, 避免本次reject成為unhandled
+        kpGqueue[gkey] = pm.catch(() => {})
+
+        return pm
+    }
+
+    //emitChange, 資料實際異動成功後發出, 事件僅為附加通知不承擔回傳義務
+    //一律包try/catch, 令訂閱函數自身拋錯不影響本次操作之結果
+    let emitChange = (mode, data, res) => {
+        try {
+            ee.emit('change', mode, data, res)
+        }
+        catch (err) {
+            console.log(err)
+        }
+    }
+
+    //emitError, 操作發生錯誤時發出, 錯誤訊息一律轉為字串
+    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)) {
+            return m
+        }
+        return String(err)
+    }
+
+    //procPk, 依autoGenPk處理各數據之主鍵, 供insert、insertBulk與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
+    }
+
+    //readData, 讀取資料庫檔案並取得本資料表之陣列
+    //註: 使用lowdb.read()初始化後須馬上檢測, 若無key則須先創建空陣列
+    let readData = async() => {
+        await lowdb.read()
+        if (!haskey(lowdb.data, key)) {
+            lowdb.data[key] = []
+        }
+        return lowdb.data[key]
+    }
+
+    //writeData, 以新陣列取代本資料表後寫檔
+    //寫檔失敗時還原記憶體狀態, 令reject之後之記憶體與檔案一致,
+    //否則殘留之修改會於下次寫入時被一併帶出, 使本應未生效之數據落盤
+    let writeData = async(arrOld, arrNew) => {
+        lowdb.data[key] = arrNew
+        try {
+            await lowdb.write()
+        }
+        catch (err) {
+            lowdb.data[key] = arrOld
+            throw err
+        }
+    }
+
+    //getKpPk, 由數據陣列建立[主鍵值 => {k, v}]之對照表, k為所在索引
+    //僅收錄具有效主鍵值者, 令資料表內若有主鍵值無效之殘留數據不致被誤配為命中
+    let getKpPk = (ltdt) => {
+        let kp = {}
+        each(ltdt, (v, k) => {
+            let id = get(v, 'id')
+            if (isestr(id)) {
+                kp[id] = { k, v }
+            }
+        })
+        return kp
+    }
+
+    //getData
+    let getData = async() => {
+
+        //check
+        if (useCache && isarr(_cache)) {
+            return cloneDeep(_cache) //與外部使用數據脫勾
+        }
+
+        //read
+        let ltdt = await readData()
+
+        //cloneDeep, 數據為lowdb內部的記憶體狀態本體, 須cloneDeep與外部使用數據脫勾
+        ltdt = cloneDeep(ltdt)
+
+        if (useCache) {
+            _cache = ltdt
+            return cloneDeep(ltdt) //與外部使用數據脫勾
+        }
+        return ltdt
+    }
+
+    /**
+     * 查詢數據
+     *
+     * @memberOf WOrmLowdb
+     * @param {Object} [find={}] 輸入查詢條件物件
+     * @returns {Promise} 回傳Promise，resolve回傳數據陣列，無符合數據回傳空陣列，reject回傳錯誤訊息
+     */
+    async function selectCore(find = {}) {
+        let isErr = false
+
+        //res
+        let res = null
+        try {
+
+            //ltdt
+            let ltdt = await getData()
+
+            //filter
+            if (iseobj(find)) {
+
+                //q
+                let q = new Query(find)
+                // console.log('q', q)
+
+                //find
+                res = q.find(ltdt).all()
+                // console.log('res', res)
+
+            }
+            else {
+                res = ltdt
+            }
+
+            //check
+            if (!isarr(res)) {
+                isErr = true
+                res = new Error(`can not select by find[${JSON.stringify(find)}]`)
+            }
+
+        }
+        catch (err) {
+            isErr = true
+            res = err
+        }
+
+        //check
+        if (isErr) {
+
+            //emit, 整批性錯誤須於reject之前發出
+            emitError('select', null, res)
+
+            return Promise.reject(res)
+        }
+
+        return res
+    }
+    async function select(find = {}) {
+        return serialize(() => selectCore(find))
+    }
+
+    /**
+     * 由主鍵查詢單筆數據
+     * 註: 本套件之主鍵欄位固定為id，尚未支援指定其他欄位為主鍵
+     * 註: lowdb無索引，本函數仍須讀取全表，故較select僅省去查詢條件之過濾而無數量級之效能差異，
+     * 提供本函數係為與其他w-orm系列套件維持同一組函數
+     *
+     * @memberOf WOrmLowdb
+     * @param {String} pk 輸入主鍵值字串，本套件之主鍵欄位為id
+     * @returns {Promise} 回傳Promise，resolve回傳數據物件，若無此主鍵或主鍵值無效則回傳null，reject回傳錯誤訊息
+     */
+    async function selectByPkCore(pk) {
+        let isErr = false
+
+        //res
+        let res = null
+        try {
+
+            //check
+            if (!isestr(pk)) {
+                //未給有效主鍵值視為查無數據
+                return null
+            }
+
+            //ltdt
+            let ltdt = await getData()
+
+            //查找資料表內pk, 判定基準與insert、insertBulk、save、del內對既有數據之認定一致(皆以id之字串值比對)
+            let kp = getKpPk(ltdt)
+            let r = get(kp, pk, null)
+
+            //check
+            if (iseobj(r)) {
+                res = r.v
+            }
+            else {
+                //不存在此主鍵, 回傳null
+                res = null
+            }
+
+        }
+        catch (err) {
+            isErr = true
+            res = err
+        }
+
+        //check
+        if (isErr) {
+
+            //emit, 整批性錯誤須於reject之前發出
+            emitError('selectByPk', null, res)
+
+            return Promise.reject(res)
+        }
+
+        return res
+    }
+    async function selectByPk(pk) {
+        return serialize(() => selectByPkCore(pk))
+    }
+
+    /**
+     * 插入數據，僅於主鍵不存在時寫入，已存在者跳過且不覆寫
+     *
+     * @memberOf WOrmLowdb
+     * @param {Object|Array} data 輸入數據物件或陣列
+     * @param {Object} [option={}] 輸入設定物件，預設為{}
+     * @param {Boolean} [option.returnList=false] 輸入是否改回傳逐筆結果布林值，預設false。給true時回傳與輸入等長保序之陣列，各筆為{n,nInserted,ok}，nInserted為1即該筆為新增；聚合計數只回答有幾筆是新的，逐筆結果方能回答是哪幾筆，供下游僅對新資料執行昂貴動作。回傳形式由呼叫點靜態決定，共用之結果處理程式碼不可跨不同取值之呼叫點混用
+     * @returns {Promise} 回傳Promise，resolve依returnList回傳插入結果：預設回傳聚合物件{n,nInserted,ok}，n為輸入筆數、nInserted為實際插入筆數；returnList為true時回傳逐筆陣列，各筆n恆為1(主鍵命中或經插入)、ok恆為1(insert之錯誤皆屬整批性而reject，不進逐筆)；reject回傳錯誤訊息
+     */
+    async function insertCore(data, option = {}) {
+        let isErr = false
+
+        //returnList
+        let returnList = get(option, 'returnList')
+        if (!isbol(returnList)) {
+            returnList = false
+        }
+
+        //check
+        if (!iseobj(data) && !isearr(data)) {
+            if (returnList) {
+                //輸入無效, 對齊save與del之空陣列規定
+                return []
+            }
+            return {
+                n: 0,
+                nInserted: 0,
+                ok: 1,
+            }
+        }
+
+        //cloneDeep, 與外部數據脫勾
+        data = cloneDeep(data)
+
+        //res
+        let res = null
+        try {
+
+            //check
+            if (!isarr(data)) {
+                data = [data]
+            }
+
+            //check id
+            data = procPk(data, 'insert')
+
+            //read
+            let arrOld = await readData()
+
+            //kp
+            let kp = getKpPk(arrOld)
+
+            //each
+            let nAll = size(data)
+            let ltdone = []
+            let ltpush = []
+            each(data, (v) => {
+
+                //check
+                if (!haskey(kp, v.id)) {
+                    //未存在v.id
+
+                    //push
+                    ltpush.push(v)
+
+                    //update, 須同步更新kp, 否則同批含重複主鍵者會全數寫入而出現重複主鍵
+                    kp[v.id] = { k: -1, v }
+
+                    ltdone.push(true)
+                }
+                else {
+                    //已存在v.id(含同批重複之非首筆)則不push
+                    ltdone.push(false)
+                }
+
+            })
+
+            //write, 未有須插入者即不寫檔, 全數已存在屬正常結果
+            if (size(ltpush) > 0) {
+                await writeData(arrOld, [...arrOld, ...ltpush])
+            }
+
+            //res
+            if (returnList) {
+                //逐筆結果, 與輸入等長保序, 元素沿用逐筆結果之家族形狀(同save與del之元素)
+                //n恆為1(主鍵命中既有或經插入而產生), ok恆為1(insert之錯誤皆屬整批性而reject, 不進逐筆),
+                //資訊由nInserted承載, filter(v=>v.nInserted===1)之長度必等於聚合模式之nInserted
+                res = map(ltdone, function(done) {
+                    return {
+                        n: 1,
+                        nInserted: done ? 1 : 0,
+                        ok: 1,
+                    }
+                })
+            }
+            else {
+                res = {
+                    n: nAll,
+                    nInserted: size(ltpush),
+                    ok: 1,
+                }
+            }
+
+        }
+        catch (err) {
+            isErr = true
+            res = err
+        }
+
+        //update, 不能保證插入多少, 一律重設快取
+        _cache = null
+
+        //emit, 於change可能須使用select, 故須放在重設快取之後
+        if (!isErr) {
+            emitChange('insert', data, res)
+        }
+
+        //check
+        if (isErr) {
+
+            //emit, 整批性錯誤須於reject之前發出
+            emitError('insert', data, res)
+
+            return Promise.reject(res)
+        }
+
+        return res
+    }
+    async function insert(data, option = {}) {
+        return serialize(() => insertCore(data, option))
+    }
+
+    /**
+     * 批次插入數據，全批視為一個單位，全部插入成功或一筆都不寫入
+     * 註: 本函數非insert之加速版，兩者衝突政策不同。insert於主鍵已存在時跳過該筆而整批ok為1，
+     * 本函數則整批reject且不寫入任何一筆；同批含重複主鍵者亦視為衝突。確無衝突時兩者結果相同
+     * 註: 於本套件不會較insert快，因兩者皆為一次讀檔與一次寫檔，
+     * 提供本函數係為與其他w-orm系列套件維持同一組函數，令呼叫端得於各套件間替換而不須改寫呼叫
+     *
+     * @memberOf WOrmLowdb
+     * @param {Object|Array} data 輸入數據物件或陣列
+     * @returns {Promise} 回傳Promise，resolve回傳插入結果物件{n,nInserted,ok}，n為輸入筆數、nInserted成功時恆等於n，任一筆主鍵已存在則reject回傳錯誤訊息
+     */
+    async function insertBulkCore(data) {
+        let isErr = false
+
+        //check
+        if (!iseobj(data) && !isearr(data)) {
+            return {
+                n: 0,
+                nInserted: 0,
+                ok: 1,
+            }
+        }
+
+        //cloneDeep, 與外部數據脫勾
+        data = cloneDeep(data)
+
+        //res
+        let res = null
+        try {
+
+            //check
+            if (!isarr(data)) {
+                data = [data]
+            }
+
+            //check id
+            data = procPk(data, 'insertBulk')
+
+            //read
+            let arrOld = await readData()
+
+            //kp
+            let kp = getKpPk(arrOld)
+
+            //nAll
+            let nAll = size(data)
+
+            //check, 主鍵檢查於任何寫入之前一次完成, 任一筆衝突即整批中止,
+            //同批含重複主鍵者亦於此被偵測為衝突(kp隨檢查同步更新)
+            let pkConflict = null
+            each(data, (v) => {
+                if (haskey(kp, v.id)) {
+                    pkConflict = v.id
+                    return false //中止each
+                }
+                kp[v.id] = { k: -1, v }
+            })
+
+            //check
+            if (pkConflict !== null) {
+                throw new Error(`can not insertBulk by existed id[${pkConflict}]`)
+            }
+
+            //write, 全部通過檢查方寫入, 且寫檔為單次[寫暫存檔後更名]之原子替換,
+            //故全有全無成立: 檢查失敗時尚未修改任何狀態, 寫檔失敗時writeData會還原記憶體
+            await writeData(arrOld, [...arrOld, ...data])
+
+            //res, 未衝突則全數插入, 故nInserted恆等於n
+            res = {
+                n: nAll,
+                nInserted: nAll,
+                ok: 1,
+            }
+
+        }
+        catch (err) {
+            isErr = true
+            res = err
+        }
+
+        //update, 不能保證插入多少, 一律重設快取
+        _cache = null
+
+        //emit, 於change可能須使用select, 故須放在重設快取之後
+        if (!isErr) {
+            emitChange('insertBulk', data, res)
+        }
+
+        //check
+        if (isErr) {
+
+            //emit, 整批性錯誤須於reject之前發出
+            emitError('insertBulk', data, res)
+
+            return Promise.reject(res)
+        }
+
+        return res
+    }
+    async function insertBulk(data) {
+        return serialize(() => insertBulkCore(data))
+    }
+
+    /**
+     * 儲存數據，以主鍵為準更新既有數據，未給之欄位保留；主鍵不存在且autoInsert為true時改為插入
+     *
+     * @memberOf WOrmLowdb
+     * @param {Object|Array} data 輸入數據物件或陣列
+     * @param {Object} [option={}] 輸入設定物件，預設為{}
+     * @param {boolean} [option.autoInsert=true] 輸入是否於儲存時發現原本無數據，則自動改以插入處理，預設為true
+     * @returns {Promise} 回傳Promise，resolve回傳與輸入等長之儲存結果陣列，各筆為{n,nInserted,nModified,ok}，n為主鍵命中筆數，單筆失敗者ok為0並附err，reject回傳錯誤訊息
+     */
+    async function saveCore(data, option = {}) {
+        let isErr = false
+
+        //check
+        if (!iseobj(data) && !isearr(data)) {
+            return []
+        }
+
+        //cloneDeep, 與外部數據脫勾
+        data = cloneDeep(data)
+
+        //autoInsert
+        let autoInsert = get(option, 'autoInsert', true)
+
+        //res
+        let res = null
+        try {
+
+            //check
+            if (!isarr(data)) {
+                data = [data]
+            }
+
+            //check id
+            data = procPk(data, 'save')
+
+            //read
+            let arrOld = await readData()
+
+            //arrNew, 逐筆修改於複本上進行, 全部完成後方取代與寫檔
+            let arrNew = [...arrOld]
+
+            //kp
+            let kp = getKpPk(arrNew)
+
+            //pmSeries
+            let b = false
+            res = await pmSeries(data, async(v) => {
+
+                //rest
+                let rest = null
+
+                try {
+
+                    //查找資料表內v.id
+                    let r = get(kp, v.id, null)
+
+                    //existed
+                    let existed = iseobj(r)
+
+                    //check
+                    if (existed) {
+                        //已存在v.id
+
+                        //vv, 現值
+                        let vv = r.v
+
+                        //vm, 合併後之結果, 另建新物件以免污染原數據
+                        let vm = merge({}, vv, v)
+
+                        //判定基準為[合併後結果與現值相同], 而非[待寫入物件與現值全等],
+                        //令nModified忠實反映是否真的寫入, 僅給部份欄位且值皆相同者不應回報已修改
+                        if (isEqual(vm, vv)) {
+                            //合併後與現值相同不須寫入, 惟已命中v.id故n為1
+                            rest = {
+                                n: 1,
+                                nInserted: 0,
+                                nModified: 0,
+                                ok: 1,
+                            }
+                        }
+                        else {
+                            //合併後與現值不同須更新
+
+                            //update
+                            arrNew[r.k] = vm
+                            kp[v.id] = { k: r.k, v: vm }
+
+                            b = true
+
+                            rest = {
+                                n: 1,
+                                nInserted: 0,
+                                nModified: 1,
+                                ok: 1,
+                            }
+                        }
+
+                    }
+                    else {
+                        //不存在v.id, 若autoInsert則須插入
+                        if (autoInsert) {
+
+                            //push
+                            let k = size(arrNew)
+                            arrNew.push(v)
+                            kp[v.id] = { k, v }
+
+                            b = true
+
+                            rest = {
+                                n: 1,
+                                nInserted: 1,
+                                nModified: 0,
+                                ok: 1,
+                            }
+
+                        }
+                        else {
+                            //未命中且未開啟autoInsert, 未命中故n為0
+                            rest = {
+                                n: 0,
+                                nInserted: 0,
+                                nModified: 0,
+                                ok: 1,
+                            }
+                        }
+                    }
+
+                }
+                catch (err) {
+
+                    //本筆失敗不中斷整批, 以ok為0並附err回報, 由呼叫端逐筆檢查
+                    rest = {
+                        n: 1,
+                        nInserted: 0,
+                        nModified: 0,
+                        ok: 0,
+                        err: getErrMsg(err),
+                    }
+
+                }
+
+                return rest
+            })
+
+            //write
+            if (b) {
+                await writeData(arrOld, arrNew)
+            }
+
+        }
+        catch (err) {
+            isErr = true
+            res = err
+        }
+
+        //update, 不能保證變更多少, 一律重設快取
+        _cache = null
+
+        //emit, 於change可能須使用select, 故須放在重設快取之後
+        if (!isErr) {
+
+            //emit, 逐筆失敗於該筆結果定案後發出, 每筆一次
+            //此事件之發出不表示整批失敗, 整批仍resolve, 該筆以ok為0回報
+            each(res, (rest, k) => {
+                if (get(rest, 'ok') === 0) {
+                    emitError('save', [get(data, k)], get(rest, 'err'))
+                }
+            })
+
+            //emit, 逐筆插入另發出mode為insert之事件, 供呼叫端區辨新增與更新
+            //逐筆結果與輸入等長保序, 故由nInserted即可定位係哪幾筆走插入, 不須另行記錄
+            each(res, (rest, k) => {
+                if (get(rest, 'nInserted') === 1) {
+                    emitChange('insert', [get(data, k)], rest)
+                }
+            })
+
+            //emit, 逐筆失敗之error事件已於上方發出, 故必早於本整批change
+            emitChange('save', data, res)
+
+        }
+
+        //check
+        if (isErr) {
+
+            //emit, 整批性錯誤須於reject之前發出
+            emitError('save', data, res)
+
+            return Promise.reject(res)
+        }
+
+        return res
+    }
+    async function save(data, option = {}) {
+        return serialize(() => saveCore(data, option))
+    }
+
+    /**
+     * 刪除數據，依主鍵刪除
+     *
+     * @memberOf WOrmLowdb
+     * @param {Object|Array} data 輸入數據物件或陣列
+     * @returns {Promise} 回傳Promise，resolve回傳與輸入等長之刪除結果陣列，各筆為{n,nDeleted,ok}，n為主鍵命中筆數，單筆失敗或未給有效id者ok為0並附err，reject回傳錯誤訊息
+     */
+    async function delCore(data) {
+        let isErr = false
+
+        //check
+        if (!iseobj(data) && !isearr(data)) {
+            return []
+        }
+
+        //cloneDeep, 與外部數據脫勾
+        data = cloneDeep(data)
+
+        //res
+        let res = null
+        try {
+
+            //check
+            if (!isarr(data)) {
+                data = [data]
+            }
+
+            //read
+            let arrOld = await readData()
+
+            //kp
+            let kp = getKpPk(arrOld)
+
+            //pmSeries
+            let kpDel = {}
+            let b = false
+            res = await pmSeries(data, async(v) => {
+
+                //rest
+                let rest = null
+
+                try {
+
+                    //id
+                    let id = get(v, 'id', '')
+
+                    //check
+                    if (!isestr(id)) {
+                        //未給有效v.id視為該筆數據有問題而無法處理, 以ok為0並附err回報,
+                        //與[已給v.id但查無數據]之ok為1有別, 二者須可由ok分辨
+                        //註: 亦不可將無效主鍵送進查詢條件, 故於此直接定案
+                        rest = {
+                            n: 0,
+                            nDeleted: 0,
+                            ok: 0,
+                            err: `can not delete by invalid id[${id}]`,
+                        }
+                    }
+                    else {
+
+                        //查找資料表內v.id
+                        let r = get(kp, id, null)
+
+                        //check
+                        if (iseobj(r)) {
+                            //已存在v.id則須刪除
+
+                            //push
+                            kpDel[r.k] = true
+
+                            //update, 須同步移除, 否則同批重複主鍵者會重複計入nDeleted
+                            delete kp[id]
+
+                            b = true
+
+                            rest = {
+                                n: 1,
+                                nDeleted: 1,
+                                ok: 1,
+                            }
+
+                        }
+                        else {
+                            //不存在v.id則不刪除, 未命中故n為0
+                            rest = {
+                                n: 0,
+                                nDeleted: 0,
+                                ok: 1,
+                            }
+
+                        }
+
+                    }
+
+                }
+                catch (err) {
+
+                    //本筆失敗不中斷整批, 以ok為0並附err回報, 由呼叫端逐筆檢查
+                    rest = {
+                        n: 1,
+                        nDeleted: 0,
+                        ok: 0,
+                        err: getErrMsg(err),
+                    }
+
+                }
+
+                return rest
+            })
+
+            //write
+            if (b) {
+                let arrNew = filter(arrOld, (v, k) => {
+                    return !haskey(kpDel, k)
+                })
+                await writeData(arrOld, arrNew)
+            }
+
+        }
+        catch (err) {
+            isErr = true
+            res = err
+        }
+
+        //update, 不能保證刪除多少, 一律重設快取
+        _cache = null
+
+        //emit, 於change可能須使用select, 故須放在重設快取之後
+        if (!isErr) {
+
+            //emit, 逐筆失敗於該筆結果定案後發出, 每筆一次
+            //此事件之發出不表示整批失敗, 整批仍resolve, 該筆以ok為0回報
+            each(res, (rest, k) => {
+                if (get(rest, 'ok') === 0) {
+                    emitError('del', [get(data, k)], get(rest, 'err'))
+                }
+            })
+
+            //emit, 逐筆失敗之error事件已於上方發出, 故必早於本整批change
+            emitChange('del', data, res)
+
+        }
+
+        //check
+        if (isErr) {
+
+            //emit, 整批性錯誤須於reject之前發出
+            emitError('del', data, res)
+
+            return Promise.reject(res)
+        }
+
+        return res
+    }
+    async function del(data) {
+        return serialize(() => delCore(data))
+    }
+
+    /**
+     * 刪除全部數據，需與del分開，避免未傳數據導致直接刪除全表
+     *
+     * @memberOf WOrmLowdb
+     * @param {Object} [find={}] 輸入刪除條件物件
+     * @returns {Promise} 回傳Promise，resolve回傳刪除結果物件{n,nDeleted,ok}，n與nDeleted同為實際刪除筆數，reject回傳錯誤訊息
+     */
+    async function delAllCore(find = {}) {
+        let isErr = false
+
+        //res
+        let res = null
+        try {
+
+            //read
+            let arrOld = await readData()
+
+            //filter
+            let nAll = size(arrOld)
+            let nDel = 0
+            let arrNew = null
+            if (iseobj(find)) {
+
+                //q
+                let q = new Query(find)
+                // console.log('q', q)
+
+                //filter, 以與select同一條件逐筆判定, 保留未命中者
+                arrNew = filter(arrOld, (v) => {
+                    return !q.test(v)
+                })
+
+                //nDel
+                nDel = nAll - size(arrNew)
+                // console.log('nDel', nDel)
+
+            }
+            else {
+                //find未給或為空物件時刪除全部數據
+
+                //nDel
+                nDel = nAll
+
+                //empty
+                arrNew = []
+
+            }
+
+            //write, 無命中即不寫檔, 屬正常結果
+            if (nDel > 0) {
+                await writeData(arrOld, arrNew)
+            }
+
+            //res, n為實際刪除筆數而非全表筆數, 故與nDeleted同值
+            res = {
+                n: nDel,
+                nDeleted: nDel,
+                ok: 1,
+            }
+
+        }
+        catch (err) {
+            isErr = true
+            res = err
+        }
+
+        //update, 不能保證刪除多少, 一律重設快取
+        _cache = null
+
+        //emit, 於change可能須使用select, 故須放在重設快取之後
+        if (!isErr) {
+            emitChange('delAll', null, res)
+        }
+
+        //check
+        if (isErr) {
+
+            //emit, 整批性錯誤須於reject之前發出
+            emitError('delAll', null, res)
+
+            return Promise.reject(res)
+        }
+
+        return res
+    }
+    async function delAll(find = {}) {
+        return serialize(() => delAllCore(find))
+    }
+
+    //bind
+    ee.select = select
+    ee.selectByPk = selectByPk
+    ee.insert = insert
+    ee.insertBulk = insertBulk
+    ee.save = save
+    ee.del = del
+    ee.delAll = delAll
+
+    return ee
+}
+
+
+export default WOrmLowdb