w-orm-reladb 1.1.13 → 1.1.14

package/test/api-float.mjs

@@ -0,0 +1,262 @@
+import assert from 'assert'
+import wo from '../src/WOrmReladb.mjs'
+import cvFind, { toFloating } from '../src/cvFind.mjs'
+import { withTz } from './tools/withTz.mjs'
+import { TZS, TZS_DST_EAST, OPS, WALL, CONDS, pad, condVal, condWall, wantIdx, tzSelfCheck } from './tools/floatTools.mjs'
+
+
+//本檔為mssql與sqlite共用之浮動時間測試套組(CLAUDE_rulebook.md之R14), 由api-sqlite.test.mjs與api-mssql.test.mjs引入
+//模擬w-orm-mdb之queryMemory: 資料表之DATE欄存「牆上時間分量作為UTC瞬間」(數據列經toFloating), 條件走ctx.dateNoTz:'floating'經cvFind取得where, 由model執行findAll/destroy
+//(WOrmReladb之getFindCtx不設定dateNoTz, 公開select/delAll不走此路徑; 數據由公開insert寫入, 取得where後由實例之model執行)
+//預言機: 牆上時間字串以UTC分量數值比較(Jet語意: 無時區、無夏令), 與主機時區無關
+//時區矩陣: 12個時區(含負偏移、半小時與45分偏移、+14、夏令跳過之UTC+時區), 以執行期賦值process.env.TZ切換, 每個時區先自證偏移
+
+
+let rid = (i) => `r${pad(i)}`
+
+let hostZones = TZS.concat(TZS_DST_EAST)
+
+
+/**
+ * 定義共用測試套組
+ *
+ * @param {String} label 輸入後端名稱字串('sqlite'或'mssql'), 供describe標題使用
+ * @param {Function} getOpt 輸入取得建構設定之函數, 於hook內呼叫以取得當下有效之連線資訊
+ */
+export function defineFloatSuites(label, getOpt) {
+
+    describe(`${label} 浮動時間: dateNoTz:'floating'與toFloating`, function() {
+
+        let w = null
+        let ins = null
+        let md = null
+        let cs = null
+
+        //load, 清表後以公開insert寫入[id, d]
+        let load = async (pairs) => {
+            await md.destroy({ where: {} })
+            let r = await w.insert(pairs.map(([id, d]) => ({ id, d })), cs)
+            assert.strictEqual(r.nInserted, pairs.length)
+        }
+
+        //whereOf, 取經cvFind轉譯之where(attrs取實際執行where之model之rawAttributes, 同mdb之queryMemory)
+        let whereOf = (find, ex = {}) => cvFind(find, { attrs: md.rawAttributes, pk: 'id', ...ex })
+
+        let idsOf = async (find, ex = {}) => {
+            let rs = await md.findAll({ where: whereOf(find, ex), attributes: ['id'], raw: true })
+            return rs.map((r) => r.id).sort()
+        }
+
+        let allIds = async () => (await md.findAll({ attributes: ['id'], raw: true })).map((r) => r.id).sort()
+
+        let msgOf = (e) => String(e && e.message !== undefined ? e.message : e)
+
+        before(async function() {
+            w = wo(getOpt({ cl: 'tfloat' }))
+            await w.createStorage()
+            ins = await w.init()
+            md = ins.mds.tfloat
+            cs = { instance: ins }
+        })
+
+        after(async function() {
+            await ins.close()
+        })
+
+        //運算矩陣: 條件18個牆上時間(字串、本地分量建構之Date、其epoch) x 6運算子 = 108組, 數據20列(含哨兵9999、年0100、夏令跳過/重疊之牆上時間、NULL)
+        for (let tz of hostZones) {
+
+            it(`${tz}: 108組條件(18個牆上時間 x 6運算子)命中集合 = 牆上時間數值比較之預言機, 無錯誤無誤拒; delAll($lt 今日)不誤刪9999哨兵`, async function() {
+                this.timeout(120000)
+                await withTz(tz, async () => {
+                    tzSelfCheck(tz)
+                    //數據列: 牆上時間字串經toFloating(同mdb之資料列轉換; 轉換失敗須整批拒收, 此處所有值皆須可換算)
+                    let pairs = WALL.map((x, i) => {
+                        let v = x === null ? null : toFloating(x)
+                        assert.ok(x === null || v !== null, `數據列無法換算: ${x}`)
+                        return [rid(i), v]
+                    })
+                    await load(pairs)
+                    let n = 0
+                    let bads = []
+                    for (let [wl, kind] of CONDS) {
+                        for (let op of OPS) {
+                            n += 1
+                            let cw = condWall(wl, kind)
+                            let want = wantIdx(op, cw).map(rid)
+                            let got
+                            try {
+                                got = await idsOf({ d: { [op]: condVal(wl, kind) } }, { dateNoTz: 'floating' })
+                            }
+                            catch (e) {
+                                got = `REJ:${msgOf(e).slice(0, 80)}`
+                            }
+                            if (JSON.stringify(got) !== JSON.stringify(want)) {
+                                bads.push({ wl, kind, op, got, want })
+                            }
+                        }
+                    }
+                    assert.strictEqual(n, 108)
+                    assert.deepStrictEqual(bads, [], `${tz}: 錯誤或誤拒 ${bads.length}/108`)
+
+                    //delAll($lt 今日): 三列expired、never(9999-12-31 23:59:59)、future, 只刪expired
+                    await load([['e', toFloating('2020-01-01 00:00:00')], ['n', toFloating('9999-12-31 23:59:59')], ['f', toFloating('2099-01-01 00:00:00')]])
+                    await md.destroy({ where: whereOf({ d: { $lt: '2026-10-20T00:00:00' } }, { dateNoTz: 'floating' }) })
+                    assert.deepStrictEqual(await allIds(), ['f', 'n'], `${tz}: delAll($lt 今日)誤刪哨兵`)
+
+                    //哨兵本身作條件值: 可用, 且只命中never
+                    assert.deepStrictEqual(await idsOf({ d: { $gte: '9999-12-31T23:59:59' } }, { dateNoTz: 'floating' }), ['n'])
+                    assert.deepStrictEqual(await idsOf({ d: '9999-12-31T23:59:59' }, { dateNoTz: 'floating' }), ['n'])
+                    assert.deepStrictEqual(await idsOf({ d: { $gt: '9999-12-31T23:59:58', $lte: '9999-12-31T23:59:59' } }, { dateNoTz: 'floating' }), ['n'])
+                    //$gt哨兵無列; $lt哨兵命中其餘兩列
+                    assert.deepStrictEqual(await idsOf({ d: { $gt: '9999-12-31T23:59:59' } }, { dateNoTz: 'floating' }), [])
+                    assert.deepStrictEqual(await idsOf({ d: { $lt: '9999-12-31T23:59:59' } }, { dateNoTz: 'floating' }), ['f'])
+                })
+            })
+
+        }
+
+        it('$in/$nin: 浮動值逐元素比對(2個時區)', async function() {
+            for (let tz of ['America/Los_Angeles', 'Asia/Taipei']) {
+                await withTz(tz, async () => {
+                    await load([['a', toFloating('2026-01-01 00:00:00')], ['b', toFloating('2026-06-01 12:00:00')], ['c', toFloating('9999-12-31 23:59:59')], ['z', null]])
+                    assert.deepStrictEqual(await idsOf({ d: { $in: ['2026-01-01T00:00:00', '9999-12-31T23:59:59'] } }, { dateNoTz: 'floating' }), ['a', 'c'])
+                    assert.deepStrictEqual(await idsOf({ d: { $nin: ['2026-01-01T00:00:00', '9999-12-31T23:59:59'] } }, { dateNoTz: 'floating' }), ['b'])
+                    assert.deepStrictEqual(await idsOf({ d: { $in: [] } }, { dateNoTz: 'floating' }), [])
+                    assert.deepStrictEqual(await idsOf({ d: null }, { dateNoTz: 'floating' }), ['z'])
+                    assert.deepStrictEqual(await idsOf({ d: { $ne: null } }, { dateNoTz: 'floating' }), ['a', 'b', 'c'])
+                })
+            }
+        })
+
+        it('不合法條件於轉譯階段拒收(不送SQL、資料表不變): 帶時區字串之曆法不存在、年0、5位年、亂字串、純日期(外審minimax F7)', async function() {
+            for (let tz of ['America/Los_Angeles', 'Asia/Taipei']) {
+                await withTz(tz, async () => {
+                    await load([['a', toFloating('2026-01-01 00:00:00')], ['b', toFloating('2026-06-01 00:00:00')]])
+                    for (let s of ['2026-02-30T00:00:00Z', '2025-02-29T00:00:00+08:00', '2026-04-31T00:00:00-08:00', '0000-06-15T00:00:00Z', '0000-06-15T00:00:00', '10000-01-01T00:00:00Z', '10000-01-01T00:00:00', 'garbage', '2026-01-01']) {
+                        let e = null
+                        try {
+                            await idsOf({ d: { $lt: s } }, { dateNoTz: 'floating' })
+                        }
+                        catch (err) {
+                            e = msgOf(err)
+                        }
+                        assert.ok(e !== null && e.indexOf('does not match column type [date]') >= 0, `${tz} [${s}] 應拒收: ${e}`)
+                    }
+                    assert.deepStrictEqual(await allIds(), ['a', 'b'])
+                })
+            }
+        })
+
+        //判別力自證(僅sqlite: 年10000之文字可存入sqlite而mssql不可): 同一矩陣對'local'臂(數據列以sequelize預設new Date(字串)依主機時區入表)於負偏移時區須出現錯誤或誤拒,
+        //證明上列矩陣與預言機能偵測此缺陷(現有mdb全套測試於TZ=PST8PDT亦全綠, 對此缺陷零偵測力)
+        if (label === 'sqlite') {
+            for (let tz of ['America/Los_Angeles', 'America/New_York', 'America/Sao_Paulo', 'Etc/GMT+12']) {
+                it(`${tz}: 判別力自證——'local'臂(數據列依主機時區入表)出現錯誤或誤拒, 且delAll($lt 今日)誤刪9999哨兵`, async function() {
+                    await withTz(tz, async () => {
+                        await md.destroy({ where: {} })
+                        await md.bulkCreate(WALL.map((x, i) => ({ id: rid(i), d: x }))) //x為字串, sequelize以new Date(字串)依主機時區解析
+                        let nBad = 0
+                        for (let [wl, kind] of CONDS) {
+                            for (let op of OPS) {
+                                let want = wantIdx(op, condWall(wl, kind)).map(rid)
+                                let got
+                                try {
+                                    got = await idsOf({ d: { [op]: condVal(wl, kind) } }, { dateNoTz: 'local' })
+                                }
+                                catch (e) {
+                                    got = `REJ`
+                                }
+                                if (JSON.stringify(got) !== JSON.stringify(want)) {
+                                    nBad += 1
+                                }
+                            }
+                        }
+                        assert.ok(nBad >= 20, `${tz}: 'local'臂僅 ${nBad}/108 組出錯, 矩陣的判別力不足`)
+                        //delAll($lt 今日)
+                        await md.destroy({ where: {} })
+                        await md.bulkCreate([['e', '2020-01-01 00:00:00'], ['n', '9999-12-31 23:59:59'], ['f', '2099-01-01 00:00:00']].map(([id, d]) => ({ id, d })))
+                        await md.destroy({ where: whereOf({ d: { $lt: '2026-10-20T00:00:00' } }, { dateNoTz: 'local' }) })
+                        assert.deepStrictEqual(await allIds(), ['f'], `${tz}: 'local'臂應誤刪哨兵n(此為修前缺陷, 'local'不變)`)
+                    })
+                })
+            }
+        }
+
+        //契約①: 編碼後之浮動Date(經資料庫讀回之Date)不可再當'floating'條件輸入
+        it('契約①: 以toFloating入表之列, 經model讀回之Date再作條件輸入即二次位移(LA: $eq不命中該列、$ne命中; UTC: 恆等)', async function() {
+            for (let tz of ['America/Los_Angeles', 'Asia/Taipei', 'UTC']) {
+                await withTz(tz, async () => {
+                    await load([['a', toFloating('2026-10-20 01:00:00')], ['b', toFloating('2026-10-21 01:00:00')]])
+                    let row = (await md.findAll({ where: { id: 'a' } }))[0]
+                    let back = row.get('d')
+                    assert.ok(back instanceof Date)
+                    assert.strictEqual(back.toISOString(), '2026-10-20T01:00:00.000Z', '讀回之Date即浮動瞬間')
+                    //原條件(牆上時間字串)命中
+                    assert.deepStrictEqual(await idsOf({ d: '2026-10-20T01:00:00' }, { dateNoTz: 'floating' }), ['a'])
+                    //讀回之Date當條件
+                    let eq = await idsOf({ d: { $eq: back } }, { dateNoTz: 'floating' })
+                    let ne = await idsOf({ d: { $ne: back } }, { dateNoTz: 'floating' })
+                    if (tz === 'UTC') {
+                        assert.deepStrictEqual(eq, ['a'])
+                        assert.deepStrictEqual(ne, ['b'])
+                    }
+                    else {
+                        assert.deepStrictEqual(eq, [], `${tz}: 二次位移後不應命中該列`)
+                        assert.deepStrictEqual(ne, ['a', 'b'], `${tz}: 二次位移後$ne命中該列(可被delAll刪除)`)
+                    }
+                })
+            }
+        })
+
+        //契約②: toFloating回null者呼叫端須整批拒收, 不得以原值或NULL代入
+        it('契約②: 參考之呼叫端轉換遇toFloating為null即整批拒收(資料表不變); 以NULL代入則該列被範圍條件漏掉、被IS NULL命中', async function() {
+            let encode = (rows) => rows.map((r) => {
+                let v = r.d === null || r.d === undefined ? r.d : toFloating(r.d)
+                if (v === null) {
+                    throw new Error(`invalid wall time at [${r.id}]`)
+                }
+                return { id: r.id, d: v }
+            })
+            await load([['k', toFloating('2020-01-01 00:00:00')]])
+            let rows = [{ id: 'a', d: '2026-01-01 00:00:00' }, { id: 'b', d: '2026-02-30 00:00:00' }, { id: 'c', d: '2026-03-01 00:00:00' }]
+            let r = null
+            try {
+                encode(rows)
+            }
+            catch (e) {
+                r = msgOf(e)
+            }
+            assert.strictEqual(r, 'invalid wall time at [b]')
+            assert.deepStrictEqual(await allIds(), ['k'], '整批拒收時不得有任何列寫入')
+
+            //反例: 以NULL代入
+            let filled = rows.map((x) => ({ id: x.id, d: toFloating(x.d) })) //b為null: 即以NULL代入
+            assert.strictEqual(filled[1].d, null)
+            let ins2 = await w.insert(filled, cs)
+            assert.strictEqual(ins2.nInserted, 3)
+            assert.ok((await idsOf({ d: { $lt: '2099-01-01T00:00:00' } }, { dateNoTz: 'floating' })).indexOf('b') < 0, 'NULL列不被範圍條件命中')
+            assert.deepStrictEqual(await idsOf({ d: null }, { dateNoTz: 'floating' }), ['b'], 'NULL列被IS NULL命中')
+        })
+
+        //契約④: 條件走'floating'與資料側toFloating同進同退
+        it('契約④: 同進同退——數據列經toFloating + floating條件得正確結果; 混用(數據列未經toFloating)於LA靜默誤命中', async function() {
+            await withTz('America/Los_Angeles', async () => {
+                let cond = { d: { $lt: '2026-10-20T04:00:00' } }
+
+                //同進: 牆上01:00 < 04:00 命中, 牆上05:00不命中
+                await load([['a', toFloating('2026-10-20 01:00:00')], ['b', toFloating('2026-10-20 05:00:00')]])
+                assert.deepStrictEqual(await idsOf(cond, { dateNoTz: 'floating' }), ['a'])
+
+                //混用: 數據列以本地分量建構之Date入表(PDT, UTC-7: 牆上01:00 = 08:00Z), 條件為浮動值(04:00Z)
+                await load([['a', new Date(2026, 9, 20, 1, 0, 0)], ['b', new Date(2026, 9, 20, 5, 0, 0)]])
+                assert.deepStrictEqual(await idsOf(cond, { dateNoTz: 'floating' }), [], '混用: 牆上01:00之列本應命中而被漏掉(靜默誤命中)')
+                //另一方向: 浮動數據列配'local'條件亦錯位(牆上01:00 = 01:00Z, 'local'條件04:00本地 = 11:00Z)
+                await load([['a', toFloating('2026-10-20 01:00:00')], ['b', toFloating('2026-10-20 05:00:00')], ['c', toFloating('2026-10-20 15:00:00')]])
+                assert.deepStrictEqual(await idsOf(cond, { dateNoTz: 'local' }), ['a', 'b'], '混用: 浮動數據列配local條件, 牆上05:00之列被誤命中')
+            })
+        })
+
+    })
+
+}

package/test/api-lower-cases.mjs

@@ -0,0 +1,129 @@
+import assert from 'assert'
+import wo from '../src/WOrmReladb.mjs'
+import lowerCases from 'wsemi/src/_lowerFindCases.mjs'
+
+
+//本檔為mssql與sqlite共用之wsemi契約案例表_lowerFindCases(方言中立條件IR之契約表, 85案)測試套組(CLAUDE_rulebook.md之R15), 由api-sqlite.test.mjs與api-mssql.test.mjs引入
+//本套件不採IR, 但此表之hits(手寫, 依SQL三值邏輯手推)是SQL族對公開select與delAll之共同期望, 作為日後任何翻譯層變更之守門
+//規則: 依表之columns建model(models/tlower.js), seed()6列; 逐案對公開select與delAll驗——
+//  非schema案兩函數須皆接受, select命中 = delAll實際刪除之id集合 = hits; hits為[]者恆假;
+//  hits為null(字串順序比較依collation而異)只驗兩函數一致; schema為true者(型別化後端可因欄位型別拒收)可reject, 但兩函數須一致reject、資料不變, 未reject時須 = hits
+
+
+let { seed, semantics } = lowerCases
+
+let ALL = [1, 2, 3, 4, 5, 6]
+
+//案例表規模下限(wsemi 1.9.25為85案)與schema案之上限, 防止案例表被掏空後仍全綠
+let nMin = 85
+
+let ids = (rs) => rs.map((v) => v.id).sort((a, b) => a - b)
+
+let msgOf = (err) => String(err && err.message !== undefined ? err.message : err)
+
+//settle, 執行promise並回傳{ok,v}或{err}
+let settle = (pm) => pm.then((v) => ({ ok: true, v })).catch((err) => ({ err }))
+
+
+/**
+ * 定義共用測試套組
+ *
+ * @param {String} label 輸入後端名稱字串('sqlite'或'mssql'), 供describe標題使用
+ * @param {Function} getOpt 輸入取得建構設定之函數, 於hook內呼叫以取得當下有效之連線資訊
+ */
+export function defineLowerCaseSuites(label, getOpt) {
+
+    describe(`${label} lowerFind契約表: 案例逐案對select與delAll`, function() {
+
+        let w = null
+        let ins = null
+        let cs = null
+
+        //stats, 各案測試時累計, 供最末之防空轉斷言
+        let stats = { accepted: 0, acceptedHit: 0, acceptedNull: 0, rejected: 0 }
+
+        let reset = async () => {
+            await w.delAll({}, cs)
+            let r = await w.insert(seed(), cs)
+            assert.strictEqual(r.nInserted, 6)
+        }
+
+        before(async function() {
+            w = wo(getOpt({ cl: 'tlower' }))
+            await w.createStorage()
+            ins = await w.init()
+            cs = { instance: ins }
+        })
+
+        after(async function() {
+            await ins.close()
+        })
+
+        it(`案例表規模: 至少${nMin}案, 代號不重複, 含hits為[]、非空、null三類與schema案`, function() {
+            assert.ok(semantics.length >= nMin, `案數 ${semantics.length}`)
+            assert.strictEqual(new Set(semantics.map((c) => c.id)).size, semantics.length)
+            assert.ok(semantics.some((c) => Array.isArray(c.hits) && c.hits.length === 0))
+            assert.ok(semantics.some((c) => Array.isArray(c.hits) && c.hits.length > 0))
+            assert.ok(semantics.some((c) => c.hits === null))
+            assert.ok(semantics.some((c) => c.schema === true))
+        })
+
+        it('種子: 6列, id 1~6', async function() {
+            let sd = seed()
+            assert.deepStrictEqual(sd.map((v) => v.id), ALL)
+            await reset()
+            assert.deepStrictEqual(ids(await w.select({}, cs)), ALL)
+        })
+
+        for (let c of semantics) {
+
+            it(`${c.id} (${c.node}): select命中 = delAll刪除 = hits${c.hits === null ? '(null: 只驗兩函數一致)' : ''}${c.schema ? '(schema案可reject)' : ''}`, async function() {
+                await reset()
+                let rs = await settle(w.select(c.find(), cs))
+                if (rs.err !== undefined) {
+                    //schema案: 型別化後端可因欄位型別檢核而reject, 此時兩函數須一致reject且資料不變
+                    assert.ok(c.schema === true, `非schema案不得reject: ${msgOf(rs.err)}`)
+                    assert.strictEqual(msgOf(rs.err).indexOf('invalid find: '), 0, msgOf(rs.err))
+                    let before = ids(await w.select({}, cs))
+                    let rd = await settle(w.delAll(c.find(), cs))
+                    assert.ok(rd.err !== undefined, 'select reject而delAll未reject')
+                    assert.strictEqual(msgOf(rd.err), msgOf(rs.err))
+                    assert.deepStrictEqual(ids(await w.select({}, cs)), before)
+                    stats.rejected += 1
+                    return
+                }
+                let sel = ids(rs.v)
+                if (c.hits !== null) {
+                    assert.deepStrictEqual(sel, c.hits, 'select之命中')
+                }
+                let r = await w.delAll(c.find(), cs)
+                let left = ids(await w.select({}, cs))
+                let gone = ALL.filter((v) => left.indexOf(v) < 0)
+                assert.deepStrictEqual(gone, sel, 'delAll之刪除 = select之命中')
+                if (c.hits !== null) {
+                    assert.deepStrictEqual(gone, c.hits, 'delAll之刪除')
+                }
+                assert.deepStrictEqual(r, { n: gone.length, nDeleted: gone.length, ok: 1 })
+                stats.accepted += 1
+                if (c.hits === null) {
+                    stats.acceptedNull += 1
+                }
+                else if (c.hits.length > 0) {
+                    stats.acceptedHit += 1
+                }
+            })
+
+        }
+
+        it('防空轉: 全部非schema案皆被接受(任一正常案全部reject即紅), 且命中非空之案數達標', function() {
+            let nSchema = semantics.filter((c) => c.schema === true).length
+            let nHit = semantics.filter((c) => Array.isArray(c.hits) && c.hits.length > 0).length
+            assert.ok(stats.rejected <= nSchema, `reject ${stats.rejected} 案, 超過schema案數 ${nSchema}`)
+            assert.ok(stats.accepted >= semantics.length - nSchema, `接受 ${stats.accepted} 案, 少於 ${semantics.length - nSchema}`)
+            assert.ok(stats.acceptedHit >= nHit - nSchema, `命中非空之接受案 ${stats.acceptedHit} 少於 ${nHit - nSchema}`)
+            assert.ok(stats.acceptedHit >= 50, `命中非空之接受案 ${stats.acceptedHit} 不足50`)
+        })
+
+    })
+
+}

package/test/api-mssql.test.mjs

@@ -5,6 +5,9 @@ import { defineSuites } from './api-suite.mjs'
 import { defineWhitelistSuites } from './api-find-whitelist.mjs'
 import { defineDateWriteSuites } from './api-date-write.mjs'
 import { defineWellformedSuites } from './api-wellformed.mjs'
+import { defineLowerCaseSuites } from './api-lower-cases.mjs'
+import { defineScopeSuites } from './api-scope.mjs'
+import { defineFloatSuites } from './api-float.mjs'
 
 
 //測試自行創建docker容器供MSSQL服務, 測試結束即銷毀, 故僅需環境已安裝docker
@@ -151,3 +154,6 @@ defineSuites('mssql', getOpt)
 defineWhitelistSuites('mssql', getOpt)
 defineDateWriteSuites('mssql', getOpt)
 defineWellformedSuites('mssql', getOpt)
+defineLowerCaseSuites('mssql', getOpt)
+defineScopeSuites('mssql', getOpt)
+defineFloatSuites('mssql', getOpt)

package/test/api-scope.mjs

@@ -0,0 +1,208 @@
+import fs from 'fs'
+import path from 'path'
+import assert from 'assert'
+import wo from '../src/WOrmReladb.mjs'
+
+
+//本檔為mssql與sqlite共用之defaultScope測試套組(CLAUDE_rulebook.md之R16), 由api-sqlite.test.mjs與api-mssql.test.mjs引入
+//sequelize預設以Object.assign合併scope.where與傳入where(同名頂層鍵後者覆寫), scope.where為Sequelize.literal或Sequelize.where(非一般物件)時scope直接被丟棄;
+//WOrmReladb於Sequelize實例之define層級設定whereMergeStrategy:'and', 令兩者一律以AND結合
+//5種defaultScope(純鍵、Op.or、Op.and、Sequelize.literal、Sequelize.where) x 5種find, 對公開select與delAll:
+//  select之命中 = delAll實際刪除之主鍵集合 = 手推期望(scope範圍內且符合find之列); delAll實際刪除之主鍵以不套scope之讀取(unscoped)取得, 不以select代替
+//Op.and之scope: chkScopeForDelAll維持拒收delAll(R1), select則須套用該scope
+
+
+let ROWS = [
+    { id: '1', g: 'A', name: 'x' },
+    { id: '2', g: 'B', name: 'x' },
+    { id: '3', g: 'A', name: 'y' },
+    { id: '4', g: 'C', name: 'x' },
+]
+
+//SCOPES, where為寫入model檔之defaultScope.where原始碼, inScope為scope範圍之手推判定
+let SCOPES = [
+    { key: 'pk', label: '純鍵', where: '{ g: \'A\' }', inScope: (r) => r.g === 'A', delAllRejects: false },
+    { key: 'or', label: 'Op.or', where: '{ [Op.or]: [{ g: \'A\' }, { g: \'C\' }] }', inScope: (r) => r.g === 'A' || r.g === 'C', delAllRejects: false },
+    { key: 'and', label: 'Op.and', where: '{ [Op.and]: [{ g: \'A\' }] }', inScope: (r) => r.g === 'A', delAllRejects: true },
+    { key: 'lit', label: 'Sequelize.literal', where: 'sequelize.literal(\'g = \\\'A\\\'\')', inScope: (r) => r.g === 'A', delAllRejects: false },
+    { key: 'whr', label: 'Sequelize.where', where: 'sequelize.where(sequelize.col(\'g\'), \'A\')', inScope: (r) => r.g === 'A', delAllRejects: false },
+    //model自身指定whereMergeStrategy:'overwrite'(蓋過Sequelize實例之define預設): 匯入後仍強制為'and'(外審sol F2)
+    { key: 'ovw', label: 'Sequelize.literal + model自身指定whereMergeStrategy overwrite', where: 'sequelize.literal(\'g = \\\'A\\\'\')', modelOpt: ', whereMergeStrategy: \'overwrite\'', inScope: (r) => r.g === 'A', delAllRejects: false },
+]
+
+//FINDS, p為find之手推判定
+let FINDS = [
+    { label: '{g:"B"}(與scope同欄之單葉)', find: () => ({ g: 'B' }), p: (r) => r.g === 'B' },
+    { label: '{name:"x"}(他欄單葉)', find: () => ({ name: 'x' }), p: (r) => r.name === 'x' },
+    { label: '$or根', find: () => ({ $or: [{ g: 'B' }, { name: 'y' }] }), p: (r) => r.g === 'B' || r.name === 'y' },
+    { label: 'and根(多欄)', find: () => ({ name: 'x', g: { $ne: 'Z' } }), p: (r) => r.name === 'x' && r.g !== 'Z' },
+    { label: '{}(全部)', find: () => ({}), p: () => true },
+]
+
+let ids = (rs) => rs.map((v) => v.id).sort()
+
+let msgOf = (err) => String(err && err.message !== undefined ? err.message : err)
+
+let genModel = (cl, where, modelOpt = '') => {
+    return [
+        'module.exports = function(sequelize, DataTypes) {',
+        '    let Op = require(\'sequelize\').Op',
+        `    return sequelize.define('${cl}', {`,
+        '        id: { type: DataTypes.STRING, allowNull: false, primaryKey: true },',
+        '        g: { type: DataTypes.STRING, allowNull: true },',
+        '        name: { type: DataTypes.STRING, allowNull: true },',
+        `    }, { tableName: '${cl}', defaultScope: { where: ${where} }${modelOpt} })`,
+        '}',
+        '',
+    ].join('\n')
+}
+
+
+/**
+ * 定義共用測試套組
+ *
+ * @param {String} label 輸入後端名稱字串('sqlite'或'mssql'), 供describe標題與暫存夾使用
+ * @param {Function} getOpt 輸入取得建構設定之函數, 於hook內呼叫以取得當下有效之連線資訊
+ */
+export function defineScopeSuites(label, getOpt) {
+
+    let fd = `./test/_tmp/api-scope-${label}`
+
+    describe(`${label} defaultScope: 6種scope(含model自身指定overwrite) x 5種find, select與delAll不越出scope`, function() {
+
+        before(function() {
+            fs.mkdirSync(fd, { recursive: true })
+            for (let sc of SCOPES) {
+                fs.writeFileSync(path.join(fd, `tsc${sc.key}.js`), genModel(`tsc${sc.key}`, sc.where, sc.modelOpt), 'utf8')
+            }
+        })
+
+        after(function() {
+            fs.rmSync(fd, { recursive: true, force: true })
+        })
+
+        for (let sc of SCOPES) {
+
+            describe(`scope ${sc.label}`, function() {
+
+                let cl = `tsc${sc.key}`
+                let w = null
+                let ins = null
+                let cs = null
+
+                //unscoped, 不套scope之全表讀取(取delAll實際刪除之主鍵), 不經select
+                let unscoped = async () => {
+                    return ids(await ins.mds[cl].unscoped().findAll({ raw: true }))
+                }
+
+                before(async function() {
+                    w = wo(getOpt({ cl, fdModels: fd }))
+                    await w.createStorage()
+                    ins = await w.init()
+                    cs = { instance: ins }
+                })
+
+                after(async function() {
+                    await ins.close()
+                })
+
+                beforeEach(async function() {
+                    await ins.mds[cl].unscoped().destroy({ where: {} })
+                    let r = await w.insert(ROWS, cs)
+                    assert.strictEqual(r.nInserted, 4)
+                    assert.deepStrictEqual(await unscoped(), ['1', '2', '3', '4'])
+                })
+
+                it('合併策略: Sequelize實例之define預設與匯入後之model皆為whereMergeStrategy:and(model自身指定overwrite者亦被改為and)', function() {
+                    let md = ins.mds[cl]
+                    assert.strictEqual(md.sequelize.options.define.whereMergeStrategy, 'and')
+                    assert.strictEqual(md.options.whereMergeStrategy, 'and')
+                })
+
+                it('前提: select({})僅回scope範圍內之列(scope確實套用)', async function() {
+                    let exp = ids(ROWS.filter(sc.inScope))
+                    assert.ok(exp.length > 0 && exp.length < ROWS.length, '夾具之scope須同時含範圍內外之列')
+                    assert.deepStrictEqual(ids(await w.select({}, cs)), exp)
+                })
+
+                for (let f of FINDS) {
+
+                    it(`${f.label}: select命中 = 手推期望(scope AND find)`, async function() {
+                        let exp = ids(ROWS.filter((r) => sc.inScope(r) && f.p(r)))
+                        assert.deepStrictEqual(ids(await w.select(f.find(), cs)), exp)
+                    })
+
+                    if (sc.delAllRejects) {
+                        it(`${f.label}: delAll拒收(chkScopeForDelAll維持, 含Op.and之scope.where)且不刪除`, async function() {
+                            let r = await w.delAll(f.find(), cs).then(() => null).catch((err) => msgOf(err))
+                            assert.ok(r !== null && r.indexOf('defaultScope') >= 0, `未reject: ${r}`)
+                            assert.deepStrictEqual(await unscoped(), ['1', '2', '3', '4'])
+                        })
+                    }
+                    else {
+                        it(`${f.label}: delAll實際刪除之主鍵集合 = 手推期望, 不越出scope`, async function() {
+                            let exp = ids(ROWS.filter((r) => sc.inScope(r) && f.p(r)))
+                            let r = await w.delAll(f.find(), cs)
+                            let left = await unscoped()
+                            let gone = ['1', '2', '3', '4'].filter((v) => left.indexOf(v) < 0)
+                            assert.deepStrictEqual(gone, exp, `delAll刪除之主鍵(scope範圍: ${ids(ROWS.filter(sc.inScope))})`)
+                            assert.ok(gone.every((v) => sc.inScope(ROWS.find((x) => x.id === v))), 'delAll刪到scope之外')
+                            assert.deepStrictEqual(r, { n: exp.length, nDeleted: exp.length, ok: 1 })
+                        })
+                    }
+
+                }
+
+                it('scope內之主鍵: selectByPk命中、del實際刪除該列(其餘列不動)、save更新該列完整欄位(外審sol F5)', async function() {
+                    let inRows = ROWS.filter(sc.inScope)
+                    let inId = inRows[0].id
+                    let other = ['1', '2', '3', '4'].filter((v) => v !== inId)
+                    assert.deepStrictEqual(await w.selectByPk(inId, cs), ROWS.find((r) => r.id === inId))
+                    //save: 更新scope內之列
+                    let rs = await w.save({ id: inId, g: inRows[0].g, name: 'zz' }, cs)
+                    assert.deepStrictEqual(rs, [{ n: 1, nInserted: 0, nModified: 1, ok: 1 }])
+                    assert.deepStrictEqual(await w.selectByPk(inId, cs), { id: inId, g: inRows[0].g, name: 'zz' })
+                    //del: 刪除scope內之列
+                    let rd = await w.del({ id: inId }, cs)
+                    assert.deepStrictEqual(rd, [{ n: 1, nDeleted: 1, ok: 1 }])
+                    assert.deepStrictEqual(await unscoped(), other, 'del只刪該列')
+                })
+
+                it('scope外已存在之主鍵: save(預設autoInsert:true)本筆失敗(ok:0, 預讀不見該列而改插入, 撞主鍵重試耗盡), 該列不改動(外審minimax F1; 修前literal/where scope下該列會被更新)', async function() {
+                    let outRow = ROWS.find((r) => !sc.inScope(r))
+                    let rs = await w.save({ id: outRow.id, g: outRow.g, name: 'zz' }, cs)
+                    assert.strictEqual(rs.length, 1)
+                    assert.strictEqual(rs[0].ok, 0, `scope外之既有主鍵save應失敗: ${JSON.stringify(rs)}`)
+                    assert.strictEqual(rs[0].nModified, 0)
+                    assert.strictEqual(rs[0].nInserted, 0)
+                    assert.ok(String(rs[0].err).indexOf('can not save') >= 0, String(rs[0].err))
+                    let row = (await ins.mds[cl].unscoped().findAll({ where: { id: outRow.id }, raw: true }))[0]
+                    assert.strictEqual(row.name, outRow.name, 'scope外之列被改動')
+                    assert.deepStrictEqual(await unscoped(), ['1', '2', '3', '4'])
+                })
+
+                it('scope外之主鍵: save(autoInsert:false)不改動該列(外審sol F5)', async function() {
+                    let outRow = ROWS.find((r) => !sc.inScope(r))
+                    let rs = await w.save({ id: outRow.id, g: outRow.g, name: 'zz' }, { ...cs, autoInsert: false })
+                    assert.strictEqual(rs[0].nModified, 0, `save更新了scope外之列: ${JSON.stringify(rs)}`)
+                    let row = (await ins.mds[cl].unscoped().findAll({ where: { id: outRow.id }, raw: true }))[0]
+                    assert.strictEqual(row.name, outRow.name, 'scope外之列被改動')
+                })
+
+                it('selectByPk、del亦不越出scope(scope外之主鍵: selectByPk回null、del不刪)', async function() {
+                    let outId = ROWS.find((r) => !sc.inScope(r)).id
+                    let inId = ROWS.find((r) => sc.inScope(r)).id
+                    assert.strictEqual(await w.selectByPk(outId, cs), null)
+                    assert.ok((await w.selectByPk(inId, cs)) !== null)
+                    let r = await w.del({ id: outId }, cs)
+                    assert.deepStrictEqual(r, [{ n: 0, nDeleted: 0, ok: 1 }], 'del刪到scope外之列')
+                    assert.deepStrictEqual(await unscoped(), ['1', '2', '3', '4'])
+                })
+
+            })
+
+        }
+
+    })
+
+}

package/test/api-sqlite.test.mjs

@@ -3,6 +3,9 @@ import { defineSuites } from './api-suite.mjs'
 import { defineWhitelistSuites } from './api-find-whitelist.mjs'
 import { defineDateWriteSuites } from './api-date-write.mjs'
 import { defineWellformedSuites } from './api-wellformed.mjs'
+import { defineLowerCaseSuites } from './api-lower-cases.mjs'
+import { defineScopeSuites } from './api-scope.mjs'
+import { defineFloatSuites } from './api-float.mjs'
 
 
 //sqlite使用獨立暫存storage檔測試, 不使用專案根目錄之worm.sqlite
@@ -46,3 +49,6 @@ defineSuites('sqlite', getOpt)
 defineWhitelistSuites('sqlite', getOpt)
 defineDateWriteSuites('sqlite', getOpt)
 defineWellformedSuites('sqlite', getOpt)
+defineLowerCaseSuites('sqlite', getOpt)
+defineScopeSuites('sqlite', getOpt)
+defineFloatSuites('sqlite', getOpt)