@d-mok/quasar-app-extension-quasar-axe 2.1.123 → 2.2.1

package/package.json

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

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

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

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

@@ -0,0 +1,207 @@
+import {
+    DeleteBuilder,
+    InsertBuilder,
+    SelectBuilder,
+    SelectInBuilder,
+    SelectRPCBuilder,
+    UpdateBuilder,
+    UpsertBuilder,
+} from './builder'
+import { Constructor, Key, BooleanKeys } from './type'
+import { Core } from './core'
+import { reactive } from 'vue'
+
+export function ORM<
+    RBase extends Constructor,
+    K extends Key<InstanceType<RBase>>
+>(RClass: RBase, tableName: string, idKey: K) {
+    type R = InstanceType<RBase>
+
+    class E extends RClass {
+        private _hostTable: TableClass
+
+        constructor(...args: any[]) {
+            super()
+            let [row, hostTable] = args
+            Object.assign(this, row)
+            this._hostTable = hostTable
+        }
+
+        update(this: E & R, row: Partial<R>) {
+            return this._hostTable.update(this[idKey], row)
+        }
+
+        delete(this: E & R) {
+            return this._hostTable.delete(this[idKey])
+        }
+
+        toggle(this: E & R, key: BooleanKeys<R>) {
+            let val = !this[key]
+            let obj = { [key]: val } as Partial<R>
+            return this._hostTable.update(this[idKey], obj)
+        }
+    }
+
+    type T = E & R
+
+    function convertor(host: TableClass) {
+        return ($: R) => new E($, host) as T
+    }
+
+    function core(host: TableClass) {
+        return new Core<T, R>(
+            tableName,
+            idKey,
+            Object.keys(new RClass()) as Key<R>[],
+            convertor(host)
+        )
+    }
+
+    class TableClass 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[K], 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[K]) {
+            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!')
+        }
+    }
+
+    console.dev(
+        `Create Table [${tableName}] idKey [${idKey}] entity [${E.name}]`
+    )
+
+    return { Entity: E, Table: TableClass }
+}
+
+if (process.env.DEBUGGING) {
+    // @ts-ignore
+    globalThis.TABLES = []
+}

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

@@ -1,26 +1,26 @@
 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)
         }
 
-        static _RowClass = RowClass
-
-        static _tableName = tableName
-
-        static _idKey: K = idKey
-
-        static _fields: any[] = Object.keys(new RowClass())
-
         update(row: Partial<R>): UpdateBuilder<any, R> {
             // @ts-ignore
             return this._hostTable.update(this[idKey], row)

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

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

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

@@ -9,7 +9,6 @@ import {
 } from './builder'
 import { Constructor, Key } from './type'
 import { Core } from './core'
-import { ENTITY } from './entity'
 import { reactive } from 'vue'
 
 type imprinted<R extends object> = {
@@ -32,6 +31,9 @@ if (process.env.DEBUGGING) {
     globalThis.TABLES = []
 }
 
+/**
+ * @deprecated
+ */
 export function TABLE<
     ClassT extends EntityClass<T, R>,
     R extends RowOf<ClassT> = RowOf<ClassT>,

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

@@ -0,0 +1,72 @@
+import { ORM } from './ORM'
+
+// example
+
+class StudentRow {
+    pyccode: string = ''
+    name: string = ''
+    class: string = ''
+    num: number = 0
+    pass: boolean = false
+    isPrefect: boolean = false
+}
+
+const { Entity, Table } = ORM(StudentRow, 'student', 'pyccode')
+
+class Student extends Entity {
+    full = this.class + this.name
+    good = true
+}
+
+let s = new Student()
+s.pyccode
+s.num
+s.pass
+s.full
+// @ts-expect-error
+s.xyz
+s.update({ name: 'a' })
+// @ts-expect-error
+s.update({ name: 1 })
+s.update({ pass: true })
+// @ts-expect-error
+s.update({ pass: 0 })
+// @ts-expect-error
+s.update({ full: 'a' })
+s.delete()
+s.toggle('pass')
+s.toggle('isPrefect')
+// @ts-expect-error
+s.toggle('name')
+// @ts-expect-error
+s.toggle('good')
+
+class StudentTable extends Table {
+    protected override onChange() {
+        return 1
+    }
+}
+
+let ss = new StudentTable()
+
+ss.select().eq('name', 'a')
+// @ts-expect-error
+ss.select().eq('full', 'a')
+ss.selectIn('num', [1, 2, 3])
+// @ts-expect-error
+ss.selectIn('name', [1, 2, 3])
+// @ts-expect-error
+ss.selectIn('full', [1, 2, 3])
+ss.insert({ name: 'a' })
+// @ts-expect-error
+ss.insert({ name: 0 })
+ss.delete('')
+// @ts-expect-error
+ss.delete(1)
+ss.update('', { name: 'a' })
+// @ts-expect-error
+ss.update('', { name: 0 })
+// @ts-expect-error
+ss.update('', { full: 'a' })
+// @ts-expect-error
+ss.update(0, { name: 'a' })