w-serv-orm 1.1.17 → 1.1.18

package/src/isOrmFail.mjs

@@ -0,0 +1,30 @@
+import size from 'lodash-es/size.js'
+import getItemsFail from 'w-data-collector/src/getItemsFail.mjs'
+
+
+/**
+ * 判斷ORM寫入類函數(insert、save、del、delAll)之回傳結果是否回報失敗
+ *
+ * 依w-orm系列規格，insert與delAll回傳聚合物件且ok恆為1，save與del回傳逐筆陣列，錯誤皆整批reject；單筆失敗者(save、del)於該筆以ok為0回報。
+ * 本函數不論函數與形狀一律判讀：回傳為聚合物件(非null、非陣列之物件)而ok為0者(ORM違約或他種後端)視為失敗；
+ * 回傳為逐筆陣列而任一筆ok為0者(同getItemsFail之判讀)視為失敗。
+ * 其餘(undefined、null、無ok鍵之物件、空陣列、元素皆ok非0或非物件之陣列、ok為1含略過既有主鍵或未命中之n為0)不視為失敗，維持舊行為。
+ * 讀取函數(select)之回傳為數據列，列內欄位可能名為ok，不得以本函數判讀。
+ * 供procOrm之寫入類各模式、mix之各步驟、備份還原與測試數據寫入共用。
+ *
+ * @param {*} r 輸入ORM寫入類函數之回傳結果
+ * @returns {Boolean} 回傳是否回報失敗
+ */
+function isOrmFail(r) {
+
+    //check, 逐筆陣列
+    if (Array.isArray(r)) {
+        return size(getItemsFail(r, [])) > 0
+    }
+
+    //check, 聚合物件
+    return r !== null && typeof r === 'object' && r.ok === 0
+}
+
+
+export default isOrmFail

package/test/api-procOrm.test.mjs

@@ -92,3 +92,145 @@ describe('procOrm接w-orm-lowdb', function() {
     })
 
 })
+
+
+//R-PERITEM-01 規則4(orm-run03、run04): 包一層真ORM(w-orm-lowdb), 令insert於injectInsert為true時第0筆不寫入、其餘筆照常寫入, 並回傳聚合物件而ok為0; 為'array'時回傳逐筆陣列而第0筆ok為0(模擬違約之ORM, w-orm-lowdb實際不會如此); 其餘操作原樣
+let fdIns = './test/_tmp/api-procOrm-insertfail'
+let injectInsert = false
+//R-ORM-RESULT-01(orm-run05): injectOther為'save'、'del'或'delAll'時, 該操作照常執行後回傳聚合物件而ok為0(非契約形狀, 模擬違約之ORM)
+let injectOther = null
+function WOrmInsertFail(...args) {
+    let wo = WOrm(...args)
+    for (let m of ['save', 'del', 'delAll']) {
+        let orig = wo[m]
+        wo[m] = async (...a) => {
+            let r = await orig(...a)
+            return injectOther === m ? { n: 1, ok: 0, err: 'E-agg' } : r
+        }
+    }
+    let insertOrig = wo.insert
+    wo.insert = async (data) => {
+        if (!injectInsert) {
+            return insertOrig(data)
+        }
+        let rows = Array.isArray(data) ? data : [data]
+        let rest = rows.slice(1)
+        if (rest.length > 0) {
+            await insertOrig(rest)
+        }
+        if (injectInsert === 'array') {
+            return rows.map((v, k) => (k === 0 ? { n: 1, nInserted: 0, ok: 0, err: 'E-ins' } : { n: 1, nInserted: 1, ok: 1 }))
+        }
+        return { n: rows.length, nInserted: rest.length, ok: 0, err: 'E-ins' }
+    }
+    return wo
+}
+
+
+describe('procOrm接insert回報ok為0之w-orm-lowdb', function() {
+
+    let so = null
+    let proc = (mode, input) => so.procOrm('u1', 'tests', mode, input)
+    let getIds = async () => (await so.woItems.tests.select({})).map((v) => v.id).sort()
+
+    before(function() {
+        fs.rmSync(fdIns, { recursive: true, force: true })
+        fs.mkdirSync(fdIns, { recursive: true })
+        so = WServOrm(ds, WOrmInsertFail, `${fdIns}/db.json`, 'worm')
+    })
+
+    beforeEach(async function() {
+        injectInsert = false
+        injectOther = null
+        await so.woItems.tests.delAll({})
+        await so.woItems.tests.insert([{ id: 'x1' }, { id: 'x2' }, { id: 'x3' }])
+    })
+
+    after(async function() {
+        injectInsert = false
+        injectOther = null
+        await so.closeAll()
+        fs.rmSync(fdIns, { recursive: true, force: true })
+    })
+
+    it('F01 insert之ORM回報ok為0時reject而不回成功', async function() {
+        //規則4: 聚合結果ok為0視為失敗; 已寫入之筆無從回復(ORM違約, 第1筆已寫入、第0筆未寫入), 但呼叫端得知失敗
+        injectInsert = true
+        let err = await getReject(proc('insert', [{ id: 'n1' }, { id: 'n2' }]))
+        assert.strict.equal(err, 'failed to insert data')
+        assert.strict.deepEqual(await getIds(), ['n2', 'x1', 'x2', 'x3'])
+    })
+
+    it('F02 mix之add之ORM回報ok為0時reject且後續del不執行', async function() {
+        //規則4: add為首步, 聚合結果ok為0即立即reject, del步驟不執行(x3仍在庫內)
+        injectInsert = true
+        let err = await getReject(proc('mix', { add: [{ id: 'n1' }, { id: 'n2' }], del: [{ id: 'x3' }] }))
+        assert.strict.equal(err, 'failed to insert data')
+        assert.strict.deepEqual(await getIds(), ['n2', 'x1', 'x2', 'x3'])
+    })
+
+    it('F04 insert之ORM回報陣列形逐筆ok為0時reject而不回成功', async function() {
+        //規則4(orm-run04): 陣列形任一筆ok為0同聚合形處置; 其餘筆已寫入(n2)無從回復
+        injectInsert = 'array'
+        let err = await getReject(proc('insert', [{ id: 'n1' }, { id: 'n2' }]))
+        assert.strict.equal(err, 'failed to insert data')
+        assert.strict.deepEqual(await getIds(), ['n2', 'x1', 'x2', 'x3'])
+    })
+
+    it('F05 mix之add之ORM回報陣列形逐筆ok為0時reject且後續del不執行', async function() {
+        //規則4(orm-run04): add為首步, 立即reject, del步驟不執行(x3仍在庫內)
+        injectInsert = 'array'
+        let err = await getReject(proc('mix', { add: [{ id: 'n1' }, { id: 'n2' }], del: [{ id: 'x3' }] }))
+        assert.strict.equal(err, 'failed to insert data')
+        assert.strict.deepEqual(await getIds(), ['n2', 'x1', 'x2', 'x3'])
+    })
+
+    it('F06 delAll之ORM回報聚合物件ok為0時reject而不回成功', async function() {
+        //R-ORM-RESULT-01(orm-run05): ORM已執行刪除而回報ok為0(違約), 呼叫端得知失敗
+        injectOther = 'delAll'
+        let err = await getReject(proc('delAll', { id: 'x1' }))
+        assert.strict.equal(err, 'failed to delete data')
+        injectOther = null
+        assert.strict.deepEqual(await getIds(), ['x2', 'x3'])
+    })
+
+    it('F07 save與del之ORM回報聚合物件ok為0時reject而不回成功', async function() {
+        //R-ORM-RESULT-01(orm-run05): 契約為逐筆陣列, 聚合形(非契約形狀)無從逐筆列出, 固定字串reject
+        injectOther = 'save'
+        let err = await getReject(proc('save', [{ id: 'x1', isActive: 'n' }]))
+        assert.strict.equal(err, 'failed to save data')
+        injectOther = 'del'
+        err = await getReject(proc('del', [{ id: 'x2' }]))
+        assert.strict.equal(err, 'failed to delete data')
+    })
+
+    it('F08 mix之del回報聚合物件ok為0時立即reject且diff不執行', async function() {
+        //R-ORM-RESULT-01(orm-run05): del為第2步, 聚合形失敗即整批性, diff步驟不執行(x1之isActive仍為預設而未被改為n)
+        injectOther = 'del'
+        let err = await getReject(proc('mix', { del: [{ id: 'x3' }], diff: [{ id: 'x1', isActive: 'n' }] }))
+        assert.strict.equal(err, 'failed to delete data')
+        injectOther = null
+        let rs = await so.woItems.tests.select({ id: 'x1' })
+        assert.ok(rs.length === 1 && rs[0].isActive !== 'n', JSON.stringify(rs))
+    })
+
+    it('F09 契約內之ORM(delAll恆ok為1)行為不變', async function() {
+        //R-ORM-RESULT-01: 未違約時delAll、save、del照常resolve
+        let r = await proc('delAll', { id: 'x1' })
+        assert.strict.deepEqual(r, { n: 1, nDeleted: 1, ok: 1 })
+        let r2 = await proc('save', [{ id: 'x2', isActive: 'n' }])
+        assert.strict.deepEqual(r2, [{ id: 'x2' }])
+        let r3 = await proc('del', [{ id: 'x3' }])
+        assert.strict.deepEqual(r3, [{ n: 1, nDeleted: 1, ok: 1 }])
+    })
+
+    it('F03 契約內之ORM(insert恆ok為1)行為不變', async function() {
+        //規則4: 未違約時insert與mix照常resolve並寫入; 略過既有主鍵(n為0)亦照常
+        let r = await proc('insert', [{ id: 'n1' }, { id: 'x1' }])
+        assert.strict.deepEqual(r, [{ id: 'n1' }, { id: 'x1' }])
+        let r2 = await proc('mix', { add: [{ id: 'n2' }], del: [{ id: 'x3' }] })
+        assert.strict.deepEqual(r2, [{ id: 'n2' }, { id: 'x3' }])
+        assert.strict.deepEqual(await getIds(), ['n1', 'n2', 'x1', 'x2'])
+    })
+
+})

package/test/unit-getDb.test.mjs

@@ -31,6 +31,26 @@ function mkWoItems(log, behavior = {}) {
     }
 }
 
+//多表替身: results[表名]為該表insert之回傳函數(未給則回契約內之成功結果)
+function mkWoItemsMulti(log, results = {}) {
+    let woItems = {}
+    for (let name of ['t1', 't2', 't3']) {
+        woItems[name] = {
+            select: async () => [],
+            insert: async (d) => {
+                log.push({ fn: 'insert', table: name, d })
+                if (results[name]) {
+                    return results[name](d)
+                }
+                return { n: d.length, nInserted: d.length, ok: 1 }
+            },
+        }
+    }
+    return woItems
+}
+
+let BK3 = [{ name: 't1', data: [{ id: 'a' }] }, { name: 't2', data: [{ id: 'b' }, { id: 'c' }] }, { name: 't3', data: [{ id: 'd' }] }]
+
 async function getReject(pm) {
     try {
         await pm
@@ -131,6 +151,64 @@ describe('getDb備份與還原', function() {
         assert.strict.deepEqual(log, [{ fn: 'insert', table: 'tests', d: [{ id: 'a' }] }])
     })
 
+    it('B05b recover之insert聚合結果ok為0即reject Error並停止, 先前之表已寫入、之後之表不寫入', async function() {
+        //R-DB-01 規則3(orm-run04): ORM回報失敗不得當成功; 錯誤型別為Error(R-ERR-01規則2); 訊息含失敗表名、ORM回傳原文與先前已寫入之表
+        let log = []
+        let fp = writeBackup('fail-agg.json', JSON.stringify(BK3))
+        let woItems = mkWoItemsMulti(log, { t2: (d) => ({ n: d.length, nInserted: 0, ok: 0, err: 'E-ins' }) })
+        let err = await quiet(() => getReject(getDb.recover(woItems, fp, { bLog: false })))
+        assert.ok(err instanceof Error)
+        assert.strict.equal(err.message, 'failed to recover data into table[t2]: {"n":2,"nInserted":0,"ok":0,"err":"E-ins"}; tables already written: t1')
+        assert.strict.deepEqual(log.map((v) => v.table), ['t1', 't2'])
+    })
+
+    it('B05c recover之insert陣列形逐筆ok為0即reject Error, 訊息列失敗筆', async function() {
+        //R-DB-01 規則3(orm-run04): 陣列形(非契約形狀)任一筆ok為0同聚合形處置; 失敗筆取輸入同位置數據之id(getItemsFail)
+        let log = []
+        let fp = writeBackup('fail-arr.json', JSON.stringify(BK3))
+        let woItems = mkWoItemsMulti(log, { t2: () => [{ n: 1, nInserted: 0, ok: 0, err: 'E-ins' }, { n: 1, nInserted: 1, ok: 1 }] })
+        let err = await quiet(() => getReject(getDb.recover(woItems, fp, { bLog: false })))
+        assert.ok(err instanceof Error)
+        assert.strict.equal(err.message, 'failed to recover data into table[t2]: [{"k":0,"id":"b","err":"E-ins"}]; tables already written: t1')
+        assert.strict.deepEqual(log.map((v) => v.table), ['t1', 't2'])
+    })
+
+    it('B05d recover之首表失敗無已寫入之表可列, 失敗筆超過10筆僅列前10筆並附總數', async function() {
+        //R-DB-01 規則3(orm-run04): 同getMsgFail之上限(10筆)
+        let log = []
+        let rows = []
+        for (let i = 1; i <= 12; i++) {
+            rows.push({ id: `r${i}` })
+        }
+        let fp = writeBackup('fail-many.json', JSON.stringify([{ name: 't1', data: rows }, { name: 't2', data: [{ id: 'b' }] }]))
+        let woItems = mkWoItemsMulti(log, { t1: (d) => d.map(() => ({ n: 1, nInserted: 0, ok: 0, err: 'E-full' })) })
+        let err = await quiet(() => getReject(getDb.recover(woItems, fp, { bLog: false })))
+        let fails = rows.slice(0, 10).map((v, k) => ({ k, id: v.id, err: 'E-full' }))
+        assert.strict.equal(err.message, `failed to recover data into table[t1]: ${JSON.stringify(fails)}, ... (12 in total)`)
+        assert.strict.deepEqual(log.map((v) => v.table), ['t1'])
+    })
+
+    it('B05e recover之insert無失敗(略過既有主鍵、回傳undefined、null、空物件、空陣列、逐筆皆ok為1)照舊resolve並寫入全部表', async function() {
+        //R-DB-01 規則3(orm-run04): 只認聚合物件ok為0與陣列內任一筆ok為0, 其餘維持舊行為
+        for (let rIns of [{ n: 0, nInserted: 0, ok: 1 }, undefined, null, {}, [], [{ n: 1, nInserted: 1, ok: 1 }]]) {
+            let log = []
+            let fp = writeBackup('ok-shapes.json', JSON.stringify(BK3))
+            let woItems = mkWoItemsMulti(log, { t2: () => rIns })
+            await quiet(() => getDb.recover(woItems, fp, { bLog: false }))
+            assert.strict.deepEqual(log.map((v) => v.table), ['t1', 't2', 't3'], JSON.stringify(rIns))
+        }
+    })
+
+    it('B05f 低階recover之insert失敗亦reject Error', async function() {
+        //R-DB-01 規則3(orm-run04): WServOrm實例上之recover即此低階函數
+        let log = []
+        let fp = writeBackup('fail-low.json', JSON.stringify(BK3))
+        let woItems = mkWoItemsMulti(log, { t3: (d) => ({ n: d.length, nInserted: 0, ok: 0 }) })
+        let err = await quiet(() => getReject(br.recover(fp, woItems)))
+        assert.ok(err instanceof Error)
+        assert.strict.equal(err.message, 'failed to recover data into table[t3]: {"n":1,"nInserted":0,"ok":0}; tables already written: t1, t2')
+    })
+
     it('B06 recover之bRela缺ds或genModelsByTabs即於寫入前reject', async function() {
         //P4-1: 明確訊息, 不寫入
         let log = []

package/test/unit-isOrmFail.test.mjs

@@ -0,0 +1,35 @@
+import assert from 'assert'
+import isOrmFail from '../src/isOrmFail.mjs'
+
+
+//R-ORM-RESULT-01(原R-PERITEM-01 規則4, orm-run03、run04): ORM寫入類函數之回傳結果是否回報失敗之判準; procOrm各寫入模式與mix各步驟、備份還原、測試數據寫入共用
+describe('isOrmFail', function() {
+
+    it('V01 聚合物件ok為0為失敗', function() {
+        //規則: 聚合物件ok恆等於0(違約之ORM或他種後端)
+        for (let r of [{ n: 2, nInserted: 0, ok: 0 }, { n: 2, nInserted: 1, ok: 0, err: 'E' }, { n: 0, nDeleted: 0, ok: 0 }, { ok: 0 }]) {
+            assert.strict.equal(isOrmFail(r), true, JSON.stringify(r))
+        }
+    })
+
+    it('V02 逐筆陣列任一筆ok為0為失敗', function() {
+        //規則(run04): 同getItemsFail之判讀(僅ok恆等於0者)
+        for (let r of [[{ ok: 0 }], [{ ok: 1 }, { ok: 0 }], [{ ok: 1 }, null, { ok: 0, err: 'E' }], [1, 'x', { ok: 0 }]]) {
+            assert.strict.equal(isOrmFail(r), true, JSON.stringify(r))
+        }
+    })
+
+    it('V03 其餘回傳形狀不是失敗(維持舊行為)', function() {
+        //規則: 略過既有主鍵或未命中(n為0、ok為1)為正常結果; ok非恆等於0(含false、'0'、null、undefined)與非物件、非陣列者不判
+        let cases = [
+            { n: 2, nInserted: 2, ok: 1 }, { n: 0, nInserted: 0, ok: 1 }, { n: 0, nDeleted: 0, ok: 1 }, {}, { n: 1 },
+            { ok: false }, { ok: '0' }, { ok: null }, { ok: undefined },
+            [], [{ ok: 1 }], [{ n: 1 }], [null, 1, 'x', {}], [{ ok: false }, { ok: '0' }],
+            undefined, null, 0, 1, '', 'x', true, false,
+        ]
+        for (let r of cases) {
+            assert.strict.equal(isOrmFail(r), false, JSON.stringify(r) + ' ' + typeof r)
+        }
+    })
+
+})

package/test/unit-mapOrm.test.mjs

@@ -146,6 +146,80 @@ describe('mapOrm逐筆失敗', function() {
         assert.strict.deepEqual(r, { n: 1, nDeleted: 1, ok: 1 })
     })
 
+    it('U03b save之ORM回傳聚合物件ok為0(非契約形狀)', async function() {
+        //R-ORM-RESULT-01(orm-run05): 契約為逐筆陣列; 回傳聚合物件而ok為0者無從逐筆列出, 仍視為失敗, 固定字串reject(陣列與單一物件輸入皆是)
+        plan.save = () => ({ n: 2, nInserted: 0, nModified: 0, ok: 0, err: 'E-agg' })
+        let err = await getReject(proc('save', [{ id: 's1' }, { id: 's2' }]))
+        assert.strict.equal(err, 'failed to save data')
+        err = await getReject(proc('save', { id: 's3' }))
+        assert.strict.equal(err, 'failed to save data')
+    })
+
+    it('U03c save之ORM回傳非陣列且無失敗者照舊', async function() {
+        //R-ORM-RESULT-01: undefined、null、無ok鍵之物件、ok為1之聚合物件不判失敗(維持舊行為, 同U07)
+        for (let rSave of [undefined, null, {}, { n: 1 }, { n: 1, ok: 1 }]) {
+            plan.save = () => rSave
+            let r = await proc('save', [{ id: 's1' }])
+            assert.strict.deepEqual(r, [{ id: 's1' }], JSON.stringify(rSave))
+        }
+    })
+
+    it('U10c del之ORM回傳聚合物件ok為0(非契約形狀)', async function() {
+        //R-ORM-RESULT-01(orm-run05): 同U03b; 陣列與單一物件輸入皆是
+        plan.del = () => ({ n: 1, nDeleted: 0, ok: 0, err: 'E-agg' })
+        let err = await getReject(proc('del', [{ id: 'd1' }, { id: 'd2' }]))
+        assert.strict.equal(err, 'failed to delete data')
+        err = await getReject(proc('del', { id: 'd3' }))
+        assert.strict.equal(err, 'failed to delete data')
+    })
+
+    it('U12b del之ORM回傳非陣列且無失敗者照舊回傳ORM原值', async function() {
+        //R-ORM-RESULT-01: undefined、null、無ok鍵之物件、ok為1之聚合物件不判失敗(同U12)
+        for (let rDel of [undefined, null, {}, { n: 1 }, { n: 1, nDeleted: 1, ok: 1 }]) {
+            plan.del = () => rDel
+            let r = await proc('del', [{ id: 'd1' }])
+            assert.strict.deepEqual(r, rDel, JSON.stringify(rDel))
+        }
+    })
+
+    it('U24 delAll之ORM回報失敗(聚合物件ok為0, 或陣列形任一筆ok為0)', async function() {
+        //R-ORM-RESULT-01(orm-run05): 契約為聚合物件ok恆為1(錯誤皆整批reject); ok為0者視為失敗, 固定字串reject, 不回成功; 無條件與有條件皆是
+        for (let rAll of [{ n: 0, nDeleted: 0, ok: 0, err: 'E-agg' }, [{ n: 0, nDeleted: 0, ok: 1 }, { ok: 0 }]]) {
+            plan.delAll = () => rAll
+            let err = await getReject(proc('delAll', {}))
+            assert.strict.equal(err, 'failed to delete data', JSON.stringify(rAll))
+            err = await getReject(proc('delAll', { id: 'd1' }))
+            assert.strict.equal(err, 'failed to delete data', JSON.stringify(rAll))
+        }
+    })
+
+    it('U24b delAll之ORM回傳無失敗者照舊回傳ORM原值', async function() {
+        //R-ORM-RESULT-01: 條件無命中(n為0、ok為1)為正常結果; undefined、null、無ok鍵之物件、空陣列不判失敗
+        for (let rAll of [{ n: 0, nDeleted: 0, ok: 1 }, { n: 3, nDeleted: 3, ok: 1 }, undefined, null, {}, [], [{ ok: 1 }]]) {
+            plan.delAll = () => rAll
+            let r = await proc('delAll', { id: 'd1' })
+            assert.strict.deepEqual(r, rAll, JSON.stringify(rAll))
+        }
+    })
+
+    it('U24c delAll之ORM整批reject', async function() {
+        //R-PERITEM-01 規則1之既有處置不變: ORM reject轉固定字串
+        plan.delAll = () => Promise.reject(new Error('E-batch'))
+        let err = await getReject(proc('delAll', {}))
+        assert.strict.equal(err, 'failed to delete data')
+    })
+
+    it('U24d mustExist之save與del遇聚合物件ok為0時以一般失敗字串reject, 不誤報rowNotFound', async function() {
+        //R-ORM-RESULT-01: ok為0優先於mustExist之事後偵測(hasNoHit只認ok非0者)
+        plan.select = () => [{ id: 's1' }]
+        plan.save = () => ({ n: 0, nInserted: 0, nModified: 0, ok: 0, err: 'E-agg' })
+        plan.del = () => ({ n: 0, nDeleted: 0, ok: 0, err: 'E-agg' })
+        let err = await getReject(so.procOrm('u1', 'tests', 'save', [{ id: 's1' }], { mustExist: true }))
+        assert.strict.equal(err, 'failed to save data')
+        err = await getReject(so.procOrm('u1', 'tests', 'del', [{ id: 's1' }], { mustExist: true }))
+        assert.strict.equal(err, 'failed to delete data')
+    })
+
     it('U13 mix全部成功', async function() {
         //R04: mix依add、del、diff順序執行, 回傳累積之id
         plan.insert = (data) => ({ n: data.length, nInserted: data.length, ok: 1 })
@@ -166,6 +240,37 @@ describe('mapOrm逐筆失敗', function() {
         assert.strict.deepEqual(calls.map((v) => v.fn), ['insert', 'del', 'save'])
     })
 
+    it('U14b mix之del回傳聚合物件ok為0(非契約形狀)', async function() {
+        //R-ORM-RESULT-01(orm-run05): 無從逐筆列出, 視為該步驟整批性失敗, 固定字串立即reject, diff步驟不執行(同add; 先前之逐筆失敗僅由log輸出, 同U18)
+        plan.insert = (data) => ({ n: data.length, nInserted: data.length, ok: 1 })
+        plan.del = () => ({ n: 1, nDeleted: 0, ok: 0, err: 'E-agg' })
+        plan.save = (data) => data.map(() => okSave)
+        let err = await getReject(proc('mix', { add: [{ id: 'a1' }], del: [{ id: 'd1' }], diff: [{ id: 'f1' }] }))
+        assert.strict.equal(err, 'failed to delete data')
+        assert.strict.deepEqual(calls.map((v) => v.fn), ['insert', 'del'])
+    })
+
+    it('U14c mix之diff回傳聚合物件ok為0(非契約形狀)', async function() {
+        //R-ORM-RESULT-01(orm-run05): 同U14b; 先前del之逐筆失敗不影響以diff之固定字串reject
+        plan.del = () => [{ n: 0, nDeleted: 0, ok: 0, err: 'E-del' }]
+        plan.save = () => ({ n: 1, nInserted: 0, nModified: 0, ok: 0, err: 'E-agg' })
+        let err = await getReject(proc('mix', { del: [{ id: 'd1' }], diff: [{ id: 'f1' }] }))
+        assert.strict.equal(err, 'failed to update data')
+        assert.strict.deepEqual(calls.map((v) => v.fn), ['del', 'save'])
+    })
+
+    it('U14d mix之del與diff回傳非陣列且無失敗者照舊', async function() {
+        //R-ORM-RESULT-01: undefined、null、無ok鍵之物件、ok為1之聚合物件不判失敗
+        for (let rStep of [undefined, null, {}, { n: 1 }, { n: 1, ok: 1 }]) {
+            calls = []
+            plan.del = () => rStep
+            plan.save = () => rStep
+            let r = await proc('mix', { del: [{ id: 'd1' }], diff: [{ id: 'f1' }] })
+            assert.strict.deepEqual(r, [{ id: 'd1' }, { id: 'f1' }], JSON.stringify(rStep))
+            assert.strict.deepEqual(calls.map((v) => v.fn), ['del', 'save'], JSON.stringify(rStep))
+        }
+    })
+
     it('U15 mix僅del有ok為0', async function() {
         //R03: del之逐筆失敗不中斷diff, diff仍寫入, 最後reject僅列del之失敗
         plan.del = () => [{ n: 0, nDeleted: 0, ok: 0, err: 'E-del' }]
@@ -201,6 +306,41 @@ describe('mapOrm逐筆失敗', function() {
         assert.strict.equal(err, 'failed to update data')
     })
 
+    it('U17b mix之add聚合結果ok為0', async function() {
+        //R-PERITEM-01 規則4(orm-run03): insert契約上ok恆為1, 聚合結果ok為0(ORM違約)視為整批性失敗, 立即reject, 後續步驟不執行
+        plan.insert = (data) => ({ n: data.length, nInserted: 0, ok: 0, err: 'E-ins' })
+        plan.del = (data) => data.map(() => okDel)
+        plan.save = (data) => data.map(() => okSave)
+        let err = await getReject(proc('mix', { add: [{ id: 'a1' }], del: [{ id: 'd1' }], diff: [{ id: 'f1' }] }))
+        assert.strict.equal(err, 'failed to insert data')
+        assert.strict.deepEqual(calls.map((v) => v.fn), ['insert'])
+    })
+
+    it('U17c mix之add略過既有主鍵或ORM回傳無失敗者照舊', async function() {
+        //R-PERITEM-01 規則4: 略過(n為0、ok為1)屬正常結果; 回傳undefined、null、無ok鍵之物件、空陣列、元素皆ok非0或非物件之陣列不判失敗
+        for (let rIns of [{ n: 0, nInserted: 0, ok: 1 }, undefined, null, [], [{ n: 1, nInserted: 1, ok: 1 }, { n: 0, nInserted: 0, ok: 1 }], [null, 1, 'x', {}], {}, { n: 1 }]) {
+            calls = []
+            plan.insert = () => rIns
+            plan.del = (data) => data.map(() => okDel)
+            let r = await proc('mix', { add: [{ id: 'a1' }], del: [{ id: 'd1' }] })
+            assert.strict.deepEqual(r, [{ id: 'a1' }, { id: 'd1' }], JSON.stringify(rIns))
+            assert.strict.deepEqual(calls.map((v) => v.fn), ['insert', 'del'], JSON.stringify(rIns))
+        }
+    })
+
+    it('U17d mix之add陣列形逐筆ok為0', async function() {
+        //R-PERITEM-01 規則4(orm-run04): insert回傳陣列形者(非契約形狀)亦逐筆判讀, 任一筆ok為0即同聚合形處置: 固定字串立即reject, 後續步驟不執行
+        for (let rIns of [[{ n: 1, nInserted: 0, ok: 0, err: 'E-ins' }], [{ n: 1, nInserted: 1, ok: 1 }, { n: 1, nInserted: 0, ok: 0 }], [{ ok: 1 }, null, { ok: 0 }]]) {
+            calls = []
+            plan.insert = () => rIns
+            plan.del = (data) => data.map(() => okDel)
+            plan.save = (data) => data.map(() => okSave)
+            let err = await getReject(proc('mix', { add: [{ id: 'a1' }, { id: 'a2' }], del: [{ id: 'd1' }], diff: [{ id: 'f1' }] }))
+            assert.strict.equal(err, 'failed to insert data', JSON.stringify(rIns))
+            assert.strict.deepEqual(calls.map((v) => v.fn), ['insert'], JSON.stringify(rIns))
+        }
+    })
+
     it('U19 insert成功', async function() {
         //R04: insert回傳聚合物件而非逐筆陣列, 照舊回傳id
         plan.insert = (data) => ({ n: data.length, nInserted: data.length, ok: 1 })
@@ -208,6 +348,55 @@ describe('mapOrm逐筆失敗', function() {
         assert.strict.deepEqual(r, [{ id: 'i1' }])
     })
 
+    it('U19b insert聚合結果ok為0', async function() {
+        //R-PERITEM-01 規則4(orm-run03): 陣列與單一物件輸入皆須檢出, 固定字串reject而不回成功
+        plan.insert = (data) => ({ n: data.length, nInserted: 0, ok: 0, err: 'E-ins' })
+        let err = await getReject(proc('insert', [{ id: 'i1' }, { id: 'i2' }]))
+        assert.strict.equal(err, 'failed to insert data')
+        err = await getReject(proc('insert', { id: 'i3' }))
+        assert.strict.equal(err, 'failed to insert data')
+        assert.strict.deepEqual(calls.map((v) => v.fn), ['insert', 'insert'])
+    })
+
+    it('U19c insert略過既有主鍵或ORM回傳無失敗者照舊', async function() {
+        //R-PERITEM-01 規則4: 略過(n為0、ok為1)屬正常結果, 回傳id含被略過者; 回傳undefined、null、無ok鍵之物件、空陣列、元素皆ok非0或非物件之陣列不判失敗
+        for (let rIns of [{ n: 0, nInserted: 0, ok: 1 }, undefined, null, [], [{ n: 1, nInserted: 1, ok: 1 }, { n: 0, nInserted: 0, ok: 1 }], [null, 1, 'x', {}], {}, { n: 1 }]) {
+            plan.insert = () => rIns
+            let r = await proc('insert', [{ id: 'i1' }])
+            assert.strict.deepEqual(r, [{ id: 'i1' }], JSON.stringify(rIns))
+        }
+    })
+
+    it('U19e insert陣列形逐筆ok為0', async function() {
+        //R-PERITEM-01 規則4(orm-run04): 陣列形(非契約形狀)任一筆ok為0即同聚合形處置, 固定字串reject; 陣列與單一物件輸入皆是; 其餘筆是否寫入由ORM決定, 已寫入者無從回復
+        for (let rIns of [[{ n: 1, nInserted: 0, ok: 0, err: 'E-ins' }], [{ n: 1, nInserted: 1, ok: 1 }, { n: 1, nInserted: 0, ok: 0 }], [null, { ok: 0 }]]) {
+            plan.insert = () => rIns
+            let err = await getReject(proc('insert', [{ id: 'i1' }, { id: 'i2' }]))
+            assert.strict.equal(err, 'failed to insert data', JSON.stringify(rIns))
+            err = await getReject(proc('insert', { id: 'i3' }))
+            assert.strict.equal(err, 'failed to insert data', JSON.stringify(rIns))
+        }
+    })
+
+    it('U19d insert聚合結果ok為0時錯誤原文只進log而不進reject訊息', async function() {
+        //R06: 前端訊息為固定字串, 錯誤原文由console.log輸出
+        plan.insert = (data) => ({ n: data.length, nInserted: 0, ok: 0, err: 'E-secret-detail' })
+        let logs = []
+        let logOrig = console.log
+        console.log = (...args) => {
+            logs.push(args)
+        }
+        let err
+        try {
+            err = await getReject(proc('insert', [{ id: 'i1' }]))
+        }
+        finally {
+            console.log = logOrig
+        }
+        assert.strict.equal(err, 'failed to insert data')
+        assert.ok(JSON.stringify(logs).includes('E-secret-detail'))
+    })
+
     it('U22 錯誤原文寫入log而不進reject訊息', async function() {
         //R06: 前端訊息只帶主鍵, 錯誤原文由console.log輸出
         plan.save = () => [{ n: 1, nInserted: 0, nModified: 0, ok: 0, err: 'E-secret-detail' }]
@@ -348,6 +537,30 @@ describe('genTestData逐筆失敗', function() {
         assert.ok(String(err).includes('g2'))
     })
 
+    it('U21b funTest之save回傳聚合物件ok為0(非契約形狀)', async function() {
+        //R-ORM-RESULT-01(orm-run05): 無從逐筆列出, 仍視為失敗, 同U21之Error與訊息前綴, 內文列ORM回傳原文
+        let woItems = {
+            tests: {
+                save: async () => ({ n: 2, nInserted: 0, nModified: 0, ok: 0, err: 'E-gen' }),
+            },
+        }
+        let err = await getReject(genTestData(dsGen, woItems, { mode: 'funTest', bLog: false }))
+        assert.ok(err instanceof Error)
+        assert.strict.equal(err.message, 'failed to write test data into table[tests]: {"n":2,"nInserted":0,"nModified":0,"ok":0,"err":"E-gen"}')
+    })
+
+    it('U21c funTest之save回傳非陣列且無失敗者照舊', async function() {
+        //R-ORM-RESULT-01: undefined、null、無ok鍵之物件、ok為1之聚合物件不判失敗(同U20)
+        for (let rSave of [undefined, null, {}, { n: 2, ok: 1 }]) {
+            let woItems = {
+                tests: {
+                    save: async () => rSave,
+                },
+            }
+            await genTestData(dsGen, woItems, { mode: 'funTest', bLog: false })
+        }
+    })
+
     it('U23 funTestAndSave與funTest之逐筆失敗訊息相同', async function() {
         //R09: funTestAndSave由w-data-collector之build產生(schema/index.mjs)且其錯誤原樣轉出; w-data-collector 1.0.46起兩種模式之訊息同為英文同格式
         let woItems = {

package/test/unit-ormsites.test.mjs

@@ -0,0 +1,61 @@
+import fs from 'fs'
+import path from 'path'
+import assert from 'assert'
+
+
+//R-ORM-RESULT-01(orm-run05): src內呼叫ORM實例方法之站點全集須已歸類; 新增站點(或改變某檔對某方法之呼叫數)時本案失敗, 須回帳本逐站判定「已檢查」或「不適用」後再更新此表
+//盤點方式: 逐行去除註解後, 以正則取出「.方法(」之呼叫, 依(檔, 方法)計次; 計次而非行號, 避免無關修改使行號位移而誤報
+let METHODS = ['select', 'selectByPk', 'selectAll', 'insert', 'insertBulk', 'save', 'del', 'delAll', 'selectGfs', 'selectByPkGfs', 'insertGfs', 'delGfs', 'delAllGfs', 'createStorage', 'close', 'backup', 'recover', 'funTest', 'funTestAndSave']
+
+//已歸類之站點(檔 -> 方法 -> 呼叫次數), 判定見 sgud/rule/rulebook_error-input.md R-ORM-RESULT-01 之站點表
+let EXPECT = {
+    'genTestData.mjs': { funTestAndSave: 1, funTest: 1, save: 1 },
+    'getDb.mjs': { backup: 1, recover: 1 },
+    'getDbBackupAndRecover.mjs': { select: 1, createStorage: 1, insert: 1 },
+    'getMapOrm.mjs': { select: 2, insert: 2, save: 3, del: 2, delAll: 1 },
+    'WServOrm.mjs': { close: 1 },
+}
+
+function stripComment(line) {
+    let t = line.trim()
+    if (t.startsWith('//') || t.startsWith('*') || t.startsWith('/*')) {
+        return ''
+    }
+    return line.replace(/\s\/\/.*$/, '')
+}
+
+function scan(re) {
+    let fd = path.resolve('./src')
+    let out = {}
+    for (let f of fs.readdirSync(fd).filter((v) => v.endsWith('.mjs')).sort()) {
+        let txt = fs.readFileSync(path.join(fd, f), 'utf8').split(/\r?\n/).map(stripComment).join('\n')
+        for (let m of txt.matchAll(re)) {
+            out[f] = out[f] || {}
+            out[f][m[1]] = (out[f][m[1]] || 0) + 1
+        }
+    }
+    return out
+}
+
+
+describe('ORM呼叫站點盤點', function() {
+
+    it('O01 src內呼叫ORM實例方法之站點全集同已歸類之表(未歸類為0)', function() {
+        //R-ORM-RESULT-01: 新增或移除呼叫須同步更新帳本與此表
+        let got = scan(new RegExp(`\\.(${METHODS.join('|')})\\(`, 'g'))
+        assert.strict.deepEqual(got, EXPECT)
+    })
+
+    it('O02 不得以括號記法或動態方法名呼叫ORM(盤點正則無從涵蓋)', function() {
+        //R-ORM-RESULT-01: 以[方法名字串]呼叫者改寫為直接呼叫, 否則O01之盤點不完整
+        let got = scan(new RegExp(`\\[['"\`](${METHODS.join('|')})['"\`]\\]`, 'g'))
+        assert.strict.deepEqual(got, {})
+    })
+
+    it('O03 ORM建構僅getWoItems一處', function() {
+        //R-ORM-RESULT-01: 建構失敗以拋錯表達, 無回傳可檢查(不適用)
+        let got = scan(/(new) WOrm\(/g)
+        assert.strict.deepEqual(got, { 'getWoItems.mjs': { new: 1 } })
+    })
+
+})