@d-mok/quasar-app-extension-quasar-axe 2.1.2 → 2.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@d-mok/quasar-app-extension-quasar-axe",
-    "version": "2.1.2",
+    "version": "2.1.5",
     "description": "A Quasar App Extension",
     "author": "d-mok <49301824+d-mok@users.noreply.github.com>",
     "license": "MIT",
@@ -15,7 +15,7 @@
     },
     "dependencies": {
         "@handsontable/vue3": "^12.1.0",
-        "@supabase/supabase-js": "^2.24.0",
+        "@supabase/supabase-js": "^1.35.4",
         "@types/lodash": "^4.14.182",
         "@types/papaparse": "^5.3.2",
         "@types/webpack-env": "^1.17.0",
@@ -24,7 +24,7 @@
         "jszip": "^3.9.0",
         "lodash": "^4.17.21",
         "papaparse": "^5.3.2",
-        "sapphire-js": "^2.0.3",
+        "sapphire-js": "^2.0.4",
         "vuedraggable": "^4.1.0"
     },
     "devDependencies": {

package/src/templates/src/utils/supabase.ts

@@ -2,8 +2,6 @@ import {
     createClient,
     PostgrestError,
     SupabaseClient,
-    Session,
-    SupabaseClientOptions,
 } from '@supabase/supabase-js'
 import { qDialog } from './dialog'
 
@@ -12,69 +10,78 @@ export type {
     PostgrestSingleResponse,
 } from '@supabase/postgrest-js'
 
-class MySupabaseClient extends SupabaseClient {
-    email: string = 'unauthenticated'
-    session: Session | null = null
-
-    constructor(
-        supabaseUrl: string,
-        supabaseKey: string,
-        options?: SupabaseClientOptions<any>
-    ) {
-        super(supabaseUrl, supabaseKey, options)
-        this.auth.onAuthStateChange((event, session) => {
-            console.log('[SUPABASE AUTH]', event, session?.user?.email)
-            this.session = session
-            this.email = session?.user?.email ?? 'unauthenticated'
-        })
+declare module '@supabase/supabase-js' {
+    interface SupabaseClient {
+        signIn: () => void
+        accessTokenLife: () => number
+        waitForSignin: () => Promise<void>
+        email: () => string
+        call: <T>(fn: string, params?: object | undefined) => Promise<T[]>
+        callSingle: <T>(fn: string, params?: object | undefined) => Promise<T>
     }
+}
 
-    async signIn() {
-        await this.auth.signOut()
-        await this.auth.signInWithOAuth({
-            provider: 'google',
-            options: {
-                redirectTo: window.location.href,
-            },
-        })
-    }
+export let supabase: SupabaseClient
+let SUPABASE_URL = process.env.SUPABASE_URL
+let SUPABASE_KEY = process.env.SUPABASE_KEY
 
-    async call<T>(fn: string, params?: object | undefined): Promise<T[]> {
-        let { data, error } = await this.rpc<string, any>(fn, params)
-        HANDLE_ERROR(data, error)
-        return data
+if (SUPABASE_URL && SUPABASE_KEY) {
+    supabase = createClient(SUPABASE_URL, SUPABASE_KEY, {
+        autoRefreshToken: true,
+    })
+
+    supabase.signIn = async () => {
+        await supabase.auth.signOut()
+        await supabase.auth.signIn(
+            { provider: 'google' },
+            { redirectTo: window.location.href }
+        )
     }
 
-    async callSingle<T>(fn: string, params?: object | undefined): Promise<T> {
-        let { data, error } = await this.rpc<string, any>(fn, params).single()
-        HANDLE_ERROR(data, error)
-        return data as T
+    supabase.accessTokenLife = () => {
+        const session = supabase.auth.session()
+        if (session?.expires_at === undefined) return -999999
+        const expireAt = new Date(session.expires_at * 1000)
+        const ms = expireAt.getTime() - new Date().getTime() // ms
+        return Math.round(ms / 1000)
     }
 
-    async waitForSignin(): Promise<void> {
+    supabase.auth.onAuthStateChange((event, session) => {
+        console.log('[SUPABASE AUTH]', event, session?.user?.email)
+    })
+
+    supabase.waitForSignin = async function (): Promise<void> {
         setInterval(() => {
-            if (this.session === null) this.signIn()
+            if (supabase.auth.session() === null) supabase.signIn()
         }, 1000)
-        waitFor(
-            () => this.session !== null,
+        await waitFor(
+            () => supabase.auth.session() !== null,
             '[Wait for SignIn] waiting...',
             '[Wait for SignIn] DONE!'
         )
     }
-}
 
-export let supabase: MySupabaseClient
-let SUPABASE_URL = process.env.SUPABASE_URL
-let SUPABASE_KEY = process.env.SUPABASE_KEY
+    supabase.call = async function <T>(
+        fn: string,
+        params?: object | undefined
+    ): Promise<T[]> {
+        let { data, error } = await supabase.rpc<T>(fn, params)
+        HANDLE_ERROR(data, error)
+        return data
+    }
 
-if (SUPABASE_URL && SUPABASE_KEY) {
-    supabase = new MySupabaseClient(SUPABASE_URL, SUPABASE_KEY, {
-        auth: {
-            autoRefreshToken: true,
-            persistSession: true,
-            detectSessionInUrl: true,
-        },
-    })
+    supabase.callSingle = async function <T>(
+        fn: string,
+        params?: object | undefined
+    ): Promise<T> {
+        let { data, error } = await supabase.rpc<T>(fn, params).single()
+        HANDLE_ERROR(data, error)
+        return data
+    }
+
+    supabase.email = function (): string {
+        return supabase.auth.user()?.email ?? 'unauthenticated'
+    }
 }
 
 export function HANDLE_ERROR<T>(
@@ -109,13 +116,13 @@ async function waitFor(
     doneMsg: string
 ) {
     return new Promise(resolve => {
-        async function checker() {
+        function checker() {
             if (predicate()) {
                 console.log(doneMsg)
                 resolve(true)
             } else {
                 console.log(waitingMsg)
-                setTimeout(checker, 50)
+                setTimeout(() => checker(), 50)
             }
         }
         checker()

package/src/templates/src/utils/supabase2.ts

@@ -0,0 +1,123 @@
+// import {
+//     createClient,
+//     PostgrestError,
+//     SupabaseClient,
+//     Session,
+//     SupabaseClientOptions,
+// } from '@supabase/supabase-js'
+// import { qDialog } from './dialog'
+
+// export type {
+//     PostgrestFilterBuilder,
+//     PostgrestSingleResponse,
+// } from '@supabase/postgrest-js'
+
+// class MySupabaseClient extends SupabaseClient {
+//     email: string = 'unauthenticated'
+//     session: Session | null = null
+
+//     constructor(
+//         supabaseUrl: string,
+//         supabaseKey: string,
+//         options?: SupabaseClientOptions<any>
+//     ) {
+//         super(supabaseUrl, supabaseKey, options)
+//         this.auth.onAuthStateChange((event, session) => {
+//             console.log('[SUPABASE AUTH]', event, session?.user?.email)
+//             this.session = session
+//             this.email = session?.user?.email ?? 'unauthenticated'
+//         })
+//     }
+
+//     async signIn() {
+//         await this.auth.signOut()
+//         await this.auth.signInWithOAuth({
+//             provider: 'google',
+//             options: {
+//                 redirectTo: window.location.href,
+//             },
+//         })
+//     }
+
+//     async call<T>(fn: string, params?: object | undefined): Promise<T[]> {
+//         let { data, error } = await this.rpc<string, any>(fn, params)
+//         HANDLE_ERROR(data, error)
+//         return data
+//     }
+
+//     async callSingle<T>(fn: string, params?: object | undefined): Promise<T> {
+//         let { data, error } = await this.rpc<string, any>(fn, params).single()
+//         HANDLE_ERROR(data, error)
+//         return data as T
+//     }
+
+//     async waitForSignin(): Promise<void> {
+//         setInterval(() => {
+//             if (this.session === null) this.signIn()
+//         }, 1000)
+//         waitFor(
+//             () => this.session !== null,
+//             '[Wait for SignIn] waiting...',
+//             '[Wait for SignIn] DONE!'
+//         )
+//     }
+// }
+
+// export let supabase: MySupabaseClient
+// let SUPABASE_URL = process.env.SUPABASE_URL
+// let SUPABASE_KEY = process.env.SUPABASE_KEY
+
+// if (SUPABASE_URL && SUPABASE_KEY) {
+//     supabase = new MySupabaseClient(SUPABASE_URL, SUPABASE_KEY, {
+//         auth: {
+//             autoRefreshToken: true,
+//             persistSession: true,
+//             detectSessionInUrl: true,
+//         },
+//     })
+// }
+
+// export function HANDLE_ERROR<T>(
+//     data: T[] | T | null,
+//     error: PostgrestError | null
+// ): asserts data {
+//     if (error) {
+//         if (error.message === 'JWSError JWSInvalidSignature') {
+//             localStorage.removeItem('supabase.auth.token')
+//             qDialog.error(
+//                 'Database Error!',
+//                 'Your login session has expired. Please try refreshing the website.'
+//             )
+//             throw error
+//         }
+//         let msg = ''
+//         msg += error.details ?? '' + '<br/>'
+//         msg += error.message ?? '' + '<br/>'
+//         msg += error.hint ?? ''
+//         qDialog.error('Database Error!', msg)
+//         throw error
+//     }
+//     if (data === null) {
+//         qDialog.error('Supabase Error!', 'Returned data is null')
+//         throw 'supabase return data is null!'
+//     }
+// }
+
+// async function waitFor(
+//     predicate: () => boolean,
+//     waitingMsg: string,
+//     doneMsg: string
+// ) {
+//     return new Promise(resolve => {
+//         async function checker() {
+//             if (predicate()) {
+//                 console.log(doneMsg)
+//                 resolve(true)
+//             } else {
+//                 console.log(waitingMsg)
+//                 setTimeout(checker, 50)
+//             }
+//         }
+//         checker()
+//     })
+// }