w-serv-orm 1.1.10 → 1.1.12

package/test/api-objcopy.test.mjs

@@ -0,0 +1,232 @@
+import fs from 'fs'
+import assert from 'assert'
+import WOrm from 'w-orm-lowdb/src/WOrmLowdb.mjs'
+import WServOrm from '../src/WServOrm.mjs'
+import { getReject, quiet, same } from './tools/ormStub.mjs'
+
+
+//以真ORM(w-orm-lowdb, mingo查詢)經procOrm驗證R-OBJ-01: 含整數length鍵之find與寫入列, 結果須等於以JS參考實作(預言機)算得者
+//自建夾具: 資料表tabA之id為字串型pk, 各案前重新播種; 「ORM收到」為對woItems.tabA.select/delAll加spy所得之實參
+let fd = './test/_tmp/api-objcopy'
+
+let ds = { tabA: { keys: ['id', 'name', 'length'], settings: { id: { pk: true, type: 'STRING' }, name: { type: 'STRING' } } } }
+
+let seed = [
+    { id: 'a1', name: 'alpha', length: 3 },
+    { id: 'a2', name: 'beta', length: 1 },
+    { id: 'a3', name: 'gamma' },
+    { id: 'a4', name: 'alpha', length: 'abc' },
+    { id: 'a5', name: 'delta', length: 0 },
+]
+
+//refMatch, JS參考實作: 欄位等值(嚴格相等)、$and、$or、$nor、欄位層$in/$nin/$eq/$ne/$not; 缺欄視為undefined
+function refMatch(row, find) {
+    let opMatch = (v, c) => {
+        if (c !== null && typeof c === 'object' && !Array.isArray(c)) {
+            return Object.keys(c).every((op) => {
+                if (op === '$eq') return v === c[op]
+                if (op === '$ne') return v !== c[op]
+                if (op === '$in') return c[op].includes(v)
+                if (op === '$nin') return !c[op].includes(v)
+                if (op === '$not') return !opMatch(v, c[op])
+                throw new Error(`參考實作不支援${op}`)
+            })
+        }
+        return v === c
+    }
+    return Object.keys(find).every((k) => {
+        let c = find[k]
+        if (k === '$and') return c.every((f) => refMatch(row, f))
+        if (k === '$or') return c.some((f) => refMatch(row, f))
+        if (k === '$nor') return !c.some((f) => refMatch(row, f))
+        return opMatch(row[k], c)
+    })
+}
+
+let finds = [
+    { length: 1, name: 'alpha' }, //無列同時符合: 修前條件消失而回全表
+    { length: 1, name: 'beta' },
+    { length: 0 },
+    { length: 0, name: 'alpha' },
+    { id: 'a1', length: 3 },
+    { id: 'a1', length: 4 },
+    { length: 3 },
+    { length: 'abc' },
+    { length: Number.MAX_SAFE_INTEGER },
+    { length: 3.5 },
+    { $or: [{ length: 3 }, { name: 'gamma' }] },
+    { $and: [{ length: 1 }, { name: 'beta' }] },
+    { $nor: [{ length: 3 }] },
+    { id: { $in: ['a1', 'a2'] }, length: 1 },
+    { name: 'alpha' },
+    {},
+]
+
+
+describe('R-OBJ-01 接w-orm-lowdb(以JS參考實作為預言機)', function() {
+
+    let so = null
+    let seen = []
+    let proc = (mode, input) => so.procOrm('u1', 'tabA', mode, input)
+    let rows = async () => (await so.woItems.tabA.select()).sort((a, b) => (a.id < b.id ? -1 : 1))
+    let reseed = async () => {
+        await so.woItems.tabA.delAll()
+        await so.woItems.tabA.insert(structuredClone(seed))
+    }
+
+    before(function() {
+        fs.rmSync(fd, { recursive: true, force: true })
+        fs.mkdirSync(fd, { recursive: true })
+        so = WServOrm(ds, WOrm, `${fd}/db.json`, 'worm')
+        for (let fn of ['select', 'delAll']) {
+            let orig = so.woItems.tabA[fn].bind(so.woItems.tabA)
+            so.woItems.tabA[fn] = async (data) => {
+                seen.push({ fn, data })
+                return orig(data)
+            }
+        }
+    })
+
+    beforeEach(async function() {
+        await reseed()
+        seen = []
+    })
+
+    after(async function() {
+        await so.closeAll()
+        fs.rmSync(fd, { recursive: true, force: true })
+    })
+
+    it('A13 select: ORM收到之條件同送入者, 回傳之列集合等於參考實作', async function() {
+        //R-OBJ-01 規則1; dspec 一之2①(同一find於select命中者即delAll刪除者)
+        for (let find of finds) {
+            seen = []
+            let r = await proc('select', find)
+            same(seen[0].data, find, `select ${JSON.stringify(find)} ORM收到`)
+            let expected = seed.filter((v) => refMatch(v, find)).map((v) => v.id).sort()
+            same(r.map((v) => v.id).sort(), expected, `select ${JSON.stringify(find)} 回傳`)
+        }
+    })
+
+    it('A14 delAll: ORM收到之條件同送入者, 刪除之列集合等於參考實作(修前{length:1,name:alpha}刪3/3列)', async function() {
+        //R-OBJ-01 規則1; dspec 一之2②③(不得擴大刪除範圍)
+        for (let find of finds) {
+            await reseed()
+            seen = []
+            let r = await proc('delAll', find)
+            same(seen[0].data, find, `delAll ${JSON.stringify(find)} ORM收到`)
+            let left = seed.filter((v) => !refMatch(v, find)).map((v) => v.id).sort()
+            same((await rows()).map((v) => v.id), left, `delAll ${JSON.stringify(find)} 剩餘`)
+            assert.strictEqual(r.nDeleted, seed.length - left.length, `delAll ${JSON.stringify(find)} 刪除筆數`)
+        }
+    })
+
+    it('A15 寫入列含整數length欄: insert、save、mix 讀回與送入者相同, 回傳主鍵即實際主鍵', async function() {
+        //R-OBJ-01 規則1: 修前 insert 含 length:3 之列內容遺失且主鍵被換成產生值, save 單筆之列不寫入而回報 {id:undefined}
+        await so.woItems.tabA.delAll()
+        let input = [
+            { id: 'l1', name: 'x', length: 3 },
+            { id: 'l2', name: 'y', length: 'abc' },
+            { id: 'l3', name: 'z' },
+            { name: 'noid', length: 0 },
+            { id: 'l5', length: 2 },
+        ]
+        let r = await proc('insert', structuredClone(input))
+        //已帶主鍵者須原樣(預期取自輸入, 不取自回傳: 否則被錯改主鍵時回傳與讀回一致而測不出, 外審 sol F5); 未帶者補值, 預期取自回傳
+        input.forEach((v, i) => {
+            if (v.id !== undefined) {
+                assert.strictEqual(r[i].id, v.id, `列${i}之主鍵`)
+            }
+            else {
+                assert.ok(typeof r[i].id === 'string' && r[i].id.length > 30, `列${i}補值`)
+            }
+        })
+        let expected = input.map((v, i) => ({ ...v, id: v.id !== undefined ? v.id : r[i].id }))
+        same(await rows(), expected.sort((a, b) => (a.id < b.id ? -1 : 1)), 'insert讀回')
+
+        //save: 以回傳主鍵覆寫, length 改值; 單筆之列 {id, length:0} 亦須寫入
+        let r2 = await proc('save', expected.map((v) => ({ ...v, length: 7 })))
+        same(r2.map((v) => v.id), expected.map((v) => v.id), 'save回傳主鍵')
+        same(await rows(), expected.map((v) => ({ ...v, length: 7 })).sort((a, b) => (a.id < b.id ? -1 : 1)), 'save讀回')
+        let r3 = await proc('save', { id: 's1', length: 0 })
+        same(r3, { id: 's1' }, 'save單筆回傳')
+        assert.deepStrictEqual((await so.woItems.tabA.select({ id: 's1' })), [{ id: 's1', length: 0 }], 'save單筆讀回')
+        let r4 = await proc('save', [{ id: 's2', length: 1 }])
+        same(r4, [{ id: 's2' }], 'save單筆陣列回傳')
+        assert.deepStrictEqual((await so.woItems.tabA.select({ id: 's2' })), [{ id: 's2', length: 1 }], 'save單筆陣列讀回')
+
+        //mix
+        await so.woItems.tabA.delAll()
+        await so.woItems.tabA.insert([{ id: 'm2', name: 'old', length: 1 }])
+        let rm = await proc('mix', { add: [{ id: 'm1', name: 'x', length: 2 }], diff: [{ id: 'm2', name: 'new', length: 5 }] })
+        same(rm, [{ id: 'm1' }, { id: 'm2' }], 'mix回傳')
+        same(await rows(), [{ id: 'm1', name: 'x', length: 2 }, { id: 'm2', name: 'new', length: 5 }], 'mix讀回')
+    })
+
+    it('A16 自有__proto__鍵: find與寫入列reject, 表內容不變(delAll不刪, insert不寫)', async function() {
+        //R-OBJ-01 規則3
+        let before = await rows()
+        seen = []
+        for (let c of ['{"__proto__":{"x":1}}', '{"id":"a1","__proto__":{"id":"zzz"}}', '{"$or":[{"__proto__":1}]}']) {
+            assert.strictEqual(await quiet(() => getReject(proc('select', JSON.parse(c)))), 'invalid find of select, unsupported key[__proto__]', c)
+            assert.strictEqual(await quiet(() => getReject(proc('delAll', JSON.parse(c)))), 'invalid find of delAll, unsupported key[__proto__]', c)
+        }
+        assert.strictEqual(await quiet(() => getReject(proc('insert', [JSON.parse('{"id":"p1","name":"x","__proto__":{"y":1}}')]))), 'failed to insert data, unsupported key[__proto__]: data[0]')
+        assert.strictEqual(await quiet(() => getReject(proc('mix', { add: [{ id: 'p2' }], diff: [JSON.parse('{"id":"a1","__proto__":{}}')] }))), 'failed to update data, unsupported key[__proto__]: data[0]')
+        assert.deepStrictEqual(seen, [], 'ORM之select與delAll不應被呼叫')
+        same(await rows(), before, '表內容不變')
+    })
+
+    it('A17 非純物件與存取器之find: select與delAll reject, 不回全表亦不刪全表(外審 opus #4、sol F1、F2)', async function() {
+        //R-INPUT-01 規則3、R-OBJ-01 規則3: 修前/D1後未擋時, 偽造Symbol.toStringTag之Map被複製成{}而刪除全表; getter讀兩次令檢查之值與使用之值不同
+        let before = await rows()
+        seen = []
+        let forged = Object.defineProperty(new Map([['id', 'a1']]), Symbol.toStringTag, { value: 'Object' })
+        class G {
+            get name() {
+                return 'alpha'
+            }
+        }
+        let reads = 0
+        let mkGetter = () => Object.defineProperty({}, 'id', {
+            enumerable: true,
+            get() {
+                return ++reads === 1 ? 'a1' : 'a2'
+            }
+        })
+        for (let [find, msg] of [
+            [forged, 'need an object'],
+            [new G(), 'need an object'],
+            [Object.create({ name: 'alpha' }), 'need an object'],
+            [mkGetter(), 'unsupported accessor property'],
+        ]) {
+            for (let mode of ['select', 'delAll']) {
+                assert.strictEqual(await quiet(() => getReject(proc(mode, find))), `invalid find of ${mode}, ${msg}`)
+            }
+        }
+        assert.strictEqual(reads, 0, 'getter不應被呼叫')
+        assert.deepStrictEqual(seen, [], 'ORM之select與delAll不應被呼叫')
+        same(await rows(), before, '表內容不變')
+    })
+
+    it('A18 woName為原型鏈名稱或路徑、find巢狀過深: 以固定字串reject, 不回全表亦不刪全表', async function() {
+        //R-INPUT-01 規則5、R-OBJ-01 規則5、R-ERR-01 規則1: 修前 woName 以 TypeError 物件 reject, 約1173層$and以 RangeError 物件 reject
+        let before = await rows()
+        seen = []
+        for (let name of ['__proto__', 'constructor', 'toString', 'tabA.select']) {
+            for (let [mode, input] of [['select', {}], ['delAll', {}], ['insert', [{ id: 'z' }]], ['del', [{ id: 'a1' }]]]) {
+                assert.strictEqual(await quiet(() => getReject(so.procOrm('u1', name, mode, input))), `can not find table[${name}] in ORM`, `${name} ${mode}`)
+            }
+        }
+        let deep = { id: 'a1' }
+        for (let i = 0; i < 1e4; i++) {
+            deep = { $and: [deep] }
+        }
+        for (let mode of ['select', 'delAll']) {
+            assert.strictEqual(await quiet(() => getReject(proc(mode, deep))), `invalid find of ${mode}, too deep`, mode)
+        }
+        assert.deepStrictEqual(seen, [], 'ORM之select與delAll不應被呼叫')
+        same(await rows(), before, '表內容不變')
+    })
+
+})

package/test/api-pkcast.test.mjs

@@ -0,0 +1,113 @@
+import fs from 'fs'
+import assert from 'assert'
+import WOrm from 'w-orm-lowdb/src/WOrmLowdb.mjs'
+import ltdtDiffByKey from 'wsemi/src/ltdtDiffByKey.mjs'
+import ds from '../schema/index.mjs'
+import WServOrm from '../src/WServOrm.mjs'
+
+
+//以真ORM(w-orm-lowdb, 主鍵固定為字串id, 數字主鍵原會被其以genIDSeq取代)經procOrm驗證R-ID-02、R-MIX-01; schema之tests表之id為STRING pk
+let fd = './test/_tmp/api-pkcast'
+
+async function getReject(pm) {
+    try {
+        await pm
+    }
+    catch (err) {
+        return err
+    }
+    throw new Error('預期reject但resolve')
+}
+
+
+describe('數字主鍵接w-orm-lowdb', function() {
+
+    let so = null
+    let proc = (mode, input) => so.procOrm('u1', 'tests', mode, input)
+    let rows = async () => (await so.woItems.tests.select()).map((v) => [v.id, v.isActive])
+    let quiet = async (fn) => {
+        let logOrig = console.log
+        console.log = () => {}
+        try {
+            return await fn()
+        }
+        finally {
+            console.log = logOrig
+        }
+    }
+
+    before(function() {
+        fs.rmSync(fd, { recursive: true, force: true })
+        fs.mkdirSync(fd, { recursive: true })
+        so = WServOrm(ds, WOrm, `${fd}/db.json`, 'worm')
+    })
+
+    beforeEach(async function() {
+        await so.woItems.tests.delAll()
+    })
+
+    after(async function() {
+        await so.closeAll()
+        fs.rmSync(fd, { recursive: true, force: true })
+    })
+
+    it('A08 數字主鍵存為其字串形式, 重送與修改命中同一筆, 以數字或字串皆可查可刪', async function() {
+        //R-ID-02 規則2: 回報 = 實際; 重送不增筆(原每次另增genIDSeq之列); 寫入、查詢、刪除同一規則
+        let r = await proc('insert', [{ id: 123, isActive: 'y' }])
+        assert.deepStrictEqual(r, [{ id: '123' }])
+        await proc('insert', [{ id: 123, isActive: 'y' }])
+        await proc('save', [{ id: 123, isActive: 'n' }])
+        await proc('mix', { diff: [{ id: 123, isActive: 'm' }] })
+        assert.deepStrictEqual(await rows(), [['123', 'm']])
+        assert.strictEqual((await proc('select', { id: 123 })).length, 1)
+        assert.strictEqual((await proc('select', { id: '123' })).length, 1)
+        let rd = await proc('del', [{ id: 123 }])
+        assert.deepStrictEqual(rd, [{ n: 1, nDeleted: 1, ok: 1 }])
+        assert.deepStrictEqual(await rows(), [])
+    })
+
+    it('A09 表內已有他方以字串寫入之同值主鍵: 以數字save覆寫該列, insert略過而回報字串主鍵', async function() {
+        //R-ID-02 規則2: 123與'123'為同一筆(對外行為變更, 原另增genIDSeq之列)
+        await so.woItems.tests.insert([{ id: '777', isActive: 'A' }])
+        let rs = await proc('save', [{ id: 777, isActive: 'B' }])
+        assert.deepStrictEqual(rs, [{ id: '777' }])
+        let ri = await proc('insert', [{ id: 777, isActive: 'C' }])
+        assert.deepStrictEqual(ri, [{ id: '777' }])
+        assert.deepStrictEqual(await rows(), [['777', 'B']])
+    })
+
+    it('A10 以ltdtDiffByKey嚴格比對產生之add 888、del 888字串, 整批reject且表內不變', async function() {
+        //R-MIX-01 規則1、2: 原為insert略過、del刪除而resolve遺失資料
+        await so.woItems.tests.insert([{ id: '888', isActive: 'y' }])
+        let old = await so.woItems.tests.select()
+        let input = ltdtDiffByKey(old, [{ ...old[0], id: 888 }], 'id', { withInfor: false })
+        assert.deepStrictEqual([input.add.length, input.del.length], [1, 1])
+        let err = await quiet(() => getReject(proc('mix', input)))
+        assert.strictEqual(err, 'invalid input of mix, same id in add and del: add[0], del[0]')
+        assert.deepStrictEqual(await rows(), [['888', 'y']])
+    })
+
+    it('A11 同批之數字與其字串形式: 表內一筆(首筆內容), 回報兩筆同鍵', async function() {
+        //R-ID-02 規則2; insert回傳之id含被略過者
+        let r = await proc('insert', [{ id: 999, isActive: 'p' }, { id: '999', isActive: 'q' }])
+        assert.deepStrictEqual(r, [{ id: '999' }, { id: '999' }])
+        assert.deepStrictEqual(await rows(), [['999', 'p']])
+    })
+
+    it('A12 查詢與delAll之條件以數字給予: 等值、$in、$ne、$not命中字串主鍵, 範圍依字典序', async function() {
+        //R-ID-02 規則2(查詢條件)與已知限制(範圍依字典序: '40' < '5')
+        await proc('insert', [{ id: 5, isActive: 'y' }, { id: 40, isActive: 'y' }, { id: 'abc', isActive: 'y' }])
+        let ids = async (find) => (await proc('select', find)).map((v) => v.id).sort()
+        assert.deepStrictEqual(await ids({ id: 5 }), ['5'])
+        assert.deepStrictEqual(await ids({ id: { $in: [5, 40] } }), ['40', '5'])
+        assert.deepStrictEqual(await ids({ id: { $ne: 5 } }), ['40', 'abc'])
+        assert.deepStrictEqual(await ids({ id: { $not: { $eq: 5 } } }), ['40', 'abc'])
+        assert.deepStrictEqual(await ids({ id: { $lt: 5 } }), ['40'])
+        let r1 = await proc('delAll', { id: { $in: [40] } })
+        assert.deepStrictEqual(r1, { n: 1, nDeleted: 1, ok: 1 })
+        let r2 = await proc('delAll', { id: 5 })
+        assert.deepStrictEqual(r2, { n: 1, nDeleted: 1, ok: 1 })
+        assert.deepStrictEqual(await rows(), [['abc', 'y']])
+    })
+
+})

package/test/api-procOrm.test.mjs

@@ -44,17 +44,18 @@ describe('procOrm接w-orm-lowdb', function() {
     })
 
     it('A02 del含無效主鍵', async function() {
-        //R02: 逐筆ok為0即reject並列出失敗主鍵; R10: 單筆失敗不中斷整批, 有效筆已刪除
-        let err = await getReject(proc('del', [{ id: 'a1' }, { id: 123 }]))
-        assert.strict.equal(err, 'failed to delete data: id[123]')
+        //R02: 逐筆ok為0即reject並列出失敗筆(無有效主鍵者列位置); R10: 單筆失敗不中斷整批, 有效筆已刪除
+        //無效主鍵取非字串非數字之值: 數字依R-ID-02轉為字串後為有效主鍵(未命中), 不再觸發逐筆失敗
+        let err = await getReject(proc('del', [{ id: 'a1' }, { id: true }]))
+        assert.strict.equal(err, 'failed to delete data: data[1]')
         let rs = await proc('select', { id: 'a1' })
         assert.strict.equal(rs.length, 0)
     })
 
     it('A03 mix之del含無效主鍵', async function() {
-        //R03: del之逐筆失敗不中斷diff, diff已寫入, 最後reject列出del之失敗
-        let err = await getReject(proc('mix', { del: [{ id: 456 }], diff: [{ id: 'a2', isActive: 'y' }] }))
-        assert.strict.equal(err, 'failed to delete data: id[456]')
+        //R03: del之逐筆失敗不中斷diff, diff已寫入, 最後reject列出del之失敗(未帶主鍵之列以位置列出)
+        let err = await getReject(proc('mix', { del: [{ id: null }], diff: [{ id: 'a2', isActive: 'y' }] }))
+        assert.strict.equal(err, 'failed to delete data: data[0]')
         let rs = await proc('select', { id: 'a2' })
         assert.strict.equal(rs.length, 1)
     })

package/test/tools/ormStub.mjs

@@ -0,0 +1,115 @@
+import { isDeepStrictEqual } from 'util'
+import assert from 'assert'
+
+
+//替身ORM與測試共用小工具(供 unit-objcopy、api-objcopy 使用): 每次createStub各自持有calls與plan, 不共用模組層狀態
+//替身ORM記錄收到之數據, 回傳形狀依w-orm系列規格: save、del回與輸入等長之逐筆陣列, insert與delAll回聚合物件; plan可覆寫各函數之回傳
+function createStub() {
+    let calls = []
+    let plan = {}
+    function WOrmStub() {
+        let ev = {}
+        for (let fn of ['select', 'insert', 'save', 'del', 'delAll']) {
+            ev[fn] = async (data) => {
+                calls.push({ fn, data })
+                if (plan[fn]) {
+                    return plan[fn](data)
+                }
+                if (fn === 'select') {
+                    return []
+                }
+                if (fn === 'save') {
+                    return (Array.isArray(data) ? data : [data]).map(() => ({ n: 1, nInserted: 0, nModified: 1, ok: 1 }))
+                }
+                if (fn === 'del') {
+                    return (Array.isArray(data) ? data : [data]).map(() => ({ n: 1, nDeleted: 1, ok: 1 }))
+                }
+                if (fn === 'delAll') {
+                    return { n: 0, nDeleted: 0, ok: 1 }
+                }
+                return { n: 1, nInserted: 1, ok: 1 }
+            }
+        }
+        return ev
+    }
+    return {
+        WOrmStub,
+        calls,
+        reset: () => {
+            calls.length = 0
+            for (let k of Object.keys(plan)) {
+                delete plan[k]
+            }
+        },
+    }
+}
+
+
+async function getReject(pm) {
+    try {
+        await pm
+    }
+    catch (err) {
+        return err
+    }
+    throw new Error('預期reject但resolve')
+}
+
+
+async function quiet(fn) {
+    let logOrig = console.log
+    console.log = () => {}
+    try {
+        return await fn()
+    }
+    finally {
+        console.log = logOrig
+    }
+}
+
+
+//protoDiff: isDeepStrictEqual對原型之比較不完整(實測 Node 24: {__proto__:{name:'x'},id:'a'} 與 {id:'a'} 視為相等, 而這正是複本以r[k]=v建立時原型被換掉之症狀),
+//故於兩者已深度相等後逐層補比原型; 有差異回傳該層路徑, 無則回傳null
+function protoDiff(a, b, path = '') {
+    if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') {
+        return null
+    }
+    if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) {
+        return path === '' ? '(根)' : path
+    }
+    for (let k of Object.keys(a)) {
+        let r = protoDiff(a[k], b[k], `${path}.${k}`)
+        if (r !== null) {
+            return r
+        }
+    }
+    return null
+}
+
+
+//same: 深度嚴格相等且各層原型相同, 失敗時只印標籤與簡短摘要(輸入含上百萬鍵之物件時, assert.deepStrictEqual之差異輸出會癱瘓測試)
+function same(actual, expected, label = '') {
+    let ok = isDeepStrictEqual(actual, expected)
+    if (ok) {
+        let p = protoDiff(actual, expected)
+        if (p !== null) {
+            assert.fail(`${label} 原型不同於 ${p}`)
+        }
+    }
+    if (!ok) {
+        let short = (v) => {
+            let c
+            try {
+                c = typeof v === 'function' ? String(v) : JSON.stringify(v, (k, x) => (x === undefined ? '__undefined__' : x))
+            }
+            catch (e) {
+                c = String(v)
+            }
+            return c === undefined ? String(v) : c.slice(0, 200)
+        }
+        assert.fail(`${label} 不相等: 實得 ${short(actual)} / 預期 ${short(expected)}`)
+    }
+}
+
+
+export { createStub, getReject, quiet, same }

package/test/unit-WServOrm.test.mjs

@@ -395,14 +395,14 @@ describe('procOrm補主鍵', function() {
     })
 
     it('P02 依主鍵值決定是否補值', async function() {
-        //D1: null、空字串、物件補值; 數字與非空字串保留(reladb、mdb視數字為有效主鍵)
+        //R-ID-01 規則1: null、空字串、物件補值, 非空字串保留; R-ID-02 規則2: 字串型(或型別未知)主鍵欄之有限數字轉為其字串形式
         let log = []
         let A = WServOrm(dsAll, mkWOrm('A', log), 'url-a', 'db-a')
         let input = [{ id: null }, { id: '' }, { id: { x: 1 } }, { id: 123 }, { id: 'keep' }]
         let r = await A.procOrm('u1', 'tests', 'save', input)
         let got = log[0].data.map((v) => v.id)
         assert.ok(isId(got[0]) && isId(got[1]) && isId(got[2]))
-        assert.strict.equal(got[3], 123)
+        assert.strict.equal(got[3], '123')
         assert.strict.equal(got[4], 'keep')
         assert.strict.deepEqual(r.map((v) => v.id), got)
     })

package/test/unit-getDb.test.mjs

@@ -112,6 +112,17 @@ describe('getDb備份與還原', function() {
         assert.strict.deepEqual(log, [])
     })
 
+    it('B04b recover之備份之name為原型鏈名稱(constructor、toString、__proto__)即於寫入前reject, 不留部分還原', async function() {
+        //R-DB-01 規則3: 原 wsemi haskey 為 in 運算, 原型鏈名稱通過驗證, 前面之表寫入後才以 TypeError 失敗(外審 opus 二輪 F9)
+        for (let name of ['constructor', 'toString', '__proto__']) {
+            let log = []
+            let fp = writeBackup(`proto-${name}.json`, JSON.stringify([{ name: 'tests', data: [{ id: 'a' }] }, { name, data: [{ id: 'z' }] }]))
+            let err = await quiet(() => getReject(getDb.recover(mkWoItems(log), fp, { bLog: false })))
+            assert.ok(String(err).includes('invalid backup data') && String(err).includes(name), `${name}: ${err}`)
+            assert.strict.deepEqual(log, [], `${name}: 不應有任何寫入`)
+        }
+    })
+
     it('B05 recover成功', async function() {
         //D5: 成功路徑不變
         let log = []

package/test/unit-mapOrm.test.mjs

@@ -119,8 +119,8 @@ describe('mapOrm逐筆失敗', function() {
     })
 
     it('U10 del數字主鍵ok為0', async function() {
-        //R02: del逐筆ok為0即reject; 數字主鍵照列
-        plan.del = () => [okDel, { n: 0, nDeleted: 0, ok: 0, err: 'can not delete by invalid id[123]' }]
+        //R02: del逐筆ok為0即reject; 數字主鍵依R-ID-02轉為字串後交ORM, 訊息照列
+        plan.del = () => [okDel, { n: 1, nDeleted: 0, ok: 0, err: 'E-del' }]
         let err = await getReject(proc('del', [{ id: 'd1' }, { id: 123 }]))
         assert.strict.equal(err, 'failed to delete data: id[123]')
     })
@@ -277,10 +277,10 @@ describe('mapOrm主鍵與clearXSS', function() {
     })
 
     it('X05 數字主鍵、未帶主鍵與不被改寫之主鍵照常寫入', async function() {
-        //判準為是否被改寫: 數字不經清除, 未帶主鍵者由本套件補值, 白名單標籤之規範寫法不被改寫
+        //判準為是否被改寫: 數字依R-ID-02轉為字串(不含標記), 未帶主鍵者由本套件補值, 白名單標籤之規範寫法不被改寫
         plan.save = (data) => data.map(() => okSave)
         let r = await proc('save', [{ id: 5 }, { id: '<b>粗體</b>' }, { name: 'no-id' }])
-        assert.strict.equal(r[0].id, 5)
+        assert.strict.equal(r[0].id, '5')
         assert.strict.equal(r[1].id, '<b>粗體</b>')
         assert.ok(typeof r[2].id === 'string' && r[2].id.length > 0)
     })
@@ -295,14 +295,14 @@ describe('mapOrm主鍵與clearXSS', function() {
     })
 
     it('X07 insert與mix各入口之其餘主鍵狀態', async function() {
-        //數字與不被改寫之主鍵照寫, mix之修改未帶主鍵者補值, mix之刪除不經clearXSS而原樣交ORM
+        //數字依R-ID-02轉為字串, 不被改寫之主鍵照寫, mix之修改未帶主鍵者補值, mix之刪除不經clearXSS而原樣交ORM
         plan.insert = (data) => ({ n: data.length, nInserted: data.length, ok: 1 })
         plan.del = (data) => data.map(() => okDel)
         plan.save = (data) => data.map(() => okSave)
         let r1 = await proc('insert', [{ id: 7 }, { id: 'a < b' }])
-        assert.strict.deepEqual(r1, [{ id: 7 }, { id: 'a < b' }])
+        assert.strict.deepEqual(r1, [{ id: '7' }, { id: 'a < b' }])
         let r2 = await proc('mix', { add: [{ id: 8 }, { id: '1 > 0' }], del: [{ id: 'a<b' }], diff: [{ id: 9 }, { id: 'x <= 5' }, { name: 'no-id' }] })
-        assert.strict.deepEqual(r2.slice(0, 5), [{ id: 8 }, { id: '1 > 0' }, { id: 'a<b' }, { id: 9 }, { id: 'x <= 5' }])
+        assert.strict.deepEqual(r2.slice(0, 5), [{ id: '8' }, { id: '1 > 0' }, { id: 'a<b' }, { id: '9' }, { id: 'x <= 5' }])
         assert.ok(typeof r2[5].id === 'string' && r2[5].id.length > 0)
         assert.strict.deepEqual(calls.map((v) => v.fn), ['insert', 'insert', 'del', 'save'])
         assert.strict.deepEqual(calls[2].data, [{ id: 'a<b' }])