@d-mok/quasar-app-extension-quasar-axe 0.0.94 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@d-mok/quasar-app-extension-quasar-axe",
-  "version": "0.0.94",
+  "version": "1.0.2",
   "description": "A Quasar App Extension",
   "author": "d-mok <49301824+d-mok@users.noreply.github.com>",
   "license": "MIT",
@@ -20,18 +20,18 @@
     "yarn": ">= 1.6.0"
   },
   "dependencies": {
-    "@supabase/supabase-js": "^1.29.1",
-    "@types/papaparse": "^5.2.6",
-    "@types/webpack-env": "^1.16.2",
+    "@supabase/supabase-js": "^1.29.4",
+    "@types/papaparse": "^5.3.2",
+    "@types/webpack-env": "^1.16.3",
     "papaparse": "^5.3.1",
-    "sapphire-js": "^1.0.61"
+    "sapphire-js": "^1.0.63"
   },
   "devDependencies": {
-    "@quasar/app": "^3.2.5",
-    "@quasar/extras": "^1.12.2",
-    "@types/node": "^17.0.4",
-    "core-js": "^3.20.0",
-    "quasar": "^2.3.4",
-    "typescript": "^4.5.4"
+    "@quasar/app": "^3.3.1",
+    "@quasar/extras": "^1.12.4",
+    "@types/node": "^17.0.13",
+    "core-js": "^3.20.3",
+    "quasar": "^2.4.13",
+    "typescript": "^4.5.5"
   }
 }

package/src/boot/AutoRoute.ts

@@ -11,7 +11,7 @@ console.log("[QuasarAxe] Run Boot AutoRoute")
 
 
 export default boot(({ app, router }) => {
-    const pages = require.context('src/pages', true, /[\w-]+\.vue$/)
+    const pages = require.context('src/pages', false, /[\w-]+\.vue$/)
     router.addRoute({
         path: '/',
         //@ts-ignore

package/src/components/QxLayout.vue

@@ -12,7 +12,9 @@
 
                 <q-toolbar-title class="text-weight-bolder text-h5">{{ title }}</q-toolbar-title>
 
-                <div class="text-h6">/{{ appendix }}</div>
+                <slot name="appendix">
+                    <div class="text-h6">/{{ appendix }}</div>
+                </slot>
             </q-toolbar>
         </q-header>
 

package/src/templates/src/utils.ts

@@ -4,11 +4,13 @@ export { qDialog } from '@d-mok/quasar-app-extension-quasar-axe/src/utils/dialog
 //@ts-ignore
 export { qNotify } from '@d-mok/quasar-app-extension-quasar-axe/src/utils/notify'
 //@ts-ignore
-export { Table, Empower } from '@d-mok/quasar-app-extension-quasar-axe/src/utils/table'
+export { Table, Empower } from '@d-mok/quasar-app-extension-quasar-axe/src/utils/ORM/table'
+//@ts-ignore
+export { TableView } from '@d-mok/quasar-app-extension-quasar-axe/src/utils/ORM/view'
 //@ts-ignore
 import '@d-mok/quasar-app-extension-quasar-axe/src/utils/supabase'
 //@ts-ignore
-export { supabase, handleError } from '@d-mok/quasar-app-extension-quasar-axe/src/utils/supabase'
+export { supabase, handleError, callRPC } from '@d-mok/quasar-app-extension-quasar-axe/src/utils/supabase'
 //@ts-ignore
 export { Sheet, List } from '@d-mok/quasar-app-extension-quasar-axe/src/utils/sapphire'
 

package/src/utils/ORM/basic.ts

@@ -0,0 +1,228 @@
+import { supabase, handleError, PostgrestFilterBuilder } from '../supabase'
+import { qDialog } from '../dialog'
+import { qNotify } from '../notify'
+import { LoadingBar } from 'quasar'
+import { Ordering, Criteria, strKeyOf, Sheet } from 'sapphire-js'
+
+
+export type Where<T> =
+    { [K in keyof T]?
+        : T[K]
+        | T[K][]
+        | { like: string }
+    }
+    | ((_: PostgrestFilterBuilder) => any)
+
+// export type OrderBy<T> =
+//     strKeyOf<T>
+//     | { [K in keyof T]?: true | false }
+
+
+
+type Action = 'select' | 'insert' | 'update' | 'delete' | 'patch'
+
+
+
+function loadingBar(on: boolean): void {
+    on ? setTimeout(() => LoadingBar.setDefaults({ size: "5px" }), 3000)
+        : LoadingBar.setDefaults({ size: "0px" })
+}
+
+
+
+
+
+
+
+/**
+ * A subclass of array designed as an ORM.
+ * @template T - type of element class
+ * @template R - type of database row class
+ */
+export abstract class BasicTable<T extends R, R extends object> extends Sheet<T>{
+
+    /**
+     * The name of the database table.
+     */
+    public abstract readonly tableName: string
+    /**
+     * The name of the ID field.
+     */
+    public abstract readonly idField: strKeyOf<R>
+    /**
+     * The class of the elements.
+     */
+    public abstract readonly entityClass: new (_: Partial<R>) => T
+    /**
+     * The default ordering instruction object.
+     */
+    public readonly ordering: Readonly<Ordering<T>> = []
+    // /**
+    //  * The default fields to select
+    //  */
+    // public readonly selectFields: strKeyOf<R>[] = []
+
+
+
+    private convert(data: R[]): T[] {
+        return data.map($ => new this.entityClass($))
+    }
+
+    private log(msg: string, data: T[]): void {
+        if (process.env.DEBUGGING)
+            console.log(`[${this.tableName}] ${msg}`, data)
+    }
+
+
+
+    // private defaultOrder(): void {
+    //     if (this.ordering !== undefined)
+    //         this.order(...this.ordering)
+    // }
+
+
+    // private selectedFields() {
+    //     return this.selectFields === undefined ? "*" : this.selectFields.join(",")
+    // }
+
+
+    protected idWhere(id: R[this['idField']]): any {
+        return { [this.idField]: id }
+    }
+
+
+    protected idsWhere(ids: R[this['idField']][]): any {
+        return { [this.idField]: ids }
+    }
+
+
+    protected orderById(ids: R[this['idField']][]): void {
+        let ord = { [this.idField]: ids } as any
+        this.order(ord)
+    }
+
+
+    private APIAction(type: Action, content: Partial<R>[] = []) {
+        let q = supabase.from<R>(this.tableName)
+        switch (type) {
+            case 'select':
+                return q.select('*')
+            case 'patch':
+                return q.select('*')
+            case 'delete':
+                return q.delete()
+            case 'insert':
+                return q.insert(content)
+            case 'update':
+                return q.update(content[0])
+        }
+    }
+
+    protected async API({
+        type,
+        content,
+        where,
+        // orderBy,
+        // limit,
+        action = (_: any) => { },
+        confirm,
+        notify,
+        slience
+    }: {
+        type: Action
+        content?: Partial<R>[]
+        where?: Where<R>
+        // orderBy?: OrderBy<R>
+        // limit?: number,
+        action: (entities: T[]) => void
+        confirm?: [string, string?]
+        notify?: string
+        slience?: boolean
+    }) {
+        if (slience) loadingBar(false)
+        if (confirm) await qDialog.confirm(...confirm)
+
+        let q = this.APIAction(type, content)
+        q = applyWhere(q, where)
+        // q = applyOrderBy(q, orderBy)
+        // q = applyLimit(q, limit)
+
+        let { data, error } = await q
+        handleError(data, error)
+
+        let entities = this.convert(data)
+        action(entities)
+        this.order(...this.ordering)
+
+        this.log(type, entities)
+        if (notify) qNotify.toast(notify)
+        if (slience) loadingBar(true)
+    }
+
+
+
+
+
+    /**
+     * Get an item by `criteria`. If not found, return a new object.
+     */
+    got(criteria: Criteria<T>): T {
+        return this.get(criteria) ?? new this.entityClass({})
+    }
+}
+
+
+
+
+
+
+function applyWhere(q: PostgrestFilterBuilder, where?: Where<any>): PostgrestFilterBuilder {
+    if (where === undefined)
+        return q
+
+    if (typeof where === 'function')
+        return where(q)
+
+    for (let key in where) {
+        let val = where[key]
+        if (Array.isArray(val)) {
+            // treat as in
+            q = q.in(key, val)
+        } else if (typeof val === 'object') {
+            if ('like' in val) {
+                // treat as like
+                let { like } = val as { like: string }
+                q = q.like(key, like)
+            }
+        } else {
+            // treat as eq
+            q = q.eq(key, val)
+        }
+    }
+    return q
+}
+
+// function applyOrderBy(q: PostgrestFilterBuilder, orderBy?: OrderBy<any>): PostgrestFilterBuilder {
+//     if (orderBy === undefined)
+//         return q
+
+//     if (typeof orderBy === "string") {
+//         q = q.order(orderBy)
+//     } else {
+//         let field = Object.keys(orderBy)[0]
+//         let ascending = orderBy[field]
+//         q = q.order(field, { ascending })
+//     }
+//     return q
+// }
+
+
+
+// function applyLimit(q: PostgrestFilterBuilder, limit?: number): PostgrestFilterBuilder {
+//     if (limit === undefined)
+//         return q
+
+//     return q.limit(limit)
+// }
+
+

package/src/utils/ORM/table.ts

@@ -0,0 +1,155 @@
+import { supabase, handleError } from '../supabase'
+import { Criteria, strKeyOf } from 'sapphire-js'
+import { TableView } from './view'
+
+
+type muteOptions = {
+    confirm?:  [string, string?]
+    notify?: string
+    slience?: boolean
+}
+
+
+
+/**
+ * A subclass of array designed as an ORM.
+ * @template T - type of element class
+ * @template R - type of database row class
+ */
+export abstract class Table<T extends R, R extends object> extends TableView<T, R>{
+
+
+
+
+    async insert(
+        rows: Partial<R> | Partial<R>[],
+        { confirm, notify, slience }: muteOptions = {}
+    ) {
+        await this.API({
+            type: 'insert',
+            content: Array.isArray(rows) ? rows : [rows],
+            action: entities => this.push(...entities),
+            confirm,
+            notify,
+            slience
+        })
+    }
+
+
+    async update(
+        id: R[this['idField']],
+        row: Partial<R>,
+        { confirm, notify, slience }: muteOptions = {}
+    ) {
+        await this.API({
+            type: 'update',
+            content: [row],
+            where: this.idWhere(id),
+            action: entities => this.merge(entities, this.idField),
+            confirm,
+            notify,
+            slience
+        })
+    }
+
+
+    async upsert(
+        row: Partial<R>,
+        conflictFields: strKeyOf<R>[],
+        { confirm, notify, slience }: muteOptions = {}
+    ) {
+        let conflict: any = {}
+        for (let f of conflictFields) {
+            conflict[f] = row[f]
+        }
+
+        let { data, error } = await supabase.from<R>(this.tableName).select("*").match(conflict)
+        handleError(data, error)
+
+        if (data.length > 1)
+            throw 'Fail to upsert! More than 1 rows matching the conflictFields are found!'
+
+        if (data.length === 1) {
+            let id = data[0][this.idField]
+            await this.update(id, row, { confirm, notify, slience })
+        }
+
+        if (data.length === 0) {
+            await this.insert(row, { confirm, notify, slience })
+        }
+    }
+
+
+
+    async delete(
+        id: R[this['idField']],
+        { confirm, notify, slience }: muteOptions = {}
+    ) {
+        await this.API({
+            type: 'delete',
+            where: this.idWhere(id),
+            action: entities => this.discard(this.idWhere(id) as Criteria<T>),
+            confirm,
+            notify,
+            slience
+        })
+    }
+
+
+}
+
+
+
+
+
+
+type Constructor = new (...args: any[]) => {}
+
+export function Empower<RCls extends Constructor, R = InstanceType<RCls>>(BaseCls: RCls) {
+
+    return class extends BaseCls {
+
+        public hostTable: Table<any, any> | undefined = undefined;
+
+        public async update(
+            this: this & R,
+            row: Partial<R>,
+            { confirm, notify, slience }: muteOptions = {}
+        ): Promise<void> {
+
+            if (this.hostTable === undefined) {
+                console.error('You must define hostTable before using .update()!')
+                console.error(this)
+                return
+            }
+
+            let idField = this.hostTable.idField as keyof R
+            let id = this[idField]
+            await this.hostTable.update(id, row, { confirm, notify, slience })
+
+        }
+
+        public async delete(
+            this: this & R,
+            { confirm, notify, slience }: muteOptions = {}
+        ): Promise<void> {
+
+            if (this.hostTable === undefined) {
+                console.error('You must define hostTable before using .delete()!')
+                console.error(this)
+                return
+            }
+
+            let idField = this.hostTable.idField as keyof R
+            let id = this[idField]
+            await this.hostTable.delete(id, { confirm, notify, slience })
+
+        }
+
+
+    }
+}
+
+
+
+

package/src/utils/ORM/view.ts

@@ -0,0 +1,94 @@
+import { BasicTable, Where } from './basic'
+
+
+type selectOptions<R> = {
+    where?: Where<R>
+    // orderBy?: OrderBy<R>
+    // limit?: number
+    confirm?: [string, string?]
+    notify?: string
+    slience?: boolean
+}
+
+
+
+
+
+function chunk<T>(arr: T[], size: number): T[][] {
+    if (size <= 0) return []
+    let newArr = []
+    for (let i = 0; i < arr.length; i += size) {
+        newArr.push(arr.slice(i, i + size))
+    }
+    return newArr
+}
+
+/**
+ * A subclass of array designed as an ORM.
+ * @template T - type of element class
+ * @template R - type of database row class
+ */
+export abstract class TableView<T extends R, R extends object> extends BasicTable<T, R>{
+
+    async select({ where, confirm, notify, slience }: selectOptions<R> = {}) {
+        await this.API({
+            type: 'select',
+            where,
+            // orderBy,
+            // limit,
+            action: entities => this.set(entities),
+            // order: true,
+            confirm,
+            notify,
+            slience
+        })
+    }
+
+    async patch({ where, confirm, notify, slience }: selectOptions<R> = {}) {
+        await this.API({
+            type: 'patch',
+            where,
+            // orderBy,
+            // limit,
+            action: entities => this.absorb(entities, this.idField),
+            confirm,
+            notify,
+            slience
+        })
+    }
+
+
+    async patchIDs(
+        ids: R[this['idField']][],
+        { where, confirm, notify, slience }: selectOptions<R> = {},
+        chunkSize = 100,
+    ) {
+        for (let ck of chunk(ids, chunkSize)) {
+            await this.patch({
+                where: { ...this.idsWhere(ck), ...where },
+                confirm,
+                notify,
+                slience
+            })
+        }
+        if (this.ordering.length === 0)
+            this.orderById(ids)
+    }
+
+
+    async selectIDs(
+        ids: R[this['idField']][],
+        { where, confirm, notify, slience }: selectOptions<R> = {},
+        chunkSize = 100,
+    ) {
+        this.clear()
+        this.patchIDs(
+            ids,
+            { where, confirm, notify, slience },
+            chunkSize
+        )
+    }
+
+
+}
+

package/src/utils/supabase.ts

@@ -1,4 +1,4 @@
-import { createClient, PostgrestError } from '@supabase/supabase-js';
+import { createClient, PostgrestError } from '@supabase/supabase-js'
 import { qDialog } from './dialog'
 
 declare module '@supabase/supabase-js' {
@@ -19,7 +19,7 @@ if (!process.env.SUPABASE_URL)
 if (!process.env.SUPABASE_KEY)
     throw 'Missing SUPABASE_KEY in process.env!'
 
-export const supabase = createClient(process.env.SUPABASE_URL, process.env.SUPABASE_KEY);
+export const supabase = createClient(process.env.SUPABASE_URL, process.env.SUPABASE_KEY)
 
 
 supabase.signIn = async () => {
@@ -28,12 +28,12 @@ supabase.signIn = async () => {
         provider: 'google'
     }, {
         redirectTo: window.location.href
-    });
-};
+    })
+}
 
 supabase.signOut = async () => {
     await supabase.auth.signOut()
-};
+}
 
 
 supabase.accessTokenLife = () => {
@@ -57,7 +57,7 @@ supabase.checkSession = async () => {
         const { error } = await supabase.auth.refreshSession()
         if (error) {
             print('Refresh failed. Force Signin...')
-            supabase.signIn();
+            supabase.signIn()
         } else {
             print('Refresh succeed!')
         }
@@ -69,7 +69,7 @@ supabase.checkSession = async () => {
             const { error } = await supabase.auth.refreshSession()
             if (error) {
                 print('Refresh failed. Force Signin...')
-                supabase.signIn();
+                supabase.signIn()
             } else {
                 print('Refresh succeed!')
             }
@@ -80,8 +80,8 @@ supabase.checkSession = async () => {
 setInterval(() => supabase.checkSession(), 1000)
 
 supabase.auth.onAuthStateChange((event, session) => {
-    console.log('[SUPABASE AUTH UPDATE]', event, session?.user?.email);
-});
+    console.log('[SUPABASE AUTH UPDATE]', event, session?.user?.email)
+})
 
 supabase.email = (): string => {
     return supabase.auth.user()?.email ?? 'unauthenticated'
@@ -91,14 +91,14 @@ supabase.email = (): string => {
 
 
 
-supabase.signedIn = false;
+supabase.signedIn = false
 
 supabase.auth.onAuthStateChange((event, session) => {
     if (event === 'SIGNED_IN') supabase.signedIn = true
-});
+})
 
 
-async function waitFor(predicate: () => boolean, waitingMsg?: string, doneMsg?: string,) {
+async function waitFor(predicate: () => boolean, waitingMsg?: string, doneMsg?: string): Promise<unknown> {
     return new Promise(resolve => {
         function checker() {
             if (predicate()) {
@@ -106,7 +106,7 @@ async function waitFor(predicate: () => boolean, waitingMsg?: string, doneMsg?:
                 resolve(true)
             } else {
                 if (waitingMsg) console.log(waitingMsg)
-                setTimeout(() => checker(), 50);
+                setTimeout(() => checker(), 50)
             }
         }
         checker()
@@ -134,3 +134,18 @@ export function handleError<T>(data: T[] | null, error: PostgrestError | null):
         throw 'supabase return data is null!'
     }
 }
+
+
+
+const _filterBuilder = supabase.from('DEMO').select()
+export type PostgrestFilterBuilder = typeof _filterBuilder
+
+
+
+export async function callRPC<T>(fn: string, params?: object | undefined) {
+    let { data, error } = await supabase.rpc<T>(fn, params)
+    handleError(data, error)
+    return data
+}
+
+

package/src/utils/table.ts

@@ -1,395 +0,0 @@
-import { Notify } from 'quasar'
-import { supabase, handleError } from './supabase'
-import { qDialog } from './dialog'
-import { LoadingBar } from 'quasar'
-import { Ordering, Criteria, strKeyOf, Sheet } from 'sapphire-js'
-
-
-type Where<T> = { [K in keyof T]?: T[K] | T[K][] | { like: string } } | ((_: FilterBuilder) => any)
-
-type OrderBy<T> = strKeyOf<T> | { [K in keyof T]?: true | false }
-
-type FilterBuilder = { eq: any, in: any, like: any, or: any, order: any }
-
-type muteOptions = {
-    confirm?: string | [string, string]
-    notify?: string
-    slience?: boolean
-}
-
-type selectOptions<R> = {
-    where?: Where<R>
-    orderBy?: OrderBy<R>
-    limit?: number
-    confirm?: string | [string, string]
-    notify?: string
-    slience?: boolean
-}
-
-
-enum ActionType {
-    select = 'select',
-    insert = 'insert',
-    update = 'update',
-    delete = 'delete',
-    patch = 'patch',
-}
-
-
-
-function getKeys<T>(obj: T): (string & keyof T)[] {
-    return Object.keys(obj) as (string & keyof T)[]
-}
-
-
-
-/**
- * A subclass of array designed as an ORM.
- * @template T - type of element class
- * @template R - type of database row class
- */
-export abstract class Table<T extends R, R extends object> extends Sheet<T>{
-
-    /**
-     * The name of the database table.
-     */
-    public abstract readonly tableName: string
-    /**
-     * The name of the ID field.
-     */
-    public abstract readonly idField: strKeyOf<R>
-    /**
-     * The class of the elements.
-     */
-    public abstract readonly entityClass: new (_: Partial<R>) => T
-    /**
-     * The default ordering instruction object.
-     */
-    public readonly ordering?: Readonly<Ordering<T>> = undefined
-    /**
-     * The default fields to select
-     */
-    public readonly selectFields?: strKeyOf<R>[] = undefined
-
-
-
-    private convert(data: R[]): T[] {
-        return data.map($ => new this.entityClass($))
-    }
-
-    private log(msg: string, data: T[]): void {
-        if (process.env.DEBUGGING)
-            console.log(`[${this.tableName}] ${msg}`, data)
-    }
-
-    private async confirm(confirm: string | [string, string]): Promise<void> {
-        if (typeof confirm === 'string') {
-            await qDialog.confirm(confirm)
-        } else {
-            let [title, message] = confirm
-            await qDialog.confirm(title, message)
-        }
-    }
-
-    private notify(msg: string): void {
-        Notify.create({
-            message: msg,
-            progress: true,
-            type: 'positive'
-        })
-    }
-
-    private loadingBarOff(): void {
-        LoadingBar.setDefaults({ size: "0px" })
-    }
-
-    private loadingBarOn(): void {
-        setTimeout(() => {
-            LoadingBar.setDefaults({ size: "5px" })
-        }, 3000);
-    }
-
-    private defaultOrder(): void {
-        if (this.ordering !== undefined)
-            this.order(...this.ordering)
-    }
-
-    private idWhere(id: R[this['idField']]): Partial<R> {
-        return { [this.idField]: id } as Partial<R>
-    }
-
-    private APIAction(type: ActionType, content?: Partial<R> | Partial<R>[]) {
-        let q = supabase.from<R>(this.tableName)
-        if (type === ActionType.select) {
-            let fields = this.selectFields === undefined ? "*" : this.selectFields.join(",")
-            return q.select(fields)
-        }
-        if (type === ActionType.patch) {
-            let fields = this.selectFields === undefined ? "*" : this.selectFields.join(",")
-            return q.select(fields)
-        }
-        if (type === ActionType.delete)
-            return q.delete()
-        if (content === undefined)
-            throw 'API Action require content!'
-        if (type === ActionType.insert)
-            return q.insert(content)
-        if (Array.isArray(content))
-            throw 'API Action require single object content!'
-        if (type === ActionType.update)
-            return q.update(content)
-        throw 'never'
-    }
-
-    private async API({
-        type,
-        content,
-        where,
-        orderBy,
-        limit,
-        action,
-        order,
-        confirm,
-        notify,
-        slience
-    }: {
-        type: ActionType
-        content?: Partial<R> | Partial<R>[]
-        where?: Where<R>
-        orderBy?: OrderBy<R>
-        limit?: number,
-        action?: (entities: T[]) => void
-        order?: boolean
-        confirm?: string | [string, string]
-        notify?: string
-        slience?: boolean
-    }) {
-        if (slience) this.loadingBarOff()
-        if (confirm) await this.confirm(confirm)
-
-        let q = this.APIAction(type, content)
-        if (where !== undefined)
-            q = this.applyWhere(q, where)
-        if (orderBy !== undefined)
-            q = this.applyOrderBy(q, orderBy)
-        if (limit !== undefined)
-            q = q.limit(limit)
-        let { data, error } = await q
-        handleError(data, error)
-
-        let entities = this.convert(data)
-        if (action !== undefined) action(entities)
-        if (order === true) this.defaultOrder()
-
-        this.log(type, entities)
-        if (notify) this.notify(notify)
-        if (slience) this.loadingBarOn()
-    }
-
-    // api
-
-    async select({ where, orderBy, limit, confirm, notify, slience }: selectOptions<R> = {}) {
-        await this.API({
-            type: ActionType.select,
-            where,
-            orderBy,
-            limit,
-            action: entities => this.set(entities),
-            order: true,
-            confirm,
-            notify,
-            slience
-        })
-    }
-
-
-    async patch({ where, orderBy, limit, confirm, notify, slience }: selectOptions<R> = {}) {
-        await this.API({
-            type: ActionType.patch,
-            where,
-            orderBy,
-            limit,
-            action: entities => this.absorb(entities, this.idField),
-            order: true,
-            confirm,
-            notify,
-            slience
-        })
-    }
-
-
-    async insert(
-        rows: Partial<R> | Partial<R>[],
-        { confirm, notify, slience }: muteOptions = {}
-    ) {
-        await this.API({
-            type: ActionType.insert,
-            content: Array.isArray(rows) ? rows : [rows],
-            action: entities => this.push(...entities),
-            order: true,
-            confirm,
-            notify,
-            slience
-        })
-    }
-
-
-    async update(
-        id: R[this['idField']],
-        row: Partial<R>,
-        { confirm, notify, slience }: muteOptions = {}
-    ) {
-        await this.API({
-            type: ActionType.update,
-            content: row,
-            where: this.idWhere(id),
-            action: entities => this.merge(entities, this.idField),
-            confirm,
-            notify,
-            slience
-        })
-    }
-
-
-    async upsert(
-        row: Partial<R>,
-        conflictFields: strKeyOf<R>[],
-        { confirm, notify, slience }: muteOptions = {}
-    ) {
-        let conflict: any = {}
-        for (let f of conflictFields) {
-            conflict[f] = row[f]
-        }
-
-        let { data, error } = await supabase.from<R>(this.tableName).select("*").match(conflict)
-        handleError(data, error)
-
-        if (data.length > 1)
-            throw 'Fail to upsert! More than 1 rows matching the conflictFields are found!'
-
-        if (data.length === 1) {
-            let id = data[0][this.idField]
-            await this.update(id, row, { confirm, notify, slience })
-        }
-
-        if (data.length === 0) {
-            await this.insert(row, { confirm, notify, slience })
-        }
-    }
-
-
-
-    async delete(
-        id: R[this['idField']],
-        { confirm, notify, slience }: muteOptions = {}
-    ) {
-        await this.API({
-            type: ActionType.delete,
-            where: this.idWhere(id),
-            action: entities => this.discard(this.idWhere(id) as Criteria<T>),
-            confirm,
-            notify,
-            slience
-        })
-    }
-
-
-    private applyWhere<T extends FilterBuilder>(q: T, where: Where<R>): T {
-        if (typeof where === 'function') {
-            q = where(q)
-        } else {
-            for (let key in where) {
-                let val = where[key]
-                if (Array.isArray(val)) {
-                    // treat as in
-                    q = q.in(key, val)
-                } else if (typeof val === 'object') {
-                    if ('like' in val) {
-                        // treat as like
-                        let { like } = val as { like: string }
-                        q = q.like(key, like)
-                    }
-                } else {
-                    // treat as eq
-                    q = q.eq(key, val)
-                }
-            }
-        }
-
-        return q
-    }
-
-    private applyOrderBy<T extends FilterBuilder>(q: T, orderBy: OrderBy<R>): T {
-        if (typeof orderBy === "string") {
-            q = q.order(orderBy)
-        } else {
-            let field = getKeys(orderBy)[0]
-            let ascending = orderBy[field]
-            q = q.order(field, { ascending })
-        }
-        return q
-    }
-
-    /**
-     * Get an item by `criteria`. If not found, return a new object.
-     */
-    got(criteria: Criteria<T>): T {
-        return this.get(criteria) ?? new this.entityClass({})
-    }
-}
-
-
-
-
-
-
-type Constructor = new (...args: any[]) => {};
-
-export function Empower<RCls extends Constructor, R = InstanceType<RCls>>(BaseCls: RCls) {
-
-    return class extends BaseCls {
-
-        public hostTable: Table<any, any> | undefined = undefined;
-
-        public async update(
-            this: this & R,
-            row: Partial<R>,
-            { confirm, notify, slience }: muteOptions = {}
-        ): Promise<void> {
-
-            if (this.hostTable === undefined) {
-                console.error('You must define hostTable before using .updateThis()!')
-                console.error(this)
-                return
-            }
-
-            let idField = this.hostTable.idField as keyof R
-            let id = this[idField]
-            await this.hostTable.update(id, row, { confirm, notify, slience })
-
-        }
-
-        public async delete(
-            this: this & R,
-            { confirm, notify, slience }: muteOptions = {}
-        ): Promise<void> {
-
-            if (this.hostTable === undefined) {
-                console.error('You must define hostTable before using .deleteThis()!')
-                console.error(this)
-                return
-            }
-
-            let idField = this.hostTable.idField as keyof R
-            let id = this[idField]
-            await this.hostTable.delete(id, { confirm, notify, slience })
-
-        }
-
-
-    };
-}
-
-
-
-