@d-mok/quasar-app-extension-quasar-axe 2.2.3 → 2.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@d-mok/quasar-app-extension-quasar-axe",
-    "version": "2.2.3",
+    "version": "2.2.4",
     "description": "A Quasar App Extension",
     "main": "src/index.js",
     "scripts": {

package/src/templates/src/utils/index.ts

@@ -6,7 +6,8 @@ export * as qNotify from './notify'
 
 export { HANDLE_ERROR, supabase } from './supabase'
 
-export { TABLE, ENTITY, ORM } from './puppets'
+export { TABLE, ENTITY } from './puppets'
+export { ORM } from './puppets2'
 
 import { supabase } from './supabase'
 

package/src/templates/src/utils/puppets/index.ts

@@ -1,3 +1,2 @@
 export { ENTITY } from './entity'
 export { TABLE } from './table'
-export { ORM } from './ORM'

package/src/templates/src/utils/{puppets → puppets2}/ORM.ts

@@ -18,7 +18,7 @@ export function ORM<
     type R = InstanceType<RBase>
 
     class E extends RClass {
-        private _hostTable: any
+        private _hostTable: InstanceType<ReturnType<typeof getTable>>
 
         constructor(...args: any[]) {
             super()
@@ -69,8 +69,8 @@ export function ORM<
                 return rec
             }
 
-            protected onChange(): any {}
-            protected onEdit(): any {}
+            protected onChange(): void {}
+            protected onEdit(): void {}
             protected onSanitize(row: Partial<R>): Partial<R> {
                 return row
             }

package/src/templates/src/utils/puppets2/builder/index.ts

@@ -0,0 +1,226 @@
+import { Core } from '../core'
+import { Filter, Key } from '../type'
+import { ui } from './ui'
+
+type Promisable<T> = T | PromiseLike<T>
+
+type onfulfilled<T, U> = ((value: T) => Promisable<U>) | undefined | null
+
+type onrejected<U> = ((reason: any) => Promisable<U>) | undefined | null
+
+abstract class BuilderUI {
+    private isSlience: boolean = false
+    private isConfirm: boolean = false
+    private confirmContent: { title: string; msg: string } = {
+        title: '',
+        msg: '',
+    }
+    private isNotify: boolean = false
+    private notifyContent: string = ''
+
+    protected abstract dataLogic(): Promise<void>
+
+    protected async run() {
+        if (this.isSlience) ui.loadingOff()
+
+        if (this.isConfirm) {
+            let { title, msg } = this.confirmContent
+            await ui.onConfirm(title, msg)
+        }
+
+        await this.dataLogic()
+
+        if (this.isNotify) ui.onNotify(this.notifyContent)
+
+        if (this.isSlience) ui.loadingOn()
+    }
+
+    confirm(title: string, ...msgs: string[]): this {
+        this.isConfirm = true
+        this.confirmContent = { title, msg: msgs.join('<br/>') }
+        return this
+    }
+
+    notify(msg: string): this {
+        this.isNotify = true
+        this.notifyContent = msg
+        return this
+    }
+
+    mute(): this {
+        this.isNotify = false
+        return this
+    }
+
+    slience(): this {
+        this.isSlience = true
+        this.isNotify = false
+        return this
+    }
+}
+
+abstract class Builder<T, R> extends BuilderUI implements PromiseLike<void> {
+    constructor(
+        protected core: Core<T, R>,
+        private callback: (objs: T[]) => void
+    ) {
+        super()
+    }
+
+    protected abstract logType: string
+
+    protected abstract fetch(): Promise<R[]>
+
+    protected override async dataLogic(): Promise<void> {
+        let data = await this.fetch()
+        let entities = data.map($ => this.core.convertor($))
+        this.callback(entities)
+        ui.log(this.core.tableName, this.logType, entities)
+    }
+
+    async then<Y, N>(
+        onfulfilled?: onfulfilled<void, Y>,
+        onrejected?: onrejected<N>
+    ): Promise<Y | N> {
+        return this.run().then(onfulfilled, onrejected)
+    }
+}
+
+abstract class FilterBuilder<T, R> extends Builder<T, R> {
+    protected filters: Filter<R>[] = []
+
+    eq<K extends Key<R>>(key: K, val: R[K]): this {
+        this.filters.push({ type: 'eq', payload: { key, val } })
+        return this
+    }
+
+    in<K extends Key<R>>(key: K, vals: R[K][]): this {
+        this.filters.push({ type: 'in', payload: { key, vals } })
+        return this
+    }
+
+    like<K extends Key<R>>(key: K, pattern: string): this {
+        this.filters.push({ type: 'like', payload: { key, pattern } })
+        return this
+    }
+
+    limit(count: number): this {
+        this.filters.push({ type: 'limit', payload: count })
+        return this
+    }
+
+    order<K extends Key<R>>(key: K, ascending: boolean = true): this {
+        this.filters.push({ type: 'order', payload: { key, asc: ascending } })
+        return this
+    }
+}
+
+export class SelectBuilder<T, R> extends FilterBuilder<T, R> {
+    protected logType = 'select'
+
+    protected override async fetch() {
+        return this.core.fetchSelect(this.filters)
+    }
+}
+
+export class SelectInBuilder<T, R, K extends Key<R>> extends FilterBuilder<
+    T,
+    R
+> {
+    protected logType = 'selectIn'
+
+    constructor(
+        private key: K,
+        private vals: R[K][],
+        core: Core<T, R>,
+        callback: (objs: T[]) => void
+    ) {
+        super(core, callback)
+    }
+
+    protected override async fetch() {
+        return this.core.fetchSelectIn(this.key, this.vals, this.filters)
+    }
+}
+
+export class SelectRPCBuilder<T, R> extends FilterBuilder<T, R> {
+    protected logType = 'rpc'
+
+    constructor(
+        private param: object,
+        core: Core<T, R>,
+        callback: (objs: T[]) => void
+    ) {
+        super(core, callback)
+    }
+
+    protected override async fetch() {
+        return this.core.fetchRPC(this.param, this.filters)
+    }
+}
+
+export class InsertBuilder<T, R> extends Builder<T, R> {
+    protected logType = 'insert'
+
+    constructor(
+        private rows: Partial<R>[],
+        core: Core<T, R>,
+        callback: (objs: T[]) => void
+    ) {
+        super(core, callback)
+    }
+
+    protected override async fetch() {
+        return this.core.fetchInsert(this.rows)
+    }
+}
+
+export class UpdateBuilder<T, R> extends Builder<T, R> {
+    protected logType = 'update'
+
+    constructor(
+        private idVal: R[keyof R],
+        private row: Partial<R>,
+        core: Core<T, R>,
+        callback: (objs: T[]) => void
+    ) {
+        super(core, callback)
+    }
+
+    protected override async fetch() {
+        return this.core.fetchUpdate(this.idVal, this.row)
+    }
+}
+
+export class DeleteBuilder<T, R> extends Builder<T, R> {
+    protected logType = 'delete'
+
+    constructor(
+        private idVal: R[keyof R],
+        core: Core<T, R>,
+        callback: (objs: T[]) => void
+    ) {
+        super(core, callback)
+    }
+
+    protected override async fetch() {
+        return this.core.fetchDelete(this.idVal)
+    }
+}
+
+export class UpsertBuilder<T, R> extends Builder<T, R> {
+    protected logType = 'upsert'
+
+    constructor(
+        private row: Partial<R>,
+        private conflictKeys: Key<R>[],
+        core: Core<T, R>,
+        callback: (objs: T[]) => void
+    ) {
+        super(core, callback)
+    }
+
+    protected override async fetch() {
+        return this.core.fetchUpsert(this.row, this.conflictKeys)
+    }
+}

package/src/templates/src/utils/puppets2/builder/ui.ts

@@ -0,0 +1,31 @@
+import { qDialog } from '../..'
+import { qNotify } from '../..'
+import { LoadingBar } from 'quasar'
+
+/**
+ * I am responsible for providing UI interaction functions using Quasar.
+ * Purely functional.
+ */
+class UI {
+    loadingOff(): void {
+        LoadingBar.setDefaults({ size: '0px' })
+    }
+
+    loadingOn(): void {
+        setTimeout(() => LoadingBar.setDefaults({ size: '5px' }), 3000)
+    }
+
+    onConfirm(title: string, msg: string): Promise<void> {
+        return qDialog.confirm(title, msg)
+    }
+
+    onNotify(msg: string): void {
+        qNotify.toast(msg)
+    }
+
+    log(table: string, type: string, data: any[]): void {
+        console.dev(`[${table}] ${type}`, data)
+    }
+}
+
+export const ui = new UI()

package/src/templates/src/utils/puppets2/core/db.ts

@@ -0,0 +1,127 @@
+import {
+    supabase,
+    HANDLE_ERROR,
+    PostgrestFilterBuilder,
+} from '../../supabase'
+import { Filter } from '../type'
+
+type FilterBuilder = PostgrestFilterBuilder<any, any, any, any>
+
+async function send(q: any): Promise<any[]> {
+    let { data, error } = await q
+    HANDLE_ERROR(data, error)
+    return Array.isArray(data) ? data : [data]
+}
+
+function parseFilters(q: FilterBuilder, filters: Filter[]): FilterBuilder {
+    let sortedFilters = filters.sortedBy(f =>
+        ['eq', 'in', 'like', 'limit', 'order'].indexOf(f.type)
+    )
+    for (const { type: t, payload: p } of sortedFilters) {
+        if (t === 'eq') q = q.eq(p.key, p.val)
+        if (t === 'in') q = q.in(p.key, p.vals)
+        if (t === 'like') q = q.like(p.key, p.pattern)
+        if (t === 'limit') q = q.limit(p)
+        if (t === 'order') q = q.order(p.key, { ascending: p.asc })
+    }
+    return q
+}
+
+/**
+ * I am responsible for providing database operation.
+ * Purely functional.
+ */
+class DB {
+    async select(
+        table: string,
+        fields: string[],
+        filters: Filter[]
+    ): Promise<any[]> {
+        let q = supabase.from(table).select(fields.join(','))
+        q = parseFilters(q, filters)
+        return send(q)
+    }
+
+    async selectIn(
+        table: string,
+        fields: string[],
+        key: string,
+        vals: any[],
+        filters: Filter[]
+    ): Promise<any[]> {
+        let getRows = (chunkPiece: any[]): Promise<any[]> => {
+            let q = supabase
+                .from(table)
+                .select(fields.join(','))
+                .in(key, chunkPiece)
+            q = parseFilters(q, filters)
+            return send(q)
+        }
+        let promises = vals.chunk(100).map(getRows)
+        let result = await Promise.all(promises)
+        return result.flat()
+    }
+
+    async rpc(fn: string, param: any, filters: Filter[]): Promise<any[]> {
+        let q = supabase.rpc(fn, param)
+        q = parseFilters(q, filters)
+        return send(q)
+    }
+
+    async insert(table: string, rows: any[]): Promise<any[]> {
+        let q = supabase.from(table).insert(rows).select('*')
+        return send(q)
+    }
+
+    async update(
+        table: string,
+        idKey: string,
+        idVal: any,
+        row: any
+    ): Promise<any[]> {
+        let q = supabase
+            .from(table)
+            .update(row)
+            .eq(idKey, idVal)
+            .select('*')
+            .single()
+        return send(q)
+    }
+
+    async delete(table: string, idKey: string, idVal: any): Promise<any[]> {
+        let q = supabase
+            .from(table)
+            .delete()
+            .eq(idKey, idVal)
+            .select('*')
+            .single()
+        return send(q)
+    }
+
+    async upsert(
+        table: string,
+        idKey: string,
+        row: any,
+        conflictKeys: (string & keyof typeof row)[]
+    ): Promise<any[]> {
+        let conflict: any = {}
+        for (let f of conflictKeys) {
+            conflict[f] = row[f]
+        }
+
+        let q = supabase.from(table).select('*').match(conflict)
+        let data = await send(q)
+
+        if (data.length > 1)
+            throw 'Fail to upsert! More than 1 rows matching the conflictKeys are found!'
+
+        if (data.length === 1) {
+            let id = data[0][idKey as keyof (typeof data)[0]]
+            return await this.update(table, idKey, id, row)
+        } else {
+            return await this.insert(table, [row])
+        }
+    }
+}
+
+export const db = new DB()

package/src/templates/src/utils/puppets2/core/index.ts

@@ -0,0 +1,44 @@
+import { Filter, Key } from '../type'
+import { db } from './db'
+
+/** I am responsible for transfering the state from Table to Builders.*/
+export class Core<T, R> {
+    constructor(
+        public tableName: string,
+        public idKey: Key<R>,
+        public fields: Key<R>[],
+        public convertor: ($: R) => T
+    ) {}
+
+    async fetchSelect(filters: Filter<R>[]): Promise<R[]> {
+        return db.select(this.tableName, this.fields, filters)
+    }
+
+    async fetchSelectIn<K extends Key<R>>(
+        key: K,
+        vals: R[K][],
+        filters: Filter<R>[]
+    ): Promise<R[]> {
+        return db.selectIn(this.tableName, this.fields, key, vals, filters)
+    }
+
+    async fetchRPC(param: object, filters: Filter<R>[]): Promise<R[]> {
+        return db.rpc(this.tableName, param, filters)
+    }
+
+    async fetchInsert(rows: Partial<R>[]): Promise<R[]> {
+        return db.insert(this.tableName, rows)
+    }
+
+    async fetchUpdate(idVal: R[keyof R], row: Partial<R>): Promise<R[]> {
+        return db.update(this.tableName, this.idKey, idVal, row)
+    }
+
+    async fetchDelete(idVal: R[keyof R]): Promise<R[]> {
+        return db.delete(this.tableName, this.idKey, idVal)
+    }
+
+    async fetchUpsert(row: Partial<R>, conflictKeys: Key<R>[]): Promise<R[]> {
+        return db.upsert(this.tableName, this.idKey, row, conflictKeys)
+    }
+}

package/src/templates/src/utils/puppets2/index.ts

@@ -0,0 +1 @@
+export { ORM } from './ORM'

package/src/templates/src/utils/puppets2/type.ts

@@ -0,0 +1,15 @@
+export type Filter<R = any> =
+    | { type: 'eq'; payload: { key: Key<R>; val: any } }
+    | { type: 'in'; payload: { key: Key<R>; vals: any[] } }
+    | { type: 'like'; payload: { key: Key<R>; pattern: string } }
+    | { type: 'limit'; payload: number }
+    | { type: 'order'; payload: { key: Key<R>; asc: boolean } }
+
+export type Constructor<T extends object = {}> = new (...args: any[]) => T
+
+export type BooleanKeys<T> = {
+    [k in keyof T]: T[k] extends boolean ? k : never
+}[keyof T]
+// type OnlyBoolean<T> = { [k in BooleanKeys<T>]: boolean }
+
+export type Key<R> = string & keyof R