w-serv-orm 1.1.8 → 1.1.9

package/src/getProc.mjs

@@ -1,189 +1,104 @@
-import get from 'lodash-es/get.js'
-import filter from 'lodash-es/filter.js'
-import isarr from 'wsemi/src/isarr.mjs'
-import isestr from 'wsemi/src/isestr.mjs'
-import iseobj from 'wsemi/src/iseobj.mjs'
-import haskey from 'wsemi/src/haskey.mjs'
-import pmSeries from 'wsemi/src/pmSeries.mjs'
-import isfun from 'wsemi/src/isfun.mjs'
-import isbol from 'wsemi/src/isbol.mjs'
-
-
-function addFun(fs, f, name, useGuard = false) {
-    //由外部添加擴充函數至該實例之陣列
-    //延後1ms生效係沿用既有之生效時序: 原為避開模組層陣列於循環引用時之「Cannot access before initialization」,
-    //改為各實例狀態後該原因已不成立, 惟使用端之啟動流程可能依賴此時序, 故保留
-
-    //check, 非函數於註冊時即拋錯; useGuard(check用)另推入恆reject之守門函數, 令拋錯被呼叫端攔下時該實例仍維持fail-closed
-    //註冊時拋錯屬建構期錯誤故為Error; 守門函數於procOrm內reject, 與procOrm其餘拒絕一致為字串
-    if (!isfun(f)) {
-        let msg = `${name} needs a function, but got ${typeof f}`
-        if (useGuard) {
-            fs.push(() => {
-                return Promise.reject(msg)
-            })
-        }
-        throw new Error(msg)
-    }
-
-    setTimeout(() => {
-        fs.push(f)
-    }, 1)
-
-}
-
-
-async function procOrm(st, userId, woName, mode, input) {
-    //封裝mapOrm, 添加檢查userId功能, st為該實例之狀態
-
-    //check
-    if (!isfun(st.mapOrm)) {
-        return Promise.reject(`invalid mapOrm`)
-    }
-
-    //check
-    if (st.useCheckUser && !isestr(userId)) {
-        console.log('userId', userId)
-        console.log('invalid userId')
-        return Promise.reject(`invalid userId`)
-    }
-
-    //isAdmin
-    let isAdmin = 'n'
-
-    //useCheckUser
-    if (st.useCheckUser) {
-
-        //check
-        if (!isfun(st.getUserById)) {
-            return Promise.reject(`invalid getUserById`)
-        }
-
-        //oSelf
-        let oSelf = await st.getUserById(userId)
-
-        //check
-        if (!oSelf) {
-            console.log('userId', userId)
-            console.log('can not find user')
-            return Promise.reject(`can not find user`)
-        }
-
-        //isAdmin
-        isAdmin = get(oSelf, 'isAdmin')
-        if (isAdmin !== 'y' && isAdmin !== 'n') {
-            isAdmin = 'n'
-        }
-
-        //isActive
-        let isActive = get(oSelf, 'isActive')
-        if (isActive !== 'y' && isActive !== 'n') {
-            isActive = 'n'
-        }
-
-        //check
-        if (isActive !== 'y') {
-            console.log('userId', userId)
-            console.log('oSelf', oSelf)
-            console.log('user is inactive or invalid')
-            return Promise.reject(`user is inactive or invalid`)
-        }
-
-    }
-
-    //funChecks, 擴充檢查, 提供給各 mOrm[OOO].mjs 檢查
-    await pmSeries(st.funChecks, (v) => {
-        return v({ woName, userId, isAdmin, mode, input })
-    })
-
-    //funPreProcessing, 擴充前處理input, 提供給各 mOrm[OOO].mjs 前處理
-    //逐一呼叫, 各前處理皆收新建之參數物件, input為前一個回傳之input; 回傳須為含input之物件, 否則reject, 避免input成為undefined而令select回全表
-    //迭代前先取快照, 呼叫進行中註冊者不套用於本次呼叫
-    for (let f of [...st.funPreProcessing]) {
-        let paramsOut = await f({ woName, userId, isAdmin, mode, input })
-        if (!iseobj(paramsOut) || paramsOut.input === undefined) {
-            return Promise.reject(`invalid return of pre-processing, need an object with input`)
-        }
-        input = paramsOut.input
-    }
-
-    //output
-    let output = await st.mapOrm(userId, woName, mode, input)
-
-    //useExcludeWhenNotAdmin, 非管理者則要過濾掉已刪除之數據
-    if (st.useExcludeWhenNotAdmin && isAdmin === 'n') {
-        if (mode === 'select' && isarr(output)) { //有可能為錯誤物件
-            output = filter(output, (v) => {
-                if (haskey(v, 'isActive')) { //針對有isActive屬性
-                    return !(v.isActive === 'n') //過濾isActive='n'
-                }
-                return true
-            })
-        }
-    }
-
-    //funPostProcessing, 擴充後處理output, 提供給各 mOrm[OOO].mjs 後處理
-    //逐一呼叫, 各後處理皆收新建之參數物件, output為前一個之回傳值, 回傳值成為新output; 迭代前先取快照
-    for (let f of [...st.funPostProcessing]) {
-        output = await f({ woName, userId, isAdmin, mode, input, output })
-    }
-
-    return output
-}
-
-
-function getProc(mapOrm, opt = {}) {
-
-    //check
-    if (!isfun(mapOrm)) {
-        return Promise.reject(`invalid mapOrm`)
-    }
-
-    //useCheckUser
-    let useCheckUser = get(opt, 'useCheckUser')
-    if (!isbol(useCheckUser)) {
-        useCheckUser = true
-    }
-
-    //getUserById, 不事先檢查, 因若useCheckUser=false可允許不給
-    let getUserById = get(opt, 'getUserById')
-
-    //useExcludeWhenNotAdmin
-    let useExcludeWhenNotAdmin = get(opt, 'useExcludeWhenNotAdmin')
-    if (!isbol(useExcludeWhenNotAdmin)) {
-        useExcludeWhenNotAdmin = true
-    }
-
-    //st, 各實例之狀態, 每次呼叫各自建立, 令同一行程內之多個實例互不干擾
-    let st = {
-        funChecks: [],
-        funPreProcessing: [],
-        funPostProcessing: [],
-        mapOrm,
-        getUserById,
-        useCheckUser,
-        useExcludeWhenNotAdmin,
-    }
-
-    //回傳函數綁定st而不依賴this, 使用端可解構取用並當裸函數傳遞
-    return {
-        addFunCheck: (f) => {
-            //由外部添加擴充檢查函數
-            addFun(st.funChecks, f, 'addFunCheck', true)
-        },
-        addFunPreProcessing: (f) => {
-            //由外部添加擴充前處理函數
-            addFun(st.funPreProcessing, f, 'addFunPreProcessing')
-        },
-        addFunPostProcessing: (f) => {
-            //由外部添加擴充後置處理函數
-            addFun(st.funPostProcessing, f, 'addFunPostProcessing')
-        },
-        procOrm: async (userId, woName, mode, input) => {
-            return procOrm(st, userId, woName, mode, input)
-        },
-    }
-}
-
-
-export default getProc
+import iseobj from 'wsemi/src/iseobj.mjs'
+import pmSeries from 'wsemi/src/pmSeries.mjs'
+import isfun from 'wsemi/src/isfun.mjs'
+
+
+function addFun(fs, f, name, useGuard = false) {
+    //由外部添加擴充函數至該實例之陣列
+    //延後1ms生效係沿用既有之生效時序: 原為避開模組層陣列於循環引用時之「Cannot access before initialization」,
+    //改為各實例狀態後該原因已不成立, 惟使用端之啟動流程可能依賴此時序, 故保留
+
+    //check, 非函數於註冊時即拋錯; useGuard(check用)另推入恆reject之守門函數, 令拋錯被呼叫端攔下時該實例仍維持fail-closed
+    //註冊時拋錯屬建構期錯誤故為Error; 守門函數於procOrm內reject, 與procOrm其餘拒絕一致為字串
+    if (!isfun(f)) {
+        let msg = `${name} needs a function, but got ${typeof f}`
+        if (useGuard) {
+            fs.push(() => {
+                return Promise.reject(msg)
+            })
+        }
+        throw new Error(msg)
+    }
+
+    setTimeout(() => {
+        fs.push(f)
+    }, 1)
+
+}
+
+
+async function procOrm(st, userId, woName, mode, input) {
+    //封裝mapOrm, 依序執行擴充檢查、前處理、ORM操作與後處理, st為該實例之狀態
+    //不做授權: 不檢查使用者亦不依使用者過濾數據, userId只供寫入稽核欄位與交給擴充函數; 開放給前端時須由開放處負責授權
+
+    //check
+    if (!isfun(st.mapOrm)) {
+        return Promise.reject(`invalid mapOrm`)
+    }
+
+    //funChecks, 擴充檢查, 提供給各 mOrm[OOO].mjs 檢查
+    await pmSeries(st.funChecks, (v) => {
+        return v({ woName, userId, mode, input })
+    })
+
+    //funPreProcessing, 擴充前處理input, 提供給各 mOrm[OOO].mjs 前處理
+    //逐一呼叫, 各前處理皆收新建之參數物件, input為前一個回傳之input; 回傳須為含input之物件, 否則reject, 避免input成為undefined而令select回全表
+    //迭代前先取快照, 呼叫進行中註冊者不套用於本次呼叫
+    for (let f of [...st.funPreProcessing]) {
+        let paramsOut = await f({ woName, userId, mode, input })
+        if (!iseobj(paramsOut) || paramsOut.input === undefined) {
+            return Promise.reject(`invalid return of pre-processing, need an object with input`)
+        }
+        input = paramsOut.input
+    }
+
+    //output
+    let output = await st.mapOrm(userId, woName, mode, input)
+
+    //funPostProcessing, 擴充後處理output, 提供給各 mOrm[OOO].mjs 後處理
+    //逐一呼叫, 各後處理皆收新建之參數物件, output為前一個之回傳值, 回傳值成為新output; 迭代前先取快照
+    for (let f of [...st.funPostProcessing]) {
+        output = await f({ woName, userId, mode, input, output })
+    }
+
+    return output
+}
+
+
+function getProc(mapOrm) {
+
+    //check
+    if (!isfun(mapOrm)) {
+        return Promise.reject(`invalid mapOrm`)
+    }
+
+    //st, 各實例之狀態, 每次呼叫各自建立, 令同一行程內之多個實例互不干擾
+    let st = {
+        funChecks: [],
+        funPreProcessing: [],
+        funPostProcessing: [],
+        mapOrm,
+    }
+
+    //回傳函數綁定st而不依賴this, 使用端可解構取用並當裸函數傳遞
+    return {
+        addFunCheck: (f) => {
+            //由外部添加擴充檢查函數
+            addFun(st.funChecks, f, 'addFunCheck', true)
+        },
+        addFunPreProcessing: (f) => {
+            //由外部添加擴充前處理函數
+            addFun(st.funPreProcessing, f, 'addFunPreProcessing')
+        },
+        addFunPostProcessing: (f) => {
+            //由外部添加擴充後置處理函數
+            addFun(st.funPostProcessing, f, 'addFunPostProcessing')
+        },
+        procOrm: async (userId, woName, mode, input) => {
+            return procOrm(st, userId, woName, mode, input)
+        },
+    }
+}
+
+
+export default getProc

package/test/unit-WServOrm.test.mjs

@@ -86,37 +86,44 @@ describe('WServOrm實例互不干擾', function() {
         assert.ok(!('timeUpdate' in log[1].data[0]))
     })
 
-    it('I03 各實例之useCheckUser與getUserById互不影響', async function() {
-        //R1: 後建之實例不改變先建者之使用者檢查; 檢查時呼叫該實例自己的getUserById
+    it('I03 已移除之設定給予非預設值即建構拋錯且不建立ORM', async function() {
+        //R3: useCheckUser、getUserById、useExcludeWhenNotAdmin已移除; 給予未給、null、false以外之值即拋錯, 避免使用端以為仍有檢查而無聲失去
+        //拋錯於建立各資料表ORM之前, 否則已開啟之ORM(如lmdb之檔案)無從關閉; 亦不影響既有實例
         let log = []
-        let callsGet = []
         let A = WServOrm(dsAll, mkWOrm('A', log), 'url-a', 'db-a', optOff)
-        let B = WServOrm(dsAll, mkWOrm('B', log), 'url-b', 'db-b', {
-            useCheckUser: true,
-            useExcludeWhenNotAdmin: false,
-            getUserById: async (id) => {
-                callsGet.push(`B:${id}`)
-                return { isAdmin: 'n', isActive: 'y' }
-            },
-        })
-        WServOrm(dsAll, mkWOrm('C', log), 'url-c', 'db-c', optOff)
-        await A.procOrm(null, 'tests', 'select', {})
-        let errB = await getReject(B.procOrm(null, 'tests', 'select', {}))
-        assert.strict.equal(errB, 'invalid userId')
-        await B.procOrm('u9', 'tests', 'select', {})
-        assert.strict.deepEqual(callsGet, ['B:u9'])
-        assert.strict.deepEqual(log.map((v) => v.name), ['A', 'B'])
+        let created = 0
+        let WOrmCount = function() {
+            created++
+            return {}
+        }
+        let bads = [
+            ['useCheckUser', true],
+            ['useCheckUser', 'true'],
+            ['useCheckUser', 1],
+            ['getUserById', async () => ({ isActive: 'y' })],
+            ['getUserById', 'x'],
+            ['useExcludeWhenNotAdmin', true],
+            ['useExcludeWhenNotAdmin', 'n'],
+        ]
+        for (let [k, v] of bads) {
+            assert.throws(() => WServOrm(dsAll, WOrmCount, 'url-x', 'db-x', { [k]: v }), (e) => e instanceof Error && e.message.startsWith(`opt.${k} has been removed, `), `${k}: ${String(v)}`)
+        }
+        assert.strict.equal(created, 0)
+        let r = await A.procOrm('u1', 'tests', 'select', {})
+        assert.strict.deepEqual(r.map((v) => v.id), ['A-r1', 'A-r2'])
     })
 
-    it('I04 各實例之useExcludeWhenNotAdmin互不影響', async function() {
-        //R1: A不過濾, 後建之B濾除isActive為n者(未檢查使用者時isAdmin為n)
-        let log = []
-        let A = WServOrm(dsAll, mkWOrm('A', log), 'url-a', 'db-a', optOff)
-        let B = WServOrm(dsAll, mkWOrm('B', log), 'url-b', 'db-b', { useCheckUser: false, useExcludeWhenNotAdmin: true })
-        let rA = await A.procOrm('u1', 'tests', 'select', {})
-        let rB = await B.procOrm('u1', 'tests', 'select', {})
-        assert.strict.deepEqual(rA.map((v) => v.id), ['A-r1', 'A-r2'])
-        assert.strict.deepEqual(rB.map((v) => v.id), ['B-r2'])
+    it('I04 已移除之設定未給、null或false照常建構, 不檢查使用者亦不過濾', async function() {
+        //R3: 四個使用端現行之設定({useCheckUser:false, getUserById:null, useExcludeWhenNotAdmin:false})升版照常可用
+        //procOrm不做授權: userId不檢查(含空字串、null、undefined), select不依使用者濾除isActive為n者
+        let opts = [undefined, null, {}, { useCheckUser: null }, { useCheckUser: false, getUserById: null, useExcludeWhenNotAdmin: false }]
+        for (let opt of opts) {
+            let X = WServOrm(dsAll, mkWOrm('X', []), 'url-x', 'db-x', opt)
+            for (let userId of ['u1', '', null, undefined]) {
+                let r = await X.procOrm(userId, 'tests', 'select', {})
+                assert.strict.deepEqual(r.map((v) => v.id), ['X-r1', 'X-r2'], `opt ${JSON.stringify(opt)}, userId ${String(userId)}`)
+            }
+        }
     })
 
     it('I05 三種hook各自屬於所註冊之實例', async function() {
@@ -178,39 +185,45 @@ describe('WServOrm實例互不干擾', function() {
         assert.strict.deepEqual(log, ['W1', 'W2'])
     })
 
-    it('I08 選項缺省、null、非布林皆視為true', async function() {
-        //R3: useCheckUser與useExcludeWhenNotAdmin之isbol語義
-        let log = []
-        for (let opt of [{}, { useCheckUser: null }, { useCheckUser: 'n' }]) {
-            let X = WServOrm(dsAll, mkWOrm('X', log), 'url-x', 'db-x', opt)
-            let err = await getReject(X.procOrm(null, 'tests', 'select', {}))
-            assert.strict.equal(err, 'invalid userId')
-        }
-        for (let opt of [{ useCheckUser: false }, { useCheckUser: false, useExcludeWhenNotAdmin: null }, { useCheckUser: false, useExcludeWhenNotAdmin: 'n' }]) {
-            let X = WServOrm(dsAll, mkWOrm('X', log), 'url-x', 'db-x', opt)
-            let r = await X.procOrm('u1', 'tests', 'select', {})
-            assert.strict.deepEqual(r.map((v) => v.id), ['X-r2'])
-        }
+    it('I08 擴充函數之參數不含isAdmin', async function() {
+        //R3: 隨useCheckUser移除, 參數物件只含woName、userId、mode、input, 後處理另含output
+        let A = WServOrm(dsAll, mkWOrm('A', []), 'url-a', 'db-a', optOff)
+        let ks = {}
+        A.addFunCheck((p) => {
+            ks.check = Object.keys(p)
+        })
+        A.addFunPreProcessing((p) => {
+            ks.pre = Object.keys(p)
+            return p
+        })
+        A.addFunPostProcessing((p) => {
+            ks.post = Object.keys(p)
+            return p.output
+        })
+        await wait(20)
+        await A.procOrm('u1', 'tests', 'select', {})
+        assert.strict.deepEqual(ks, {
+            check: ['woName', 'userId', 'mode', 'input'],
+            pre: ['woName', 'userId', 'mode', 'input'],
+            post: ['woName', 'userId', 'mode', 'input', 'output'],
+        })
     })
 
     it('I09 呼叫進行中建立另一實例不影響該次呼叫', async function() {
-        //R1a: A於getUserById等待中建立B, A之呼叫仍打A之ORM並套A之過濾設定
+        //R1a: A之check等待中建立B, A之呼叫仍打A之ORM
         let log = []
         let release = null
         let gate = new Promise((resolve) => {
             release = resolve
         })
-        let A = WServOrm(dsAll, mkWOrm('A', log), 'url-a', 'db-a', {
-            useCheckUser: true,
-            useExcludeWhenNotAdmin: false,
-            getUserById: async () => {
-                await gate
-                return { isAdmin: 'n', isActive: 'y' }
-            },
+        let A = WServOrm(dsAll, mkWOrm('A', log), 'url-a', 'db-a', optOff)
+        A.addFunCheck(async () => {
+            await gate
         })
+        await wait(20)
         let pA = A.procOrm('u1', 'tests', 'select', {})
         await wait(5)
-        WServOrm(dsAll, mkWOrm('B', log), 'url-b', 'db-b', { useCheckUser: false, useExcludeWhenNotAdmin: true })
+        WServOrm(dsAll, mkWOrm('B', log), 'url-b', 'db-b', optOff)
         release()
         let rA = await pA
         assert.strict.deepEqual(log.map((v) => v.name), ['A'])

package/test/unit-mapOrm.test.mjs

@@ -4,7 +4,7 @@ import genTestData from '../src/genTestData.mjs'
 import dsSchema from '../schema/index.mjs'
 
 
-//替身ORM, 回傳形狀依w-orm系列規格(資料庫函數回傳定義計算.md T2、T4):
+//替身ORM, 回傳形狀依w-orm系列規格(w-orm系列套件統一規格.md T2、T4):
 //save與del回傳與輸入等長保序之逐筆陣列, 單筆失敗時整批仍resolve, 該筆以ok為0並附err回報; 整批性錯誤則reject
 let plan = {}
 let calls = []