@d-mok/quasar-app-extension-quasar-axe 2.2.13 → 2.3.1

package/package.json

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

package/src/install.js

@@ -1,6 +1,6 @@
 module.exports = function (api) {
     api.compatibleWith('quasar', '^2.0.0')
-    api.compatibleWith('@quasar/app-vite', '^1.0.0')
+    api.compatibleWith('@quasar/app-vite', '^1.0.0 || ^2.0.0')
     api.render('./templates')
     api.onExitLog('Thanks for installing quasar-axe!')
 }

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

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

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

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

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

@@ -1,39 +0,0 @@
-import { DeleteBuilder, UpdateBuilder } from './builder'
-import { Constructor, BooleanKeys } from './type'
-
-/**
- * @deprecated
- */
-export function ENTITY<
-    TBase extends Constructor,
-    K extends string & keyof R,
-    R extends InstanceType<TBase> = InstanceType<TBase>
->(RowClass: TBase, tableName: string, idKey: K) {
-    return class extends RowClass {
-        static _RowClass = RowClass
-        static _tableName = tableName
-        static _idKey: K = idKey
-        static _fields: any[] = Object.keys(new RowClass())
-
-        constructor(...args: any[]) {
-            super(...args)
-            let template = args[0] ?? {}
-            Object.assign(this, template)
-        }
-
-        update(row: Partial<R>): UpdateBuilder<any, R> {
-            // @ts-ignore
-            return this._hostTable.update(this[idKey], row)
-        }
-
-        delete(): DeleteBuilder<any, R> {
-            // @ts-ignore
-            return this._hostTable.delete(this[idKey])
-        }
-
-        toggle(key: BooleanKeys<R>): UpdateBuilder<any, R> {
-            // @ts-ignore
-            return this._hostTable.update(this[idKey], { [key]: !this[key] })
-        }
-    }
-}

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

@@ -1,226 +0,0 @@
-import {
-    DeleteBuilder,
-    InsertBuilder,
-    SelectBuilder,
-    SelectInBuilder,
-    SelectRPCBuilder,
-    UpdateBuilder,
-    UpsertBuilder,
-} from './builder'
-import { Constructor, Key } from './type'
-import { Core } from './core'
-import { reactive } from 'vue'
-
-type imprinted<R extends object> = {
-    _RowClass: Constructor
-    _tableName: string
-    _idKey: string & keyof R
-    _fields: any[]
-}
-type EntityClass<T extends R, R extends object> = Constructor<T> & imprinted<R>
-type RowOf<E extends EntityClass<any, any>> = InstanceType<E['_RowClass']>
-
-function logCreate(tableName: string, idKey: string, entityName: string) {
-    console.dev(
-        `Create Table [${tableName}] idKey [${idKey}] entity [${entityName}]`
-    )
-}
-
-if (process.env.DEBUGGING) {
-    // @ts-ignore
-    globalThis.TABLES = []
-}
-
-/**
- * @deprecated
- */
-export function TABLE<
-    ClassT extends EntityClass<T, R>,
-    R extends RowOf<ClassT> = RowOf<ClassT>,
-    T extends R = InstanceType<ClassT>
->(EntityClass: ClassT) {
-    const tableName: string = EntityClass._tableName
-    const idKey: ClassT['_idKey'] = EntityClass._idKey
-    const fields: any[] = EntityClass._fields
-
-    logCreate(tableName, idKey, EntityClass.name)
-
-    function convertor(host: any) {
-        return ($: R) => {
-            let T = new EntityClass($)
-            // @ts-ignore
-            T._hostTable = host
-            return T
-        }
-    }
-
-    function core(host: any) {
-        return new Core<T, R>(tableName, idKey, fields, convertor(host))
-    }
-
-    return class extends Array<T> {
-        /** make reactive */
-        reactive(): this {
-            const rec = reactive(this) as this
-            if (process.env.DEBUGGING) {
-                // @ts-ignore
-                globalThis.TABLES.push(rec)
-            }
-            return rec
-        }
-
-        protected onChange(): any {}
-        protected onEdit(): any {}
-        protected onSanitize(row: Partial<R>): Partial<R> {
-            return row
-        }
-
-        select() {
-            let callback = ($: T[]) => {
-                this.set($)
-                this.onChange()
-            }
-            return new SelectBuilder(core(this), callback)
-        }
-
-        patch() {
-            let callback = ($: T[]) => {
-                this.absorb($, idKey)
-                this.onChange()
-            }
-            return new SelectBuilder(core(this), callback)
-        }
-
-        selectIn<K extends Key<R>>(key: K, vals: R[K][]) {
-            let callback = ($: T[]) => {
-                this.set($)
-                this.sortBy($ => vals.indexOf($[key]))
-                this.onChange()
-            }
-            return new SelectInBuilder(key, vals, core(this), callback)
-        }
-
-        patchIn<K extends Key<R>>(key: K, vals: R[K][]) {
-            let callback = ($: T[]) => {
-                this.absorb($, idKey)
-                this.sortBy($ => vals.indexOf($[key]))
-                this.onChange()
-            }
-            return new SelectInBuilder(key, vals, core(this), callback)
-        }
-
-        selectRPC(param: object = {}) {
-            let callback = ($: T[]) => {
-                this.set($)
-                this.onChange()
-            }
-            return new SelectRPCBuilder(param, core(this), callback)
-        }
-
-        patchRPC(param: object = {}) {
-            let callback = ($: T[]) => {
-                this.absorb($, idKey)
-                this.onChange()
-            }
-            return new SelectRPCBuilder(param, core(this), callback)
-        }
-
-        selectCustom(rows: R[]) {
-            let convert = core(this).convertor
-            let entities = rows.map(convert)
-            this.set(entities)
-            this.onChange()
-        }
-
-        insert(row: Partial<R>) {
-            row = this.onSanitize(row)
-            let callback = ($: T[]) => {
-                this.push(...$)
-                this.onChange()
-                this.onEdit()
-            }
-            return new InsertBuilder([row], core(this), callback).notify(
-                'Created!'
-            )
-        }
-
-        insertMany(rows: Partial<R>[]) {
-            rows = rows.map(this.onSanitize)
-            let callback = ($: T[]) => {
-                this.push(...$)
-                this.onChange()
-                this.onEdit()
-            }
-            return new InsertBuilder(rows, core(this), callback).notify(
-                'Created!'
-            )
-        }
-
-        update(idVal: R[ClassT['_idKey']], row: Partial<R>) {
-            row = this.onSanitize(row)
-            let callback = ($: T[]) => {
-                this.merge($, idKey)
-                this.onChange()
-                this.onEdit()
-            }
-            return new UpdateBuilder(idVal, row, core(this), callback).notify(
-                'Updated!'
-            )
-        }
-
-        delete(idVal: R[ClassT['_idKey']]) {
-            let callback = ($: T[]) => {
-                this.remove($ => $[idKey] === idVal)
-                this.onChange()
-                this.onEdit()
-            }
-            return new DeleteBuilder(idVal, core(this), callback).notify(
-                'Deleted!'
-            )
-        }
-
-        upsert(row: Partial<R>, conflictKeys: Key<R>[]) {
-            row = this.onSanitize(row)
-            let callback = ($: T[]) => {
-                this.absorb($, idKey)
-                this.onChange()
-                this.onEdit()
-            }
-            return new UpsertBuilder(
-                row,
-                conflictKeys,
-                core(this),
-                callback
-            ).notify('Updated!')
-        }
-    }
-}
-
-// // example
-
-// class StudentRow {
-//     public name: string = ''
-//     public class: string = ''
-//     public num: number = 0
-//     public pass: boolean = false
-//     public pasds: boolean = false
-// }
-
-// class Student extends ENTITY(StudentRow, 'student', 'num') {
-//     public full = this.class + this.name
-// }
-
-// let s = new Student()
-// // s.ful
-// s.toggle('pass')
-
-// class StudentsCollection extends TABLE(Student) {
-//     protected override onChange() {
-//         return 1
-//     }
-// }
-
-// let ss = new StudentsCollection()
-// ss.select().eq('name', 'a')
-// ss.insert({ name: 'a' })
-// ss.delete(1)

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

@@ -1,226 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,127 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

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

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

@@ -1,15 +0,0 @@
-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