@basictech/react 0.6.0 → 0.7.0-beta.1

package/src/AuthContext.tsx

@@ -1,5 +1,3 @@
-// @ts-nocheck
-
 import React, { createContext, useContext, useEffect, useState, useRef } from 'react'
 import { jwtDecode } from 'jwt-decode'
 
@@ -9,6 +7,25 @@ import { validateSchema, compareSchemas } from '@basictech/schema'
 
 import { log } from './config'
 import {version as currentVersion} from '../package.json'
+export interface BasicStorage {
+    get(key: string): Promise<string | null>
+    set(key: string, value: string): Promise<void>
+    remove(key: string): Promise<void>
+}
+
+export class LocalStorageAdapter implements BasicStorage {
+    async get(key: string): Promise<string | null> {
+        return localStorage.getItem(key)
+    }
+    
+    async set(key: string, value: string): Promise<void> {
+        localStorage.setItem(key, value)
+    }
+    
+    async remove(key: string): Promise<void> {
+        localStorage.removeItem(key)
+    }
+}
 
 type BasicSyncType = {
     basic_schema: any;
@@ -20,7 +37,7 @@ type BasicSyncType = {
             count: () => Promise<number>;
         };
     };
-    [key: string]: any; // For other potential methods and properties
+    [key: string]: any;
 };
 
 
@@ -46,7 +63,7 @@ type Token = {
     access_token: string,
     token_type: string,
     expires_in: number,
-    refresh: string,
+    refresh_token: string,
 }
 
 export const BasicContext = createContext<{
@@ -54,10 +71,11 @@ export const BasicContext = createContext<{
     isAuthReady: boolean,
     isSignedIn: boolean,
     user: User | null,
-    signout: () => void,
-    signin: () => void,
+    signout: () => Promise<void>,
+    signin: () => Promise<void>,
+    signinWithCode: (code: string, state?: string) => Promise<{ success: boolean, error?: string }>,
     getToken: () => Promise<string>,
-    getSignInLink: () => string,
+    getSignInLink: (redirectUri?: string) => Promise<string>,
     db: any,
     dbStatus: DBStatus
 }>({
@@ -65,21 +83,25 @@ export const BasicContext = createContext<{
     isAuthReady: false,
     isSignedIn: false,
     user: null,
-    signout: () => { },
-    signin: () => { },
+    signout: () => Promise.resolve(),
+    signin: () => Promise.resolve(),
+    signinWithCode: () => new Promise(() => { }),
     getToken: () => new Promise(() => { }),
-    getSignInLink: () => "",
+    getSignInLink: () => Promise.resolve(""),
     db: {},
     dbStatus: DBStatus.LOADING
 });
 
 const EmptyDB: BasicSyncType = {
+    basic_schema: {},
+    connect: () => {},
+    debugeroo: () => {},
     isOpen: false,
     collection: () => {
         return {
             ref: {
-                toArray: () => [],
-                count: () => 0
+                toArray: () => Promise.resolve([]),
+                count: () => Promise.resolve(0)
             }
         }
     }
@@ -223,7 +245,19 @@ async function checkForNewVersion(): Promise<{ hasNewVersion: boolean, latestVer
     }
 }
 
-export function BasicProvider({ children, project_id, schema, debug = false }: { children: React.ReactNode, project_id?: string, schema?: any, debug?: boolean }) {
+export function BasicProvider({ 
+    children, 
+    project_id, 
+    schema, 
+    debug = false, 
+    storage 
+}: { 
+    children: React.ReactNode, 
+    project_id?: string, 
+    schema?: any, 
+    debug?: boolean,
+    storage?: BasicStorage 
+}) {
     const [isAuthReady, setIsAuthReady] = useState(false)
     const [isSignedIn, setIsSignedIn] = useState<boolean>(false)
     const [token, setToken] = useState<Token | null>(null)
@@ -233,8 +267,71 @@ export function BasicProvider({ children, project_id, schema, debug = false }: {
 
     const [dbStatus, setDbStatus] = useState<DBStatus>(DBStatus.OFFLINE)
     const [error, setError] = useState<ErrorObject | null>(null)
+    const [isOnline, setIsOnline] = useState<boolean>(navigator.onLine)
+    const [pendingRefresh, setPendingRefresh] = useState<boolean>(false)
 
     const syncRef = useRef<BasicSync | null>(null);
+    const storageAdapter = storage || new LocalStorageAdapter();
+    const STORAGE_KEYS = {
+        REFRESH_TOKEN: 'basic_refresh_token',
+        USER_INFO: 'basic_user_info',
+        AUTH_STATE: 'basic_auth_state',
+        DEBUG: 'basic_debug'
+    }
+
+    const isDevelopment = () => {
+        return (
+            window.location.hostname === 'localhost' ||
+            window.location.hostname === '127.0.0.1' ||
+            window.location.hostname.includes('localhost') ||
+            window.location.hostname.includes('127.0.0.1') ||
+            window.location.hostname.includes('.local') ||
+            process.env.NODE_ENV === 'development' ||
+            debug === true
+        )
+    }
+
+    const cleanOAuthParamsFromUrl = () => {
+        if (window.location.search.includes('code') || window.location.search.includes('state')) {
+            const url = new URL(window.location.href)
+            url.searchParams.delete('code')
+            url.searchParams.delete('state')
+            window.history.pushState({}, document.title, url.pathname + url.search)
+            log('Cleaned OAuth parameters from URL')
+        }
+    }
+
+    useEffect(() => {
+        const handleOnline = () => {
+            log('Network came back online')
+            setIsOnline(true)
+            if (pendingRefresh) {
+                log('Retrying pending token refresh')
+                setPendingRefresh(false)
+                if (token) {
+                    const refreshToken = token.refresh_token || localStorage.getItem('basic_refresh_token')
+                    if (refreshToken) {
+                        fetchToken(refreshToken).catch(error => {
+                            log('Retry refresh failed:', error)
+                        })
+                    }
+                }
+            }
+        }
+        
+        const handleOffline = () => {
+            log('Network went offline')
+            setIsOnline(false)
+        }
+
+        window.addEventListener('online', handleOnline)
+        window.addEventListener('offline', handleOffline)
+
+        return () => {
+            window.removeEventListener('online', handleOnline)
+            window.removeEventListener('offline', handleOffline)
+        }
+    }, [pendingRefresh, token])
 
     useEffect(() => {
         function initDb(options: { shouldConnect: boolean }) {
@@ -243,12 +340,12 @@ export function BasicProvider({ children, project_id, schema, debug = false }: {
                 syncRef.current = new BasicSync('basicdb', { schema: schema });
                 
                 syncRef.current.syncable.on('statusChanged', (status: number, url: string) => {
-                    setDbStatus(getSyncStatus(status))
+                    setDbStatus(getSyncStatus(status) as DBStatus)
                 })
         
-                syncRef.current.syncable.getStatus().then((status) => {
-                    setDbStatus(getSyncStatus(status))
-                })
+                // syncRef.current.syncable.getStatus().then((status: number) => {
+                //     setDbStatus(getSyncStatus(status) as DBStatus)
+                // })
 
                 if (options.shouldConnect) {    
                     setShouldConnect(true)
@@ -257,12 +354,6 @@ export function BasicProvider({ children, project_id, schema, debug = false }: {
                 }
 
                 setIsReady(true)
-
-                // log('db is open', syncRef.current.isOpen())
-                // syncRef.current.open()
-                // .then(() => {
-                //     log("is open now:", syncRef.current.isOpen())
-                // })
             }
         }
 
@@ -276,7 +367,7 @@ export function BasicProvider({ children, project_id, schema, debug = false }: {
                     log(`${index + 1}:`, error.message, ` - at ${error.instancePath}`)
                     errorMessage += `${index + 1}: ${error.message} - at ${error.instancePath}\n`
                 })
-                console.groupEnd('Schema Errors')
+                console.groupEnd()
                 setError({
                     code: 'schema_invalid',
                     title: 'Basic Schema is invalid!',
@@ -319,39 +410,87 @@ export function BasicProvider({ children, project_id, schema, debug = false }: {
         }
     }, [isSignedIn, shouldConnect])
 
+    const connectToDb = async () => {
+        const tok = await getToken()
+        if (!tok) {
+            log('no token found')
+            return
+        }
+
+        log('connecting to db...')
+
+        syncRef.current?.connect({ access_token: tok })
+            .catch((e) => {
+                log('error connecting to db', e)
+            })
+    }
+
     useEffect(() => {
-        localStorage.setItem('basic_debug', debug ? 'true' : 'false')
+        const initializeAuth = async () => {
+            await storageAdapter.set(STORAGE_KEYS.DEBUG, debug ? 'true' : 'false')
 
-        try {
+            try {
             if (window.location.search.includes('code')) {
-                let code = window.location?.search?.split('code=')[1].split('&')[0]
+                let code = window.location?.search?.split('code=')[1]?.split('&')[0]
+                if (!code) return
 
-                const state = localStorage.getItem('basic_auth_state')
-                if (!state || state !== window.location.search.split('state=')[1].split('&')[0]) {
+                const state = await storageAdapter.get(STORAGE_KEYS.AUTH_STATE)
+                const urlState = window.location.search.split('state=')[1]?.split('&')[0]
+                if (!state || state !== urlState) {
                     log('error: auth state does not match')
                     setIsAuthReady(true)
 
-                    localStorage.removeItem('basic_auth_state')
-                    window.history.pushState({}, document.title, "/");
+                    await storageAdapter.remove(STORAGE_KEYS.AUTH_STATE)
+                    // Clean OAuth parameters from URL
+                    cleanOAuthParamsFromUrl()
                     return
                 }
 
-                localStorage.removeItem('basic_auth_state')
+                await storageAdapter.remove(STORAGE_KEYS.AUTH_STATE)
+                // Clean OAuth parameters from URL
+                cleanOAuthParamsFromUrl()
 
-                fetchToken(code)                
+                fetchToken(code).catch((error) => {
+                    log('Error fetching token:', error)
+                })                
             } else { 
-                let cookie_token = getCookie('basic_token')
-                if (cookie_token !== '') {
-                    setToken(JSON.parse(cookie_token))
-                } else { 
-                    setIsAuthReady(true)
+                const refreshToken = await storageAdapter.get(STORAGE_KEYS.REFRESH_TOKEN)
+                if (refreshToken) {
+                    log('Found refresh token in storage, attempting to refresh access token')
+                    fetchToken(refreshToken).catch((error) => {
+                        log('Error fetching refresh token:', error)
+                    })
+                } else {
+                    let cookie_token = getCookie('basic_token')
+                    if (cookie_token !== '') {
+                        const tokenData = JSON.parse(cookie_token)
+                        setToken(tokenData)
+                        if (tokenData.refresh_token) {
+                            await storageAdapter.set(STORAGE_KEYS.REFRESH_TOKEN, tokenData.refresh_token)
+                        }
+                    } else { 
+                        const cachedUserInfo = await storageAdapter.get(STORAGE_KEYS.USER_INFO)
+                        if (cachedUserInfo) {
+                            try {
+                                const userData = JSON.parse(cachedUserInfo)
+                                setUser(userData)
+                                setIsSignedIn(true)
+                                log('Loaded cached user info for offline mode')
+                            } catch (error) {
+                                log('Error parsing cached user info:', error)
+                            }
+                        }
+                        setIsAuthReady(true)
+                    }
                 }
             }
 
-
-        } catch (e) {
-            log('error getting cookie', e)
+            } catch (e) {
+                log('error getting token', e)
+            }
         }
+        
+        initializeAuth()
     }, [])
 
     useEffect(() => {
@@ -368,16 +507,18 @@ export function BasicProvider({ children, project_id, schema, debug = false }: {
 
             if (user.error) {
                 log('error fetching user', user.error)
-                // refreshToken()
                 return
             } else {
-                // log('user', user)
-                document.cookie = `basic_token=${JSON.stringify(token)}; Secure; SameSite=Strict`;
-                
-                if (window.location.search.includes('code')) {
-                    window.history.pushState({}, document.title, "/");
+                if (token?.refresh_token) {
+                    await storageAdapter.set(STORAGE_KEYS.REFRESH_TOKEN, token.refresh_token)
                 }
                 
+                await storageAdapter.set(STORAGE_KEYS.USER_INFO, JSON.stringify(user))
+                log('Cached user info in storage')
+                
+                document.cookie = `basic_access_token=${token?.access_token}; Secure; SameSite=Strict; HttpOnly=false`;
+                document.cookie = `basic_token=${JSON.stringify(token)}; Secure; SameSite=Strict`;
+                
                 setUser(user)
                 setIsSignedIn(true)
 
@@ -398,10 +539,21 @@ export function BasicProvider({ children, project_id, schema, debug = false }: {
 
             if (isExpired) {
                 log('token is expired - refreshing ...')
-                const newToken = await fetchToken(token?.refresh)
-                fetchUser(newToken.access_token)
+                try {
+                    const newToken = await fetchToken(token?.refresh_token || '')
+                    fetchUser(newToken?.access_token || '')
+                } catch (error) {
+                    log('Failed to refresh token in checkToken:', error)
+                    
+                    if ((error as Error).message.includes('offline') || (error as Error).message.includes('Network')) {
+                        log('Network issue - continuing with expired token until online')
+                        fetchUser(token?.access_token || '')
+                    } else {
+                        setIsAuthReady(true)
+                    }
+                }
             } else {
-                fetchUser(token.access_token)
+                fetchUser(token?.access_token || '')
             }
         }
 
@@ -410,65 +562,125 @@ export function BasicProvider({ children, project_id, schema, debug = false }: {
         } 
     }, [token])
 
-    const connectToDb = async () => {
-        const tok = await getToken()
-        if (!tok) {
-            log('no token found')
-            return
-        }
+    const getSignInLink = async (redirectUri?: string) => {
+        try {
+            log('getting sign in link...')
 
-        log('connecting to db...')
+            if (!project_id) {
+                throw new Error('Project ID is required to generate sign-in link')
+            }
 
-        // TODO: handle if signed out after connect() is already called
+            const randomState = Math.random().toString(36).substring(6);
+            await storageAdapter.set(STORAGE_KEYS.AUTH_STATE, randomState)
 
-        syncRef.current.connect({ access_token: tok })
-            .catch((e) => {
-                log('error connecting to db', e)
-            })
-    }
+            const redirectUrl = redirectUri || window.location.href
+
+            if (!redirectUrl || (!redirectUrl.startsWith('http://') && !redirectUrl.startsWith('https://'))) {
+                throw new Error('Invalid redirect URI provided')
+            }
 
-    const getSignInLink = () => {
-        log('getting sign in link...')
+            let baseUrl = "https://api.basic.tech/auth/authorize"
+            baseUrl += `?client_id=${project_id}`
+            baseUrl += `&redirect_uri=${encodeURIComponent(redirectUrl)}`
+            baseUrl += `&response_type=code`
+            baseUrl += `&scope=profile`
+            baseUrl += `&state=${randomState}`
 
-        const randomState = Math.random().toString(36).substring(6);
-        localStorage.setItem('basic_auth_state', randomState)
+            log('Generated sign-in link successfully')
+            return baseUrl;
 
-        let baseUrl = "https://api.basic.tech/auth/authorize"
-        baseUrl += `?client_id=${project_id}`
-        baseUrl += `&redirect_uri=${encodeURIComponent(window.location.href)}`
-        baseUrl += `&response_type=code`
-        baseUrl += `&scope=profile`
-        baseUrl += `&state=${randomState}`
+        } catch (error) {
+            log('Error generating sign-in link:', error)
+            throw error
+        }
+    }
 
-        return baseUrl;
+    const signin = async () => {
+        try {
+            log('signing in...')
+            
+            if (!project_id) {
+                log('Error: project_id is required for sign-in')
+                throw new Error('Project ID is required for authentication')
+            }
+            
+            const signInLink = await getSignInLink()
+            log('Generated sign-in link:', signInLink)
+            
+            if (!signInLink || !signInLink.startsWith('https://')) {
+                log('Error: Invalid sign-in link generated')
+                throw new Error('Failed to generate valid sign-in URL')
+            }
+            
+            window.location.href = signInLink
+            
+        } catch (error) {
+            log('Error during sign-in:', error)
+            
+            if (isDevelopment()) {
+                setError({
+                    code: 'signin_error',
+                    title: 'Sign-in Failed',
+                    message: (error as Error).message || 'An error occurred during sign-in. Please try again.'
+                })
+            }
+            
+            throw error
+        }
     }
 
-    const signin = () => {
-        log('signing in: ', getSignInLink())
-        const signInLink = getSignInLink()
-        //todo: change to the other thing?
-        window.location.href = signInLink;
+    const signinWithCode = async (code: string, state?: string): Promise<{ success: boolean, error?: string }> => {
+        try {
+            log('signinWithCode called with code:', code)
+            
+            if (!code || typeof code !== 'string') {
+                return { success: false, error: 'Invalid authorization code' }
+            }
+
+            if (state) {
+                const storedState = await storageAdapter.get(STORAGE_KEYS.AUTH_STATE)
+                if (storedState && storedState !== state) {
+                    log('State parameter mismatch:', { provided: state, stored: storedState })
+                    return { success: false, error: 'State parameter mismatch' }
+                }
+            }
+
+            await storageAdapter.remove(STORAGE_KEYS.AUTH_STATE)
+            cleanOAuthParamsFromUrl()
+
+            const token = await fetchToken(code)
+            
+            if (token) {
+                log('signinWithCode successful')
+                return { success: true }
+            } else {
+                return { success: false, error: 'Failed to exchange code for token' }
+            }
+        } catch (error) {
+            log('signinWithCode error:', error)
+            return { 
+                success: false, 
+                error: (error as Error).message || 'Authentication failed' 
+            }
+        }
     }
 
-    const signout = () => {
+    const signout = async () => {
         log('signing out!')
         setUser({})
         setIsSignedIn(false)
         setToken(null)
+        
         document.cookie = `basic_token=; Secure; SameSite=Strict`;
-        localStorage.removeItem('basic_auth_state')
-
-        // if (syncRef.current) {
-        //     // WIP - BUG - sometimes connects even after signout
-        //     syncRef.current.disconnect()
-
-            
-        // }
+        document.cookie = `basic_access_token=; Secure; SameSite=Strict`;
+        await storageAdapter.remove(STORAGE_KEYS.AUTH_STATE)
+        await storageAdapter.remove(STORAGE_KEYS.REFRESH_TOKEN)
+        await storageAdapter.remove(STORAGE_KEYS.USER_INFO)
         if (syncRef.current) {
             (async () => {
                 try {
-                    await syncRef.current.close()
-                    await syncRef.current.delete({disableAutoOpen: false})
+                    await syncRef.current?.close()
+                    await syncRef.current?.delete({disableAutoOpen: false})
                     syncRef.current = null
                     window?.location?.reload()
                 } catch (error) {
@@ -481,7 +693,32 @@ export function BasicProvider({ children, project_id, schema, debug = false }: {
     const getToken = async (): Promise<string> => {
         log('getting token...')
 
+
         if (!token) {
+            // Try to recover from storage refresh token
+            const refreshToken = await storageAdapter.get(STORAGE_KEYS.REFRESH_TOKEN)
+            if (refreshToken) {
+                log('No token in memory, attempting to refresh from storage')
+                try {
+                    const newToken = await fetchToken(refreshToken)
+                    if (newToken?.access_token) {
+                        return newToken.access_token
+                    }
+                } catch (error) {
+                    log('Failed to refresh token from storage:', error)
+                    
+                    if ((error as Error).message.includes('offline') || (error as Error).message.includes('Network')) {
+                        log('Network issue - continuing with potentially expired token')
+                        const lastToken = localStorage.getItem('basic_access_token')
+                        if (lastToken) {
+                            return lastToken
+                        }
+                        throw new Error('Network offline - authentication will be retried when online')
+                    }
+                    
+                    throw new Error('Authentication expired. Please sign in again.')
+                }
+            }
             log('no token found')
             throw new Error('no token found')
         }
@@ -491,8 +728,24 @@ export function BasicProvider({ children, project_id, schema, debug = false }: {
 
         if (isExpired) {
             log('token is expired - refreshing ...')
-            const newToken = await fetchToken(token?.refresh)
-            return newToken?.access_token || ''
+            const refreshToken = token?.refresh_token || await storageAdapter.get(STORAGE_KEYS.REFRESH_TOKEN)
+            if (refreshToken) {
+                try {
+                    const newToken = await fetchToken(refreshToken)
+                    return newToken?.access_token || ''
+                } catch (error) {
+                    log('Failed to refresh expired token:', error)
+                    
+                    if ((error as Error).message.includes('offline') || (error as Error).message.includes('Network')) {
+                        log('Network issue - using expired token until network is restored')
+                        return token.access_token
+                    }
+                    
+                    throw new Error('Authentication expired. Please sign in again.')
+                }
+            } else {
+                throw new Error('no refresh token available')
+            }
         }
 
         return token?.access_token || ''
@@ -503,8 +756,8 @@ export function BasicProvider({ children, project_id, schema, debug = false }: {
         if (document.cookie && document.cookie !== '') {
             const cookies = document.cookie.split(';');
             for (let i = 0; i < cookies.length; i++) {
-                const cookie = cookies[i].trim();
-                if (cookie.substring(0, name.length + 1) === (name + '=')) {
+                const cookie = cookies[i]?.trim();
+                if (cookie && cookie.substring(0, name.length + 1) === (name + '=')) {
                     cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
                     break;
                 }
@@ -514,24 +767,79 @@ export function BasicProvider({ children, project_id, schema, debug = false }: {
     }
 
     const fetchToken = async (code: string) => {
-        const token = await fetch('https://api.basic.tech/auth/token', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify({ code: code })
-        })
-            .then(response => response.json())
-            .catch(error => log('Error:', error))
+        try {
+            if (!isOnline) {
+                log('Network is offline, marking refresh as pending')
+                setPendingRefresh(true)
+                throw new Error('Network offline - refresh will be retried when online')
+            }
 
-        if (token.error) {
-            log('error fetching token', token.error)
-            return
-        } else {
-            // log('token', token)
-            setToken(token)
+            const token = await fetch('https://api.basic.tech/auth/token', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ code: code })
+            })
+                .then(response => response.json())
+                .catch(error => {
+                    log('Network error fetching token:', error)
+                    if (!isOnline) {
+                        setPendingRefresh(true)
+                        throw new Error('Network offline - refresh will be retried when online')
+                    }
+                    throw new Error('Network error during token refresh')
+                })
+
+            if (token.error) {
+                log('error fetching token', token.error)
+                
+                if (token.error.includes('network') || token.error.includes('timeout')) {
+                    setPendingRefresh(true)
+                    throw new Error('Network issue - refresh will be retried when online')
+                }
+                
+                await storageAdapter.remove(STORAGE_KEYS.REFRESH_TOKEN)
+                await storageAdapter.remove(STORAGE_KEYS.USER_INFO)
+                document.cookie = `basic_token=; Secure; SameSite=Strict`;
+                document.cookie = `basic_access_token=; Secure; SameSite=Strict`;
+                
+                setUser({})
+                setIsSignedIn(false)
+                setToken(null)
+                setIsAuthReady(true)
+                
+                throw new Error(`Token refresh failed: ${token.error}`)
+            } else {
+                setToken(token)
+                setPendingRefresh(false)
+                
+                if (token.refresh_token) {
+                    await storageAdapter.set(STORAGE_KEYS.REFRESH_TOKEN, token.refresh_token)
+                    log('Updated refresh token in storage')
+                }
+                
+                document.cookie = `basic_access_token=${token.access_token}; Secure; SameSite=Strict; HttpOnly=false`;
+                log('Updated access token in cookie')
+            }
+            return token
+        } catch (error) {
+            log('Token refresh error:', error)
+            
+            if (!(error as Error).message.includes('offline') && !(error as Error).message.includes('Network')) {
+                await storageAdapter.remove(STORAGE_KEYS.REFRESH_TOKEN)
+                await storageAdapter.remove(STORAGE_KEYS.USER_INFO)
+                document.cookie = `basic_token=; Secure; SameSite=Strict`;
+                document.cookie = `basic_access_token=; Secure; SameSite=Strict`;
+                
+                setUser({})
+                setIsSignedIn(false)
+                setToken(null)
+                setIsAuthReady(true)
+            }
+            
+            throw error
         }
-        return token
     }
 
 
@@ -546,22 +854,22 @@ export function BasicProvider({ children, project_id, schema, debug = false }: {
             get: async () => {
                 checkSignIn()
                 const tok = await getToken()
-                return get({ projectId: project_id, accountId: user.id, tableName: tableName, token: tok })
+                return get({ projectId: project_id, accountId: user?.id, tableName: tableName, token: tok })
             },
             add: async (value: any) => {
                 checkSignIn()
                 const tok = await getToken()
-                return add({ projectId: project_id, accountId: user.id, tableName: tableName, value: value, token: tok })
+                return add({ projectId: project_id, accountId: user?.id, tableName: tableName, value: value, token: tok })
             },
             update: async (id: string, value: any) => {
                 checkSignIn()
                 const tok = await getToken()
-                return update({ projectId: project_id, accountId: user.id, tableName: tableName, id: id, value: value, token: tok })
+                return update({ projectId: project_id, accountId: user?.id, tableName: tableName, id: id, value: value, token: tok })
             },
             delete: async (id: string) => {
                 checkSignIn()
                 const tok = await getToken()
-                return deleteRecord({ projectId: project_id, accountId: user.id, tableName: tableName, id: id, token: tok })
+                return deleteRecord({ projectId: project_id, accountId: user?.id, tableName: tableName, id: id, token: tok })
             }
 
         }
@@ -582,13 +890,14 @@ export function BasicProvider({ children, project_id, schema, debug = false }: {
             user,
             signout,
             signin,
+            signinWithCode,
             getToken,
             getSignInLink,
             db: syncRef.current ? syncRef.current : noDb,
             dbStatus
         }}>
             
-            {error && <ErrorDisplay error={error} />}
+            {error && isDevelopment() && <ErrorDisplay error={error} />}
             {isReady && children}
         </BasicContext.Provider>
     )
@@ -615,11 +924,6 @@ function ErrorDisplay({ error }: { error: ErrorObject }) {
     </div>
 }
 
-/*
-possible errors: 
-- projectid missing / invalid
-- schema missing / invalid
-*/
 
 export function useBasic() {
     return useContext(BasicContext);